Python Prediction Algorithm

Introduction:

In this tutorial, we are learning about Python Prediction Algorithm. A predictive model in Python predicts a future release based on patterns found in historical data. Essentially, by collecting and analyzing historical data, you can train a model to identify certain patterns, thus preventing future sales, epidemics, fraud, etc. In other words, when a Python model is trained after encountering new data, it can predict future outcomes. You can build predictive models using different data and machine learning algorithms like decision trees, K-means clustering, time series, naive Bayes, and more.

Predictive programming is used throughout the industry as a way to drive growth and change. One such way companies use this model is to forecast next month's sales based on data collected in the previous year. Similarly, the healthcare industry is using predictive analytics to detect and identify patients' early symptoms so that doctors can better treat their patients.

Can we use Python programming language for predictive analysis?

Yes, Python can be used for predictive analytics. The Python is one of the most popular programming languages today and has a rich and powerful library. It makes building predictive models a simple process. Some popular ones are pandas, NymPy, matplotlib, seaborn and scikit-learn. In addition to existing libraries, Python has many functions that make data analysis and prediction work easier. The syntax is easy to learn and also can be adapted to your analysis needs, making it an excellent choice for data scientists and employers.

If you take advantage of Python and all its libraries and features, you will create a good model with high predictability that will lead to the success of your company or your personal project. But before you start building these models, you need some background knowledge in coding and machine learning to understand the mechanics of the algorithms.

How can you write a predictive model in Python?

You can write a predictive model that requires several steps. For starters, if your data is out of date, you will need to clear it before you start. If you are using simple files from other sources like GitHub or Kaggle, these steps will work for some files. It is important to check your data log and make sure you know what data is stored there. Calling Python functions like info(), shape, and describe() can help you understand what you're working with so you have a better idea of how to build the model later.

Then, you need to select a feature. You will only need part of the dataset during the course. Therefore, you should only select the features that have the best relationship with the measured variables. In this step, you perform a statistical analysis to determine which of the datasets is most important to your model. Now, it is the time to create the model by splitting the data set into training data and test data. You want to train your model well so that it can perform well when it encounters unknown objects later. Finally, you can evaluate your model's performance by running a classification report and calculating the ROC curve.

What is the process predicting model?

You need to always focus on investing the right time in the initial phase of design, such as hypothesis generation or brain storming sessions, or discussing or understanding the design. All these activities help me solve problems and ultimately build a stronger business. There are many reasons why you should use this opportunity first, which are given below -

You have enough time to invest, and you are fresh (this makes a difference)
You have no equity for other content or ideas; reflect on your thoughts before digging into the data created.
In the next stage, you will rush to complete the project, and there will be no quality time.

This stage should be a good time, so you will not talk about time here. I recommend you to do it as a model. It will help you build better predictive models and reduce rework later. Let us look at the remaining stages and time of the initial design:

Firstly, the Description of data which takes 50% time
Then, Data processing like missing value and outlier fixing take 40% of the time
The Data Modelling which takes 4% time
The last one is Performance Evaluation, which takes 6% time

Now we discuss the few steps of the process of the predicting model, which is given below -

Step 1 - Data Exploration or Descriptive Analysis:

Date exploration or descriptive analysis is the first step of the process of predicting the model. The initial time of every data scientist takes a lot of time for data exploration. But with the time flow, they will gather a lot of knowledge in data. Considering that data prep takes up 50% of the effort in creating the initial prototype, the benefits of automation are clear. You can read "7 Steps of Data Exploration" to see the most common data analysis tasks.

With the advent of advanced machine learning tools, the time required to do this task has decreased. Since this is our first base model, we have removed all aspects of task quality. Therefore, the time you must do the explanation is limited to understanding the missing values and seeing the main features directly. According to my method, you need 2 minutes to complete this step (assuming there are 100,000 observations in the dataset). The following operation you must perform in the first model included:

You need to identify the ID, login, and target attributes
Specify the categorical feature and numerical feature

Lastly, identify the columns that are not needed

Step 2 - Data Treatment or Missing value treatment:

The data treatment or the missing value treatment is the next step of the process of the predictive model. There are many ways to solve this. For our first model, we will focus on smart and fast skills to create the first working model.

Firstly, you need to create a dummy flag for the missing value. It works when sometimes it carries too much information to miss important things.
Then, we need to impute the missing values. The mean, median or any easiest method does this. Mean and median imputation works; most people like to impute using the mean, but if the distribution is not uniform, I recommend using the median. Another Intelligent way is to use other relevant features to influence the results or create models from similar data and mean interpolation. For example, In the Titanic Survival Challenge, you can use the passengers' names ("Mr.", "Miss.", "Mrs.", "Master", etc.) to guess their ages, which is a challenging solution. It positively affects the performance of the model.

Now, we assign missing values for categorical variables. Create a new hierarchy to impute categorical variables. So, all missing values are encoded as a single value (e.g., "New_Cat"), or you can view the mix frequencies and impute the missing values. Use values with frequency. With this simple data processing method, you can reduce the data processing time to 3-4 minutes.

Step 3 - Data modelling:

The data modeling is the third step of the process of predictive modeling. Depending on the business problem, it is recommended to use one of the GBM or the Random Forest techniques. Both of these methods are useful for creating solutions. We often see data scientists use two methods as the initial model and sometimes as the final model. This will take the longest (about 4-5 minutes).

Step 4 - Performance Estimation:

The last step is performance estimation for processing the prediction model. There are many ways to measure the performance of the model. We recommend splitting your training data into training and validating (ideally 70:30) and creating a model consisting of 70% of the training dataset. Now, cross-validate using 30% of valid data and measure performance using benchmarks. This process ultimately takes 1-2 minutes to complete and document.

Now we are putting it into this action:

You have done all the hypothesis generation first and are good at doing data science using Python. I will explain this with an example from a competitive case study. Let us see the example:

Step 1: Import the required library and read the test and training data. Connect both.

import pandas as pd
import numpy as np
from sklearn.preprocessing import LabelEncoder
import random
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
train = pd.read_csv('D:/Users/Desktop/challenge/Train.csv')
test = pd.read_csv('D:/Users/Desktop/challenge/Test.csv')

# Here, we create a flag for Train the data set
train['Type'] = 'Train' 

# Here, we create a flag for Test the data set
test['Type'] = 'Test'

# Here, we combine the train and the test dataset
full_Data = pd.concat([train,test],axis=0) 

Step 2: This step's framework is not required in Python. So, we go into the next step.

Step 3: In this step, we can view the column name and summary of the data set.

fullData.columns 
# Here, we show all the column names by this command

fullData.head(5) 
# Here, we show the first 10 records of the dataframe by this command

fullData.describe() 
# Here, we are using the describe() function for show the summary of numerical fields 

Step 4: In this step, we are identify the ID variables, Target variables, Categorical Variables, Numerical Variables, and Other Variables.

ID_column = ['REF_NO']
target_column = ["Acc.Status"]
cat_column = ['children','age_band','status','occupation','occu_partner','home_status','family_income','self_emp', 'self_employed_partner','year_last_moved','TV_area','post_code','post_area','gender','region']
num_column = list(set(list(fullData.column))-set(cat_column)-set(ID_column)-set(target_column)-set(data_column))

# Here we Test and Train Data set identifier
other_column=['Type'] 

Step 5: In this step, we are identify the variables with missing values and then we create a flag for them.

fullData.isnull().any()
# Here, using this command, we can return the feature with True or False as a result. True means there is a missing value and False means there is no return value.

Output

Using the above command, we can find the below output.

