Artificial intelligence has numerous interesting branches, we will be discussing a branch of AI which is called Computer Vision.

Computer vision (CV) is a branch of artificial intelligence (AI) that allows computers and systems to extract useful information from digital photos, videos, and other visual inputs, as well as to make meaningful decisions based on those data.

Computer vision has numerous subfields which include Image classification, Image segmentation, scene reconstruction, object detection, event detection, video tracking, object recognition, 3D pose estimation, learning, indexing, motion estimation, visual servoing, and 3D scene modeling, and image restoration.

In this piece, we shall be focusing on a subfield in CV known as Image classification. Image classification is the task of assigning a label to an image from a predefined set of categories. In practice, this implies that we must analyze an input image and then produce a label that categorizes it. The label is always chosen from a predetermined set of options.

In this article, we would be building a model using transfer learning(pre-trained models)to classify if a plant has been affected by a fall armyworm using the images of the plant. The data source for this task is the Makerere Fall Armyworm Crop Challenge data on Zindi.

The data for this project has a train.CSV file that contains the 1,619train images name and Labels, a test.CSV file that contains the 1,080 image names only, and the Images folder which contains the 2,699 images for the train CSV and test CSV. I would be using Google colab as the IDE for this project. After downloading and uploading the data on your drive, you mount the drive.

Then import all the necessary libraries. For this project, we would be using the Tensorflow and Keras framework. I choose this framework because it is easy to use, flexible and both have simpler APIs.

The libraries are now imported, it’s time to load the data.

Let’s check what the data looks like;

We can see that the train images CSV file contains the Image_id and the labels. Where 1 indicates that the image has been affected by a fall armyworm and 0 if it has not been affected.

The test data does not have a Label column because it is what we are classifying after building the model. Let’s give a variable name to the path of the image directory.

Now, we would be merging the images_path with the train [‘Image_Id] so that the train [‘Image_Id] column in the csv file will have the full image path.

The train [‘Image_Id] column of the train CSV file now has the train images full path containing 1,619 image file paths. We would do the same for the test CSV.

Let’s now preprocess the data for modelling. As I said earlier we would be using Tensorflow.keras framework for this project. Tensorflow.keras framework has different ways of loading and augmenting data into the model. For this project, we would be using the ImageDataGenerator to augment the images and .flow from_dataframe to load the data. After rescaling all the images to a particular size we then augment the images.

Note: It is not compulsory to augment image data, we only augment image data to improve the performance and the outcome of the model by forming new and different examples to the train and validation datasets

When you use the .flow from_dataframe data loader, pass in the csv file, the image_id as the x column ,the target as the y column, the target_size of the images the class_mode, subset,seed and batch _size. There are other arguments you can pass in depending on what you want to do.

For the test data loader we put the y_col as None because that is what we are predicting.

Let’s build our model!!!!!

In image classification, deep learning models require training from scratch, which is computationally expensive and requires a large amount of data to achieve high performance. On the other hand, using a pre-trained model is what we call Transfer Learning. Transfer Learning is a method in machine learning where a model developed for a task is reused as the starting point for a model on another similar task. Transfer learning is computationally efficient and helps achieve better results using a small amount of data. For this project, we are using a pre-trained model to classify the plant image which is infected or uninfected.

We have several pre-trained models for image classification. Examples are VGG16, VGG19, InceptionV3, ResNet50, ResNetV2, etc. These pre-trained models have been trained on millions of images making it easier to perform better on our data.

Let’s import the pre-trained model we are using.

We would be using VGG19 as our pretrained model. VGG19 is a variant of the VGG model which consists of 19 layers (16 convolution layers, 3 fully connected layers, 5 MaxPool layers, and 1 SoftMax layer).

