4. Building a Simple Model (Supervised Learning)

Example: Predicting student scores based on hours studied

This statement introduces a practical example where we will create a supervised learning model. The goal of this model is to predict student scores based on the number of hours they studied. Here, the number of hours studied is the input feature, and the student scores are the target output we want to predict.

Imagine a teacher wanting to understand how study time affects student performance. By tracking how many hours each student studies and their subsequent scores, the teacher can predict future scores based on study habits.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

In this chunk, we import necessary Python libraries: pandas for data manipulation, 'train_test_split' from scikit-learn to split the dataset into training and testing sets, 'LinearRegression' to create the model, and 'mean_squared_error' to evaluate the model's predictions. Libraries in programming help us use pre-written code to make our work easier and more efficient.

Think of importing libraries like gathering tools before starting a DIY project. Just as you wouldn't start without the right tools, we gather these libraries to ensure we have everything needed to build our model.

df = pd.read_csv("student_scores.csv")
X = df[['Hours']]
y = df['Scores']

This chunk involves reading a CSV file containing the data, which includes correlations between hours studied and student scores. We load this data into a variable 'df'. Next, we separate the features (input) into 'X' which contains just hours studied, and 'y' which represents the scores to predict.

Loading data from a CSV file is like opening a recipe book to find all the ingredients you need for a dish. Here, 'X' are the ingredients (hours studied), and 'y' is the finished dish (student scores) you want to create.

X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.2, random_state=42)

In this step, we use the train_test_split function to divide our dataset into training and testing subsets. The training set (80% of data) is used to train the model, while the test set (20%) is reserved to test the model's performance on unseen data. Setting a 'random_state' ensures that we get the same split every time we run the code for consistent results.

This is akin to a teacher holding a mock exam for a class. The teacher can use 80% of the students' previous work to prepare exam questions and then test the students with the remaining 20% to check their comprehension.

model = LinearRegression()
model.fit(X_train, y_train)

Here, we create an instance of a Linear Regression model and train it using our training datasets, 'X_train' for inputs and 'y_train' for outputs. The model will learn the relationship between the hours studied and the scores based on the training data.

Think of this as a coach training a team. During practice (training), the coach teaches the players strategies and skills based on their past games (training data) to improve their future performance.

predictions = model.predict(X_test)

After training, we use the model to make predictions on the test set using the predict method. This will provide the estimated scores for the students based on the hours they studied, which we can then compare to their actual scores.

This is like a coach watching their team play a real game after all the training. The coach observes how well the strategies work (the predictions) against how the team actually performs (the actual scores).

print("MSE:", mean_squared_error(y_test, predictions))

In this final step, we evaluate how well our model performed by calculating the Mean Squared Error (MSE) using the mean_squared_error function. MSE measures the average squared difference between actual scores and predicted scores. A lower MSE indicates a better-performing model.

Evaluating the model's performance is like reviewing the game after it ends. The coach looks at the score (MSE) to see how well the team played; a higher score means more mistakes were made, while a lower score suggests they executed the strategy well.

--