Acc.Status                               True
Average.A.C.Balance                      True
Average.Credit.Card.Transaction			 True
Balance.Transfer                         True
Home.Loan                                True
Investment.Tax.Saving.Bond			     True
Investment.in.Commudity			         True
Investment.in.Derivative			     True
Investment.in.Equity			         True
Investment.in.Mutual.Fund			     True
Life.Insurance                           True
Medical.Insurance                        True
Online.Purchase.Amount			         True
Personal.Loan                            True
Portfolio.Balance                        True
REF_NO                                   False
TV_area                                  True
Term.Deposit                             True
Type                                     False
age_band                                 True
children                                 True

# Here, we add the numerical column and the categorical column
num_cat_column = num_column + cat_column 

# Identify variables with missing values and create a flag with a missing value using VariableName_NA and mark the missing value as 1 and the others as 0.
for var in num_cat_column:
    if fullData[var].isnull().any() == True:
        fullData[var+'_NA']=fullData[var].isnull()*1

Step 6: In this step, we impute the missing values, and the code is given below -

# Here, we impute the numerical missing values with the mean value
fullData[num_column] = fullData[num_ column].fillna(fullData[num_ column].mean(),inplace=True)
# Here, we impute the categorical missing values with -9999
fullData[cat_ column] = fullData[cat_ column].fillna(value = -9999)

Step 7: In this step, we create label encoders for the categorical variables. Then, split the dataset into training dataset and testing datasets. Here, we also split the training data into training and validation. The code is now given below -

# Here, we create the label encoders for the categorical features
for var in cat_column:
 number = LabelEncoder()
 fullData[var] = number.fit_transform(fullData[var].astype('str'))

# Here, the target variable is also a categorical variable so convert it
fullData["Acc.Status"] = number.fit_transform(fullData["Acc.Status"].astype('str'))

train = fullData[fullData['Type'] == 'Train']
test = fullData[fullData['Type'] == 'Test']

train['is_train'] = np.random.uniform(0, 1, len(train)) <= 0.75
Train, Validate = train[train['is_train']==True], train[train['is_train']==False]

Step 8: In this step, we import the imputed variables and dummy (non-flag) variables into the model. I used the random forest to predict the class. The code is now given below -

Features = list(set(list(fullData.columns))-set(ID_column)-set(target_column)-set(other_column))
x_train = Train[list(features)].values
y_train = Train["Acc.Status"].values
x_validate = Validate[list(features)].values
y_validate = Validate["Acc.Status"].values
x_test = test[list(features)].values
random.seed(100)
rf = RandomForestClassifier(n_estimators = 1000)
rf.fit(x_train, y_train)

Step 9: In this step, we are checking the performance and then make a prediction. So, the code is now given in below -

# Here, we find the status of the code
status = rf.predict_proba(x_validate)
fpr, tpr, _ = roc_curve(y_validate, status[:,1])
roc_auc = auc(fpr, tpr)
print roc_auc

final_status = rf.predict_proba(x_test)
test["Acc.Status"] = final_status[:,1]
test.to_csv('D:/Users/Desktop/model_output.csv', columns = ['REF_NO','Acc.Status'])

Lastly, we need to submit the code.

Discuss the types of prediction.

The prediction is basically three types, which are given below -

1. Classification:

In the classification, we can predict the class that an input belongs to based on the training data with labeled examples.

2. Regression:

It predicts a fixed number as output, aiming to find the relationship between input variables and target variables.

3. Time series forecasting:

Predict future values based on patterns and trends observed in historical data with time series.

Conclusion:

Through this tutorial, we are learning about Python Prediction Algorithms. A predictive model in Python predicts a future release based on patterns found in historical data. A predictive model in Python is a mathematical or mathematical algorithm. It is used to make predictions based on the input data. The predicting model uses machine learning or statistical techniques to analyse the historical data and learn patterns that can be used to predict future outcomes or trends. Python has many functions that make data analysis and prediction work easier. So, we use Python programming language for the prediction algorithm.

Next TopicReading-binary-files-in-python

← prev next →