Now, we are done importing the pre-trained model. We would not be loading the output layer for the model, because the VGG19 model was initially trained with the ImageNet database that contains a million images of 1000 classes. Since we are working on a binary image classification we, therefore, freeze the initial output layers that have 1000 classes and add our output layer. We freeze the output layer by putting False to the include_top argument. VGG19 takes the input shape of the images 224x224 size.

In the above code we set our trainable argument to false because we don’t want the VGG19 model’s weight to interfere with our current data so we freeze the weight of the pre-trained model.

Let’s add our output layer .

Let’s compile the model using Adam as the optimizer, loss as binary_crossentropy, because it’s a binary image classification and metrics as Accuracy score

Let’s check for the summary

The above image is the output when you run the model.summary() code, it brings out the layers of the model. We can also see that there are 26,447,682 total parameters for the model, of which 6,423,298 are trainable parameters. The remaining 20,024,384 are non-trainable parameters, which are the weights we froze.

Let’s now train the model!!!

To train our model we pass in the train data, validation data, epochs, and steps_per_epochs this is the number of unique samples of your dataset divided by the batch size and the verbose. The verbose will show the output of the model while training.

Wow!!! The accuracy of our model is 98.4%. Let’s now create a submission CSV file by using the model to classify the images in the test data set.

When we print out the predictions, we get two values which are the probability of each label being the actual value. This can be quite confusing, to avoid this we use the argmax() function from the Numpy library. The argmax function prints the index of the maximum value. If the first value is maximum it prints out 0, if the second value is maximum it prints out 1.

Now we have converted the prediction probability to target labels

The submission csv contains the test.csv file image_id , let’s read the submission CSV file and create a Label column

When this code is done executing , a new csv file called my_submission csv will be created on your drive. This is what you will download and upload as your submission .

Finally, we have a model that can predict if a plant is infected or uninfected. I recommend you try out other pre-trained models and compare their accuracy scores.

For more clarifications on this project check out my GitHub portfolio.

Thank you for reading all through, I hope this article is useful and of benefit to you. Don’t forget to read, practice, learn, clap and share.

Machine learning (ML) is a subfield of artificial intelligence (AI) that focuses on developing systems that learn from the data they consume to improve their performance. Most AI applications execute with ML models, and most beginners are unaware that there is a step-by-step process for creating an ML model.

We’ll go over the processes for creating a machine learning model in this article. The following is a step-by-step approach to building a machine learning model:

(1)Understanding the problem: Understanding the problem is the first step in creating a machine learning model, once the problem is understood, it provides us with a structured way to solve it.

(2)Data collection: The practice of collecting and acquiring data from a variety of sources is known as data collection. Data must be collected and kept in a form that makes sense for the problem at hand to be used to develop viable artificial intelligence (AI) and machine learning solutions. The accuracy of a machine learning model is only as good as the data used to train them. Different websites serve as a source of data for ML projects e.g Kaggle, Zindi, UCL machine learning repository.

(3)Data Preprocessing: As we know we can’t work with raw data, we must transform the data into an understandable format by preprocessing the data. There are various preprocessing methods for the various data type. Data preprocessing is considered one of the crucial phases in developing a machine learning model because it prepares the data in the most meaningful way for the subsequent data modeling.

(4)Data Modelling: The data is ready for training and testing at this point. We may now select a model and train the data on it. When it comes to selecting a model. You can choose from a variety of models based on your data. The model selection process includes classification, regression, clustering, and other methods. You will now be required to train datasets for them to run smoothly. Several algorithms and techniques are used in the stage of training and testing the machine model.

(5)-Model Evaluation: The outcome of the model can be used to evaluate the model. Model evaluation is done by using evaluation metrics such as accuracy score, Root Mean Square Error(RMSE), confusion metrics, classification report, Mean Square Error (MSE), and so on to be able to check the quality of the data. This stage ensures that a machine learning model is of high performance.

(6)-Model improvement: After checking your model’s performance by evaluating it with some metrics, there could be an improvement if the model is not performing as expected. So this stage is an optional one.

