Introduction to Machine Learning with Python

Machine learning might seem intimidating, but with Python's excellent ecosystem, getting started is easier than you think. This guide will take you from zero to building your first ML model.

What is Machine Learning?

Machine learning is a subset of artificial intelligence where computers learn patterns from data without being explicitly programmed for each task. Instead of writing rules, you provide examples and the algorithm finds the patterns.

• Supervised Learning: Learn from labeled data to predict outcomes (classification, regression)
• Unsupervised Learning: Find hidden patterns in unlabeled data (clustering, dimensionality reduction)
• Reinforcement Learning: Learn through trial and error with rewards and penalties

Setting Up Your Environment

# Create a virtual environment
python -m venv ml-env
source ml-env/bin/activate  # On Windows: ml-env\Scripts\activate

# Install essential packages
pip install numpy pandas scikit-learn matplotlib seaborn jupyter

# Start Jupyter for interactive development
jupyter notebook

Your First ML Model: Classification

Let's build a classifier that predicts flower species from measurements. This is the 'Hello World' of machine learning:

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

# Load the famous Iris dataset
iris = load_iris()
X = iris.data  # Features: sepal length, sepal width, petal length, petal width
y = iris.target  # Labels: 0=setosa, 1=versicolor, 2=virginica

# Split into training (80%) and test (20%) sets
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

print(f"Training samples: {len(X_train)}")
print(f"Test samples: {len(X_test)}")

# Train a Random Forest classifier
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Make predictions on test set
predictions = model.predict(X_test)

# Evaluate accuracy
accuracy = accuracy_score(y_test, predictions)
print(f"\nAccuracy: {accuracy:.2%}")

# Detailed classification report
print("\nClassification Report:")
print(classification_report(y_test, predictions, target_names=iris.target_names))

Your Second Model: Regression

Regression predicts continuous values instead of categories. Let's predict house prices:

from sklearn.datasets import fetch_california_housing
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score

# Load California housing dataset
housing = fetch_california_housing()
X, y = housing.data, housing.target

# Split the data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Scale features (important for many algorithms)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Train a Linear Regression model
model = LinearRegression()
model.fit(X_train_scaled, y_train)

# Predict and evaluate
predictions = model.predict(X_test_scaled)

mse = mean_squared_error(y_test, predictions)
r2 = r2_score(y_test, predictions)

print(f"Mean Squared Error: {mse:.4f}")
print(f"R² Score: {r2:.4f}")

# Feature importance
feature_importance = pd.DataFrame({
    'feature': housing.feature_names,
    'coefficient': model.coef_
}).sort_values('coefficient', key=abs, ascending=False)

print("\nFeature Importance:")
print(feature_importance)

The Machine Learning Workflow

1. Define the problem: What are you trying to predict? Classification or regression?
2. Gather and explore data: Understand your features, check for missing values
3. Prepare the data: Handle missing values, encode categories, scale features
4. Split the data: Training set for learning, test set for evaluation
5. Choose and train a model: Start simple (linear models), then try complex ones
6. Evaluate: Use appropriate metrics (accuracy, F1, MSE, R²)
7. Iterate: Try different features, models, and hyperparameters
8. Deploy: Serve your model in production

Common Pitfalls to Avoid

• Data leakage: Never use test data during training or feature engineering
• Overfitting: Model memorizes training data but fails on new data. Use cross-validation.
• Imbalanced classes: Accuracy can be misleading. Use F1-score or balanced accuracy.
• Not scaling features: Many algorithms require normalized data
• Ignoring feature engineering: Good features matter more than complex models

Essential Libraries

Next Steps

Now that you've built your first models, here's how to continue learning:

1. Practice on Kaggle competitions and datasets
2. Learn cross-validation and hyperparameter tuning
3. Study feature engineering techniques
4. Explore ensemble methods (Random Forest, Gradient Boosting)
5. Dive into deep learning with TensorFlow or PyTorch
6. Read 'Hands-On Machine Learning with Scikit-Learn and TensorFlow'