Introduction to Machine Learning with Python

Learn the fundamentals of machine learning step by step

🧠 What is Machine Learning?

Machine Learning is a subset of artificial intelligence that enables computers to learn from data and make predictions or decisions without being explicitly programmed. Instead of writing code with specific instructions for every scenario, we train models on data, allowing them to identify patterns and make predictions on new, unseen data.

Machine learning algorithms build mathematical models based on sample data, known as "training data," to make predictions or decisions without being explicitly programmed to do so.

1. Types of Machine Learning

Machine learning can be broadly categorized into three main types:

1.1 Supervised Learning

In supervised learning, the algorithm learns from labeled training data. It maps input features to known output labels, allowing it to predict outputs for new, unseen inputs.

Common Supervised Learning Algorithms:

• Linear Regression
• Logistic Regression
• Decision Trees
• Random Forests
• Support Vector Machines (SVM)
• Neural Networks

1.2 Unsupervised Learning

In unsupervised learning, the algorithm works with unlabeled data, trying to find patterns, structures, or relationships within the data.

Common Unsupervised Learning Algorithms:

• K-means Clustering
• Hierarchical Clustering
• Principal Component Analysis (PCA)
• Association Rules
• Autoencoders

1.3 Reinforcement Learning

In reinforcement learning, an agent learns to make decisions by taking actions in an environment to maximize some notion of cumulative reward.

Common Reinforcement Learning Algorithms:

• Q-Learning
• Deep Q Network (DQN)
• Policy Gradient Methods
• Actor-Critic Methods

2. Setting Up Your Environment

Before we dive into machine learning, let's set up our Python environment with the necessary libraries:

# Install required libraries
# Run these commands in your terminal or command prompt
!pip install numpy pandas matplotlib scikit-learn

Now, let's import the libraries we'll need:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn import datasets, model_selection, metrics
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.cluster import KMeans

# Set a random seed for reproducibility
np.random.seed(42)

3. Working with Datasets

Understanding how to work with datasets is a fundamental skill in machine learning. In this section, we'll learn how to:

• Load and explore datasets
• Understand dataset structure (features and targets)
• Visualize data to gain insights
• Prepare data for machine learning algorithms

The Iris Dataset: This is one of the most famous datasets in machine learning. It contains measurements of 150 iris flowers from three different species (setosa, versicolor, and virginica). Each flower has four features measured: sepal length, sepal width, petal length, and petal width.

Scikit-learn comes with several built-in datasets that are great for learning. Let's start by exploring the Iris dataset:

# Step 1: Import the datasets module from scikit-learn
from sklearn import datasets

# Step 2: Load the iris dataset into memory
# This gives us access to the data and information about it
iris = datasets.load_iris()

# Step 3: Explore the dataset to understand what we're working with
# How many samples and features do we have?
print("Dataset shape:", iris.data.shape)  # Output: (150, 4) meaning 150 flowers with 4 measurements each

# What are the names of the features (measurements)?
print("Feature names:", iris.feature_names)  # These are the 4 measurements taken for each flower

# What are the different types of flowers (target classes)?
print("Flower species:", iris.target_names)  # The 3 species of iris flowers

# Step 4: Look at some actual data samples
print("\nLet's look at the first 5 flowers in our dataset:")
for i in range(5):
    # Get the measurements for this flower
    measurements = iris.data[i]
    
    # Get the species of this flower (0=setosa, 1=versicolor, 2=virginica)
    species_number = iris.target[i]
    
    # Convert the species number to the actual species name
    species_name = iris.target_names[species_number]
    
    # Print the information in a readable format
    print(f"Flower #{i+1}:")
    print(f"  Measurements: {measurements}")
    print(f"  Species: {species_name}")
    print()

Output:

Dataset shape: (150, 4)
Feature names: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
Flower species: ['setosa', 'versicolor', 'virginica']

Let's look at the first 5 flowers in our dataset:
Flower #1:
  Measurements: [5.1 3.5 1.4 0.2]
  Species: setosa

Flower #2:
  Measurements: [4.9 3.0 1.4 0.2]
  Species: setosa

Flower #3:
  Measurements: [4.7 3.2 1.3 0.2]
  Species: setosa

Flower #4:
  Measurements: [4.6 3.1 1.5 0.2]
  Species: setosa

Flower #5:
  Measurements: [5.0 3.6 1.4 0.2]
  Species: setosa

3.1 Data Preprocessing

Before training a model, we typically need to preprocess our data to ensure it's in the right format and quality for machine learning algorithms. Think of this as preparing ingredients before cooking!

Common preprocessing steps include:

• Handling missing values: Filling in or removing missing data points (e.g., using mean, median, or most frequent values)
• Encoding categorical variables: Converting text categories to numbers (e.g., 'red', 'blue', 'green' → 0, 1, 2)
• Scaling numerical features: Ensuring all features have similar ranges (e.g., using StandardScaler or MinMaxScaler)
• Feature selection/engineering: Choosing the most relevant features or creating new ones
• Splitting data: Dividing data into training and testing sets to evaluate model performance

Let's see how to split data into training and testing sets:

# Step 1: Import the function we need for splitting data
from sklearn.model_selection import train_test_split

# Step 2: Prepare our data
# We already loaded the iris dataset above
iris = datasets.load_iris()

# Separate the features (measurements) from the target (species)
X = iris.data  # X is the convention for features/inputs
y = iris.target  # y is the convention for targets/outputs

# Step 3: Split the data into training and testing sets
# Think of this like dividing a textbook:
# - Most pages (80%) are used for studying (training)
# - Some pages (20%) are saved for self-quizzing (testing)