(7)-Model deployment: The model is now ready to be put into production to test how it performs in the real world. It could be deployed as a web app or anything you wish it could be

Finally, these are the steps needed to build a machine learning model. Thank you for reading this far; I hope you now have a clear understanding of how to build a machine learning model. Remember to read, learn, practice, clap, and share what you’ve learned.

Breast cancer is a disease in which the cells of the breast grow out of control. A breast cancer tumor can be benign (meaning it is not harmful to one’s health) or malignant (meaning it is harmful to one’s health) (has the potential to be dangerous). Benign tumors are not cancerous because their cells have a similar appearance to normal cells, they develop slowly, and do not invade neighboring tissues or spread to other parts of the body. Malignant tumors are cancerous. Malignant cells can eventually expand beyond the original tumor to other regions of the body if left untreated.

Deep learning is a subset of machine learning that is essentially a neural network with three or more layers. These neural networks aim to imitate the activity of the human brain by allowing it to “learn” from large amounts of data. Deep learning is a machine learning technique that allows computers to learn by example in the same way that humans do. Deep learning is a critical component of self-driving automobiles, allowing them to detect a stop sign or discriminate between pedestrians and lamppost. It enables voice control in consumer electronics such as phones, tablets, televisions, and hands-free speakers. Deep learning has gotten a lot of press recently, and with good cause. It’s accomplishing previously unattainable accomplishments.

In deep learning, a computer model learns to perform classification tasks directly from images, text, or Sundeep learning models can attain state-of-the-art accuracy, even surpassing human performance in some cases. Models are trained using a huge quantity of labeled data and multilayer neural network architectures.

In this article, I would be walking you through how to classify with deep learning whether a breast cancer tumor is benign or malignant.

The whole process is broken down into 4 stages;

• Data Collection.
• Data cleaning and preprocessing
• Building Neural Network
• Making a predictive system

Data collection: The data used for this project is the publicly available dataset from Kaggle titled ‘Breast Cancer Wisconsin (Diagnostic) Data Set’. Here is the link.

Data cleaning and preprocessing: Importing libraries and datasets is the initial step in data cleaning and preprocessing. A Python library is a group of related modules that may be called and used together. Pandas (for data analysis), Numpy (for numerical operations), Seaborn (for data visualization and exploratory data analysis), and matplotlib.py plot( for data visualization and graphical plotting). The “import” keyword can be used to access and use these libraries.

import all the necessary libraries

To be able to access the dataset from the drive ,we must make sure we mount the google drive

After mounting the drive, load and read the dataset

The above shows the sample of the dataset

From the above code, we can see that the data contains 569 rows and 33 columns.

Let’s drop the columns which aren’t needed for the prediction

After dropping the unneeded columns, we can see that we now have31 columns.

Let’s take a look at the dataset

The above shows that we have 569 data entries.

The above shows the statistical measures of the dataset.

Let’s check for categorical features

Here we see that the target column which is the diagnosis is the only categorical column in the dataset. Let’s check for the distribution of the target column.

The image above shows the value counts for the target column.

In my previous article, I talked about how to transform categorical features into numerical features using LabelEncoder. So we are going to encode the distribution of the target column into numerical features.

Now, the label encoder has given each target value a unique integer value.

0-Benign

1-Malignant

Let’s take a look at the data.

Our data is ready for modeling!!!!

Now, we would split our data into X and y. X will contain the features and y will contain the target which is the diagnosis.

Splitting the data into Test and Train

To ensure that the data is internally consistent, we will use the standard scaler function from the sklearn.preprocessing library. Data standardization helps to increase the quality of your data and improve the accuracy of the model ,you can read more about data standardization.

Now that the data has been cleaned and preprocessed, the next stage is building the neural network.

• Building Neural Network: To train this data, we’d build a three-layer network.

