Nishant Rao Guvvada

Hi. I'm Nishan Guwada. I'm currently working as a visualization and analytics specialist at Rackspace Technology. My skill set includes SQL, Python. I'm currently learning JavaScript, React, and Express, basically the Monstera. My professional journey began as a PA developer, building dashboards and reporting solutions and even automating subprocessors using Python. Due to my inclination towards Python and automation, I was given opportunities to get into the machine learning side of things. For the past 3 years, I've been involved in multiple machine learning projects. During my tenure at better.com, which is an online mortgage provider, I created a proof of concept of a mortgage approval prediction system, and that was using a simple logistic regression. My tenure at Better was for around 2 years. Better is a startup when I had joined it. During my tenure here at Rackspace, I was again due to my inclination into machine learning and I think I was recommended for Google's advanced solution lab for machine learning, which is a 2-month cohort, where they brief you about the basics of machine learning, as well as utilizing their own tools such as Vertex AI, AutoML, etc. During my tenure at Better, I've been involved in multiple machine learning projects such as building a churn prediction system using the land and forest. That was also a POC. One of the projects that I moved to production was via data deliver, which is an enterprise-level chatbot. It is meant for providing insights into basically if a particular information exists in a particular place within the enterprise. That particular chatbot was backed by a rack-implemented system. So, the chatbot has only context with regard to the form and nothing else. That's something I don't tell production. In my company, we have different teams for building the model and then deploying the model. We have different teams, and I've been part of both teams for a certain capacity. And I'm looking forward to a full-time machine learning role because, right now, I'm a cross-functional resource. I'm trying to enroll again to look into reporting solutions and automation. But I'm also working in machine learning as a cross-functional resource.

In order to deploy a Python-based machine learning model to a production environment, there are multiple stages and steps that need to be followed. The first step is building a base model and iteratively building models and defining those models until you get a satisfactory model that gives you a level of precision or accuracy or whatever metric that you are following. Until you achieve that metric, you keep on iterating and improving your model and refining your data if required in order to get that level of satisfaction. Once that is done, in order to deploy a model to production, there are multiple ways. I have personally used hosting sites such as Replicate, Hugging Face, as well as Streamlit. I can just download the model using the pickle library. We can save the model, even in TensorFlow. We can save the model and upload those models to a particular container and upload those models to the hosting environment and run those models there. I have done that personally on Huddle Phase and Streamlit, as well as Replicate. But if I talk about the enterprise level, move to production, I have personally done it using Google's platform. The Google Vertex AI is basically Google's AI platform where you can deploy your machine learning products to an endpoint, basically. And using that endpoint, where the particular model is hosted, you can utilize that to make predictions or you can use that particular API and connect it to a front end built on whatever you like Flutter or yeah.

There are multiple feature selection techniques that can be implemented within a dataset. Some of the feature selection techniques are such as the recursive feature selection. You can train a particular model recursively, giving the model incrementally the number of features, increasing the number of features every time in every iteration you feed to the model. What that does is that basically trains the model with a minimum number of features and keeps on increasing that feature or keeps on decreasing the number of features. That depends on the type of technique that you apply. The one I'm talking about is recursive feature elimination where you give a particular model a set of features, and you train the model on those set of features. And then in the next cycle of training or the next iteration, you reduce the number of features and train it again. What happens is the best model performance is achieved when you give the correct number of features, and that is how you are able to select those features. There are other metrics that can be used such as correlation and covariance. Some other metrics are chi squared as well as ANOVA score. You can utilize these to select the features. These are some of the techniques that you can apply on the dataset to extract out the best features. If I talk about a library, a Python library called scikit-learn. That library provides some feature selection techniques that I just stated. But along with that, a random forest classifier also has a feature selection capability. And the library provides that particular capability along with the random forest. And you can use that random forest feature selection to get the correct number of features that is ideal for the model to perform the best.

There are multiple techniques that can be taken or methods that can be applied to mitigate overfitting. Firstly, overfitting is when the model is trained and the model understands or learns the data very well. At least, that is what is presented or appears to be. But when you give the same model new data that it has not seen, then you see that the accuracy of the prediction is not that good. This is because the model has kind of learned the data itself, and that is overfitting. The steps that you can take in cases of overfitting is basically if you can increase the dataset, the size of the data, so that the model has enough data to basically generalize. You can also utilize Lasso and Ridge regularization techniques, which are basically in mathematical terms, adding a particular term to the cost function so that now the model not just has to minimize the cost function, but another term that has been added to the cost function. Generally, that term for lasso regression is the modulus of the weights, and in terms of Ridge regression, it is basically the squared of the weights. So it is basically Manhattan distance for Lasso and Euclidean distance for Ridge regularization technique. These are the two methods that you can use. You can also increase the complexity of the model in order to mitigate overfitting. And in that manner, you can achieve a better performing model. In supervised learning models, because you have all the labels there, it is generally better to give the model more data, so that it does not memorize the training data.

