Machine Learning with Python: A Practical Tutorial

This tutorial guides you through solving a realworld problem using machine learning with Python and Jupyter Notebook. You'll learn how to build a model that predicts music preferences based on user data. No prior machine learning knowledge is required, but a good understanding of Python is essential.

Introduction to Machine Learning

Machine learning is a subset of artificial intelligence (AI) and a trending topic with numerous future applications. Consider the task of building a program to identify cats and dogs in images using traditional programming. This becomes complex, requiring numerous rules for curves, edges, and colors. Machine learning offers a solution.

Instead of writing complex rules, we build a model and feed it大量data (e.g., thousands of cat and dog pictures). The model learns patterns, allowing it to identify cats and dogs in new, unseen images. The more data, the more accurate the model. Applications of machine learning extend beyond image recognition to selfdriving cars, robotics, language processing, forecasting, and gaming.

The Machine Learning Project Lifecycle

A machine learning project involves several key steps:

1. Data Import

Data is often imported from CSV files or databases. The goal is to bring the data into your machine learning environment.

2. Data Cleaning

This crucial step involves removing duplicates, irrelevant data, and handling incomplete entries. Textbased data needs to be converted to numerical values. Clean data is vital for accurate model training.

3. Data Splitting

The data is split into two sets: a training set (e.g., 80%) used to train the model and a testing set (e.g., 20%) used to evaluate its performance.

4. Model Creation

This involves selecting a machine learning algorithm, such as decision trees or neural networks. Scikitlearn is a popular Python library that provides prebuilt algorithms. The choice of algorithm depends on the problem and data.

5. Model Training

The model is trained using the training data, allowing it to learn patterns.

6. Prediction

The trained model is used to make predictions on new data.

7. Evaluation and Refinement

The accuracy of the predictions is evaluated. If the accuracy is insufficient, the algorithm is finetuned or a different algorithm is selected. Algorithm parameters can be modified to optimize accuracy.

Essential Python Libraries and Tools

Several Python libraries are essential for machine learning projects:

• NumPy: Provides multidimensional array objects.
• Pandas: A data analysis library that offers DataFrames (twodimensional data structures similar to Excel spreadsheets).
• Matplotlib: A twodimensional plotting library for creating graphs.
• Scikitlearn: A widelyused machine learning library with common algorithms.

Jupyter Notebook is the preferred environment for writing machine learning code because it allows for easy data inspection. Anaconda is a platform that simplifies the installation of Jupyter and these libraries. Download Anaconda from anaconda.com.

Installing Anaconda and Running Jupyter Notebook

Follow the instructions on the Anaconda website to install the distribution for your operating system. Once installed, open a terminal window and type jupyter notebook. This will start the notebook server and open a browser window with the Jupyter dashboard. From there, you can create new notebooks and begin coding.

Loading Data in Jupyter

Kaggle is a popular website for data science projects. Download the "Video Game Sales" dataset from Kaggle. Then, using Pandas, you can import the csv.

 
import pandas as pd
df = pd.read_csv("vgsales.csv")
print(df.shape)
print(df.describe())
print(df.values)
 
 

Dataframe shape gives you the number of records and columns. Dataframe describe returns basic stats about the columns. Dataframe values returns the twodimensional array.

Jupyter Notebook Shortcuts

Here's a summary of shortcuts for Jupyter Notebook:

• Green bar is Edit mode; blue bar is command mode
• 'h' in command mode shows all keyboard shortcuts
• Press 'b' in command mode, inserts a new cell below the currently selected cell.
• Press 'a' in command mode, inserts a new cell above the currently selected cell.
• Press 'd' twice to delete a cell.
• Run all cells from the Cell menu.
• Autocomplete with 'tab' key
• Comment a line with Command+/

Cordwindmarch.com has an online coding school, with courses on web and mobile development. Look at their comprehensive Python course to learn more!

Building a Music Recommendation Model

This project aims to build a model that recommends music albums to users based on their age and gender. You'll create a CSV file (downloadable below the video) containing sample data with age, gender (1 for male, 0 for female), and genre. The goal is to train the model to predict the genre a user is likely to enjoy.

Data Preparation

1. Import Data: Load the music.csv file using Pandas.

 
import pandas as pd
music_data = pd.read_csv("music.csv")
print(music_data)
 
 

2. Data Cleaning: The data set is clean so no cleaning is required for this step.

3. Data Splitting: Split the data into input (X) and output (y) sets.

 
X = music_data.drop(columns=["genre"])
y = music_data["genre"]
print(X)
print(y)
 
 

Model Creation and Training

Select the Decision Tree algorithm. The code imports sklearn and creates a model.

 
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier()
model.fit(X, y)
predictions = model.predict([[21, 1], [22, 0]])
print(predictions)
 
 

The code trains the model with the input and output sets and then makes predictions for a 21yearold male and a 22yearold female.

Measuring Accuracy

To measure the model's accuracy, split the data into training and testing sets using the train_test_split function.

 
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

from sklearn.metrics import accuracy_score
predictions = model.predict(X_test)
score = accuracy_score(y_test, predictions)
print(score)
 
 

The accuracy_score function compares the predicted values with the expected values in the test set. More data leads to a higher level of accuracy.

Model Persistence

Model persistence allows you to save a trained model to a file and load it later, avoiding the need to retrain it every time. The code below saves and loads a model:

 
from sklearn.externals import joblib
joblib.dump(model, "musicrecommender.joblib")
model = joblib.load("musicrecommender.joblib")
 
 

Visualizing Decision Trees

Decision Trees can be exported into a visual format.

 
from sklearn import tree
tree.export_graphviz(model,
 out_file="musicrecommender.dot",
 feature_names=["age", "gender"],
 class_names=sorted(y.unique()),
 label="all",
 rounded=True,
 filled=True)
 
 

View the dot file with the Graphviz extension for VS Code. By viewing the tree, you can see how the predictions are made!

Thank you for watching!