Hence, we’d import the TensorFlow library, set the seed, specify a value, and import Keras from TensorFlow. Tensorflow is a deep learning library created by google used to create neural networks. Here is the documentation. Keras is an open-source software library for artificial neural networks, it serves as a user interface for TensorFlow. Here is the documentation

Let’s create the neural network by calling the keras.Sequential() function. Sequential groups a linear stack of layers into a tf.keras.Model.

keras.layers.Flatten: this layer is the input layer, and it’s responsible for converting data into a one-dimensional array so that it may be passed on to the next layer. All of the feature columns are taken in this layer.

keras.layers.Dense: this is the hidden layer, where every neuron in the previous and next layers is connected to every other neuron in this layer. This layer is in between the input and output layers, it also contains the given number of neurons and activation function.

keras.layers.Dense: this is the output layer, it contains the number of target values and the activation function.

An activation function is a very important feature of an artificial neural network, they decide whether the neuron should be activated or not.

We then compile the neural network after it has been created. Compilation of neural networks is a process in deep learning that converts the previously created basic sequence of layers into a highly efficient series of matrix transformations. Compilation can be thought of as a stage before computing that allows the computer to train the model. The compilation is performed using one single method which is shown below

Optimizer: An optimizer is a function or algorithm that modifies the characteristics of a neural network, such as its weights and learning rate. As a result, it aids in the reduction of total loss and the improvement of accuracy.

Loss: the loss function in a neural network quantifies the difference between the expected outcome and the outcome produced by the machine learning model.

Metrics: A metric is a function that can be used to assess your model’s performance. Metric functions are similar to loss functions, except that the outcomes of assessing a metric are not included in the model’s training.

The next stage is to train the neural network.

From this, we can see that the loss function and accuracy are inversely proportional. The lower the loss function the higher the accuracy of the neural network and vice versa.

Let’s check the accuracy of the test data set.

Building a predictive system: This is the most interesting part of this project. Now we are going to be building a predictive system.

The above code and output show the probability of the first data point labels as 0 and the probability of the second label as 1. So we can say that the model is 64% sure that the output is 0(Benign) and 43% sure that the output is 1(Malignant). So when we print out y.pred we get two values which are the probability of each label being the actual value. This can be quite confusing, to avoid this we use the argmax() function from the Numpy library, the argmax function prints the index of the maximum value. If the first value is maximum it prints out 0, if the second value is maximum it prints out 1.

Now we have converted the prediction probability to target labels

Now, we have successfully built a deep learning model that can predict if a breast cancer tumor is Benign or malignant.

To test if your model is accurate you could just copy and paste a data point from your dataset and pass it into the input() and run the code. You can view the code on my GitHub portfolio.

Deep learning models may not be the best approach for this project, given the complexities of deep learning models.
It is a recommended practice in machine learning to experiment with basic models before moving on to more complicated model approaches like neural networks, which are the foundation for deep learning. So I recommend you try out some machine learning models with this dataset.

Thank you for reading all through, I hope you now have a clear understanding of this project. Don’t forget to read, learn, practice, clap and share.

In my last article, I built a model that can predict the annual salaries of data scientists. In this article, we will be deploying that model to create a Machine Learning web app that can predict the annual salaries of data scientists.

Before creating the ML web app, we must save the model, and we do this by using the library called pickle. Pickle is the standard way of serializing objects in Python. You can use the pickle operation to serialize your machine learning algorithms and save the serialized format to a file.

After importing the pickle, we save the model, the label encoder for the country, and edlevel which is lb_country, lb_edlevel saved inside a dictionary. We then open a pickle file in the write binary mode “wb”, then dump the data into the file.

After running the code above, the pickle file(Saved_step.pkl) will be saved automatically on our google drive directory. We can check it again by loading it again in the read binary format “ rb”. We can access the model, the label encoder for the country, and edlevel which is lb_country, lb_edlevel by giving them a key.

Now that we are through with saving the model. Next thing to do is to deploy this model into a web app using streamlit.