# The train_test_split function returns 4 datasets:
# 1. X_train: The flower measurements we'll use to train our model
# 2. X_test: The flower measurements we'll use to test our model
# 3. y_train: The correct species for the training flowers
# 4. y_test: The correct species for the testing flowers
X_train, X_test, y_train, y_test = train_test_split(
    X,                  # The feature data
    y,                  # The target data
    test_size=0.2,      # Use 20% of data for testing
    random_state=42     # Set a "seed" so we get the same split every time
)

# Step 4: Verify our split worked correctly
print("Original dataset:")
print(f"  Total number of flowers: {X.shape[0]}")
print(f"  Measurements per flower: {X.shape[1]}")
print()

print("After splitting:")
print(f"  Training set: {X_train.shape[0]} flowers ({X_train.shape[0]/X.shape[0]*100:.1f}% of data)")
print(f"  Testing set: {X_test.shape[0]} flowers ({X_test.shape[0]/X.shape[0]*100:.1f}% of data)")

# Let's also check that we have all three species in our training data
species_in_training = set(y_train)
print(f"\nSpecies in training data: {[iris.target_names[i] for i in species_in_training]}")

Output:

Original dataset:
  Total number of flowers: 150
  Measurements per flower: 4

After splitting:
  Training set: 120 flowers (80.0% of data)
  Testing set: 30 flowers (20.0% of data)

Species in training data: ['setosa', 'versicolor', 'virginica']

Try This Code Yourself & See the Result

Visualize the Iris Dataset:

# Step 1: Import the libraries we need for visualization
import matplotlib.pyplot as plt  # The main plotting library
import seaborn as sns            # A library that makes prettier plots
import pandas as pd              # For working with data in table format
from sklearn import datasets     # To get our iris dataset

# Step 2: Load and prepare the data
# Get the iris dataset
iris = datasets.load_iris()

# Extract the features and target
X = iris.data    # The 4 measurements
y = iris.target  # The species (0, 1, or 2)

# Step 3: Convert to a pandas DataFrame for easier visualization
# A DataFrame is like a spreadsheet/table with rows and columns
iris_df = pd.DataFrame(X, columns=iris.feature_names)

# Add a column for the species names
iris_df['species'] = [iris.target_names[i] for i in y]

# Let's look at the first few rows of our DataFrame
print("First 5 rows of our DataFrame:")
print(iris_df.head())
print()

# Step 4: Create a simple scatter plot to visualize two features
# We'll plot petal length vs. petal width, which are good for distinguishing species
plt.figure(figsize=(10, 6))  # Set the figure size (width, height in inches)

# Create a dictionary to map species to colors for consistency
colors = {'setosa': 'blue', 'versicolor': 'orange', 'virginica': 'green'}

# Loop through each species and plot it with a different color
for species in iris.target_names:
    # Get only the rows for this species
    species_data = iris_df[iris_df['species'] == species]
    
    # Plot this species with its own color
    plt.scatter(
        species_data['petal length (cm)'],  # x-axis
        species_data['petal width (cm)'],   # y-axis
        c=colors[species],                  # color
        label=species,                      # for the legend
        alpha=0.7,                          # transparency
        s=70                                # size of dots
    )

# Add labels and title
plt.title('Iris Flowers: Petal Length vs. Petal Width', fontsize=14)
plt.xlabel('Petal Length (cm)', fontsize=12)
plt.ylabel('Petal Width (cm)', fontsize=12)

# Add gridlines to make it easier to read values
plt.grid(True, linestyle='--', alpha=0.7)

# Add a legend to identify which color represents which species
plt.legend(title='Species')

# Make sure everything fits nicely
plt.tight_layout()

# Display the plot
plt.show()

# Step 5: Create a more advanced visualization - a pair plot
# This shows relationships between all pairs of features
print("Creating a pair plot to show all feature relationships...")
sns.pairplot(
    iris_df,                  # Our data
    hue='species',            # Color by species
    markers=['o', 's', 'D'],  # Different marker for each species
    height=2.5                # Size of each subplot
)

plt.suptitle('Iris Dataset - All Feature Relationships by Species', y=1.02, fontsize=16)
plt.show()

Output:

First 5 rows of our DataFrame:
   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)  species
0                5.1               3.5                1.4               0.2   setosa
1                4.9               3.0                1.4               0.2   setosa
2                4.7               3.2                1.3               0.2   setosa
3                4.6               3.1                1.5               0.2   setosa
4                5.0               3.6                1.4               0.2   setosa

Creating a pair plot to show all feature relationships...

🎯 Key Concepts in Machine Learning

📊 Data Concepts

• Features: The input variables used to make predictions (like the flower measurements)
• Labels/Targets: What we're trying to predict (like the flower species)
• Training Data: The data used to teach the model patterns
• Testing Data: New data used to evaluate the model's performance

🧠 Learning Types

• Supervised Learning: Learning from labeled examples (like classifying flowers when we know their species)
• Unsupervised Learning: Finding patterns in unlabeled data (like grouping similar customers)
• Reinforcement Learning: Learning through trial and error with rewards (like teaching a computer to play games)

⚠️ Common Challenges

• Overfitting: When a model learns the training data too well and performs poorly on new data (like memorizing instead of understanding)
• Underfitting: When a model is too simple to capture the patterns in the data
• Data Quality: Missing values, outliers, or biased data can lead to poor models

📈 Evaluation

• Accuracy: The percentage of correct predictions
• Precision & Recall: Measures of a model's exactness and completeness
• Cross-Validation: Testing the model on different subsets of data
• Confusion Matrix: A table showing correct and incorrect predictions by class

Understanding these concepts will help you build more effective machine learning models and avoid common pitfalls.

Quiz Time

Machine Learning Practice Questions

Tip: Try running these codes in your Python editor or Google Colab.

Machine Learning Practice Questions