There are certain libraries that can be used, such as the SIS library and the PSUTIL library. We can utilize these libraries to perform multi-threading. That means that the execution will happen parallelly. In the code itself, you can flip some of the flags to true in order to execute the code parallelly. You can utilize that in order to get the Python script to run parallelly, since you can have it on a multi-core machine. Currently, I am unable to name the exact library that can perform multi-threading. I believe it is the SIS and the PSUTIL library because it can also provide you with information on how much memory your Python script is actually taking. In TensorFlow, there's a certain flag that you can utilize. I believe the name of the flag is auto-tune, which enables the processing of machine learning use cases.

Certainly, I can talk about the machine learning project, where we had to optimize the Python code to meet the memory and computational budget. So in terms of memory, there are certain libraries such as psutil, the SIS library, the resource library, and the module that can help us visualize or see the amount of memory that is being utilized by our Python code. And in order to optimize a Python code, we basically utilize generators instead of lists, which captures a lot more memory. We cleaned up the code where certain variables were not being used anywhere else. We cleaned the code and optimized it in that manner. We used generators, obviously, instead of lists. So these small changes basically help us in utilizing less memory for a certain amount of Python code. And that helped us in working within the constraints of the budget that we had. Also, I worked on a project called BI Data Delivered. It's basically a chatbot that provides a code summarization or helps you locate information within the data warehouse that we have, which is Google's BigQuery. Because all the components of the model were posted and trained on Google, we used Abel to build that model and work on it. So there, we already have the metrics that we can see for how much we're spending to train the model, to run our query, and stuff like that.

In the Python code snippet, the normalized data function is receiving data, in this case, as a list, as input. We are utilizing NumPy to calculate the mean of that list of the elements in the list. We are also calculating the standard deviation from the list. Normalized data is basically every element of the list subtracted by the mean and divided by the standard deviation. I believe because we are dealing with a list, subtracting the mean from the list and dividing it using the standard deviation. The normalized data needs to be a list again. I believe this should have been an iteration so that every element is subtracted by the mean and divided by the standard deviation. And the normalized data is being returned. I think this is something that we can do. There are other methods to normalize as well such as min max scaling, which is dividing each element of the data by the subtraction of the maximum value.

So in this particular function, we are given predictions and labels as the arguments. The correct predictions are a sum of one every time the prediction is equal to the label. We can also add an else clause which says 0 if the prediction is not equal to the label. Total predictions is equal to the length of the predictions. Accuracy is given by correct predictions divided by total predictions, and we are returning the accuracy.

The main strategy of writing clean and maintainable code in machine learning projects is creating modules based on the functions. Never write the whole machine learning code in a single script. The best strategy is to divide the code basis on the type of function or the type of aim or goal that is being tried to be achieved. As an example, we can create a different module in order to reprocess the data. That's a model for training the data, the machine learning model, and so on. In that manner, we have a structured and clean code. We can also write clean code by utilizing data structures, such as classes and functions, in order to create and write daily clean code, so that everything is wrapped in a particular class that signifies a certain function. So the first one was dividing the script into modules and other scripts. The second one is utilizing the classes concept. The other thing is writing comments in order to have the code daily explainable, especially in machine learning projects, there are certain lines of code that need to be actually explained. So comments are something that would be really handy for other developers who work with the code.

Python facilitates the comparison and decision-making process because there are multiple libraries that we can utilize to run our model, such as the SK learn library. We can utilize models from there. We can run multiple models or train multiple models on a particular set of data, and run them to understand their metrics, the accuracy they are achieving. And based on those metrics, if it's accuracy, then we can utilize this particular metric as a decision threshold for making decisions, whether we want a model that is providing this much accuracy versus the other model. Because Python is so widely used, and we have multiple libraries that provide machine learning models that we can run in a few lines of code, it becomes very easy for us to compare and make decisions.

I would say that some of the libraries that help us understand memory requirements and write optimized codes such as PSUTIL, as well as the resource module. They are modules that help us write optimized codes because that helps us give the memory being used for a particular script or function. Because Python is executed at runtime, and the execution happens line by line. So it has a better language for debugging.