Streamlit is an open-source python framework for creating and sharing web apps and interactive dashboards for data science and machine learning projects

Open the editor of your choice, I would be using visual studio code. Inside the Vscode, open a folder containing the dataset, colab notebook, and the pickle file we created (Saved_step.pkl).

Create three new files called app.py, predict_page.py for the prediction page, and explore_page.py. for the explore page.

For the predict_page.py page, we import all the libraries used which are streamlit, numpy , and pickle

After running the above code, we load and execute our data by writing a function.

Now, we want to access the keys to the model and label encoder for country and edlevel.

Now, let’s create a function containing streamlit widgets.

In order for us to run these codes, we would input “streamlit run predict_page.py ” in the terminal to activate the terminal, then we go to our app file to import streamlit as st and import show_predict_page.

After doing all these, input streamlit run app.py in the Vscode terminal.

The above output is what is going to show in the browser.

The next thing we are going to add to the predict_page are two select boxes to the countries and edlevel.

The select box can contain a list or a tuple but we will be using a tuple here since the country and edlevel are tuples.

After doing all these, click save, go back to your browser and click rerun.

The above is the output it shows.

When you click on the country, it brings out the list of countries ;

When you click on education, it brings out the list of education levels.

For the years of experience, we would create a slider by calling the slider method and giving it a min -value, max value, and default value

Click save and rerun in your browser

This is what it looks like when runned.

Now let’s add a button to calculate the salary after filling in all the information needed. We would call the button method and assign it to a variable.

Click save and rerun in the browser

The above is the output after rerunning.

You get the estimated salary after clicking the “Calculate Salary” button.

Now that we are done with the prediction page, let’s take an example where we have the country to be Canada, education level to be master’s degree, and 10 years of experience.

When we click the calculate salary button we have:

If you followed all the steps above, your prediction page should have these contents in your browser.

We now have the prediction page ready, we are going to create a sidebar and add the second page called the explore page.

To create a sidebar, go to the app.py file and create a sidebar and selectbox method, passing the first and second argument.

The above is the result.

The only thing left to do is to implement the explore page.

For that import all the libraries

The reason we imported the zip file is that our dataset is in the zip format.

Now we are going to clean and load the data the same way we did in the notebook in the previous article. To do this, we will copy all the functions we used to clean the data.

After cleaning and loading this data, we will apply all the transformations we did.

To avoid having the model reloaded, we are going to use a function decorator called st.cache decorator. st.cache is a function decorator that helps to improve speed performance and memory consumption of the model.

On the explore page we will be displaying three charts a pie chart, a bar chart, and a line chart.

For the pie chart, we would be plotting the value_counts of the countries, we would do it by calling the value_counts() method and putting it in a pie chart using matplotlib. pyplot library.

To show everything we have done on the export page on the web app we would add some changes in the app.py file .

Click save and rerun the browser .

Let’s plot the next bar chart.

For the bar chart, we are going to be plotting the Mean salary based on the country.

Click save and rerun

Now we see the mean salary for each country.

The last chart is the line chart.

We would be plotting the mean salary based on the years of experience

Save and re-run the explore page

Now we are through deploying our model.

At the end of the deployment, this is how the web app should look like

This is the link to my web app ,you can also view the code on my GitHub portfolio

Thank you for reading all through, I hope you now have a clear understanding of this project. Don’t forget to read, learn ,practice and clap under the article.

Data Science is a very broad industry that has birthed many other recent data roles such as data analysis, machine learning engineering, data engineering, analytics engineering, and a few others. While some people have these roles well defined, others work across many of these branches without even knowing.

I recently stumbled upon a dataset that contains details of data scientists’ earnings/salaries across some countries, based on their education level and years of experience, so I thought it would be interesting to explore.

This article will be giving details of the project on data scientists’ annual salary predictions, which I worked on.

Prerequisites to understand this project include :

• Basic knowledge in Python programming
• An understanding of data science

The whole process is broken down into 4 stages;

• Data Collection.
• Data Preprocessing
• Model Building
• Model Deployment

Data Collection: Data salaries are not easily available as HR personnel claims they are proprietary. Therefore, we resorted to using the publicly available data from Stack Overflow Annual Developer Survey. Here is the link

Stack Overflow

Data Cleaning and preprocessing: The first step in data cleaning and preprocessing is importing the libraries and dataset. A python library is a collection of related modules that can be called and used. I would be using four main libraries which are pandas (for data analysis), Numpy (for numerical operations), seaborn (for data visualization and exploratory data analysis), and matplotlib.pyplot ( for data visualization and graphical plotting). These libraries can be called and used with the help of the “import” keyword.

Importing all the necessary libraries

Import and load the dataset from the drive: Since I used google colab I had to import and load the dataset from drive.

The above shows the sample of the dataset.

The dataset above contains 64461 rows and 61columns.

Let’s start cleaning!!!

Selecting and keeping the columns/features needed for the prediction: When building a machine learning model in real-life, features selection is very important because it’s almost rare that all the features in the dataset are useful to build a model. So we selected only a few columns needed for the prediction in order not to bother the user with having to fill in too much unnecessary information. The columns are Country, Edlevel which is the education level, YearsCodePro which is the number of years of experience, Employment (full-time or part-time), ConvertedComp (the annual salary in dollars) this feature is still going to be renamed.

Dealing with Missing Values: I would be using the columns where the salary is available, so I will be dropping columns with Nan salary.

Let’s take a quick look at the dataset

Here we see that we have 34,025 data entries, three columns are objects which means they are strings, only the salary column is a float. So we would be dropping the rows where the columns are not numbers.

I dropped the employment columns since it wasn’t really needed for the prediction. Let’s take a quick look at our dataset again

Now we would be cleaning each of the columns data

I would start with the country data

The value_counts() function in python will return the series containing counts of unique values. The resulting object will be in descending order so that the first element is the most frequently-occurring element. Here we see that the U.S.A has the most data and we have some countries with one data point which we will get rid of because our model can not learn from just one data point.

We will be cleaning our country column with the use of the function above after naming the function “shorten_categories”, we fix a cut-off value. If the number of data points for each country is greater than the cut-off value we keep it. Other wise we combine it to a new category called ‘Other’.

Now, after running the above we discovered that the new category we created has the most data points.

I would like to look at the relationship between the salary column and the country column by plotting a boxplot.

From our plot we can see that we have lot of outliers .So now we would keep the data where we have more information by keeping salaries that are lesser than or equal to $250,000 ,greater than or equal to $10,000 and drop the other category.

Let’s plot it again

We can see that the outliers has reduced.

Cleaning the YearsCodepro feature

The unique() function in python is used to get unique values of the series object. Unique() functions are returned in order of appearance.

After running this, we discovered that all the arrays came out as strings, for the computer to understand these, we would convert the arrays to floats. If any is less than a year, it will return 0.5 while if it is more than a year, we ascribe 50. Otherwise, convert it to a float. We would do that by creating a function called clean_experience.

After running the above we see that the output came out as integers.

Cleaning the EdLevel feature

Here, we have different education levels. We would be focusing on the Bachelor’s , Master’s and other Post graduate degrees. Anything apart from these would be called Less than a Bachelor.

After running the code above we would see that we have only five outputs.

Now, we are almost done with the data cleaning.

As we all know, the computer does not understand strings and we do have columns containing strings! It is, therefore, necessary to transform the string values into unique values. To do this, we would be using LabelEncoder. Label Encoding in Python is part of data preprocessing. Hence, we will use the preprocessing module from the sklearn package and then import LabelEncoder

Create an instance of LabelEncoder() and store it in the LabelEncoder variable which is the lb_edlevel.

Apply fit and transform which does the trick to assign numerical value to categorical value and the same is stored in a new column called “edlevel”.

Let’s take a look at the EdLevel

We no longer have strings here again, the LabelEncoder has transformed the EdLevel column to integers which the model can now understand . We would do the same for the country column also.

Create an instance of LabelEncoder() and store it in the LabelEncoder variable which is the lb_country.

Apply fit and transform which does the trick to assign numerical value to categorical value and the same is stored in new a column called “country”.

Let's have a look at the unique values for the country column

Now, label encoder has given each country a unique integer value.

Let’s check the dataset

Now, our data is ready for training and testing.

Data Splitting: Data splitting is commonly used in machine learning to split data into a train, test, or validation set. This approach allows us to estimate the model performance. Here, we would only be training and testing the data.

We would split our data into X and y. X will contain the features and y will contain the dropped target which is the salary.

After doing that we would be splitting X and y dataset into the test and train. To do this we will be using the train_test_split function.

The train_test_split is a function in Sklearn model selection for splitting data arrays into two subsets: for training and testing data. With this function, you don’t need to divide the dataset manually. By default, Sklearn train_test_split will make random partitions for the two subsets.

We would be training with 70% and testing with 30% of the dataset and set our random_state at 42. The random state ensures that the outputs are generated in the same order whenever it is being runned.

So it’s time to build our model!!!

Three different algorithms would be used to build the model then we will pick the algorithm with the least error.

We would start with Linear Regression, Linear regression is a basic and commonly used type of algorithm for predictive analysis, we would start by importing it from sklearn.linear_model.

Create an instance of LinearRegression() and store it in a variable, fit it on the training dataset and store it in a variable. Then predict on the testing dataset and store it in a variable.

In regression predictive modeling, we use error metrics to calculate the model performance. The error metrics we would be using is the RMSE which is the root of the mean square error. This error metric would be used to show the difference between the predicted value and the actual value.

Our output is shown below

We can see that the difference between the actual and predicted value using LinearRegression algorithm is $39,558.79 which is very high

Let’s try the DecisionTreeRegressor algorithm

Import DecisionTreeRegressor from sklearn.tree, create an instance of DecisionTreeRegressor and store it in a variable, fit it on the training dataset and store it in a variable. Then predict on the testing dataset and store it in a variable.

The difference between the actual and predicted value using DecisionTreeRegressor is $33,962.56 which is a little bit high.

Let’s try the Random Forest Regression algorithm.

Import RandomForestRegressor from sklearn.ensemble. Create an instance of RandomForestRegressor and store it in a variable, fit it on the training dataset and store it in a variable. Then predict on the testing dataset and store it in a variable.

Finally, the RandomForestRegressor algorithm gave us the least error. Now we want to find the best parameter for our model using the Gridsearchcv.

Grid search is the process of performing hyperparameter tuning to determine the optimal values for a given model. This is significant as the performance of the entire model is based on the hyperparameter values specified. It is a useful tool to fine-tune the parameters of your model.

The way it works is by importing it from sklearn.model_selection, define the set of different parameters, then create a parameter dictionary containing the keyword argument in RandomForestRegressor, (you can check out the documentation for that ) then create an instance of the regressor algorithm used, an instance of Gridsearchcv containing the regressor algorithm, parameter, and the scoring. Lastly, fit the Gridsearchcv to the training data set.

After running the above code, we get the best estimator and store it in a variable called model. Then fit it on our training dataset and use it to predict on our test data set.

Following this, the error value has reduced a bit from $33,617.45 to $32,911.09 which is still fair.

Making a predictive system

For instance a user inputs his country’s information as United States; EdLevel as Master’s degree; and the yearscodepro as 15years

Below is the result for the user’s annual salary .

In conclusion, we have seen the step-by-step approach to building the model for our salary prediction web app. In my next article, I will be sharing how to deploy this model.