Python for Machine Learning 2026 — Your First ML Project with scikit-learn

Python for Machine Learning 2026 — Build Your First ML Model

There is a moment every data scientist remembers: the first time they run model.predict() and the computer correctly guesses something it has never seen before. That moment — seeing a machine learn from data — is genuinely thrilling.

Machine learning sounds intimidating. Algorithms, matrices, mathematics. But here is the truth: with Python and scikit-learn, you can build your first working ML model in under 50 lines of code. The math happens inside the library. You focus on understanding the problem.

This guide walks you from absolute ML beginner to building and evaluating real models.

What Is Machine Learning?

Machine learning is teaching a computer to make predictions or decisions from data — without explicitly programming every rule.

Instead of writing if price > 500 and bedrooms >= 3 then expensive, you show the model thousands of house sales and let it figure out the patterns itself.

Three main types:

This guide focuses on supervised learning — the most common type in real-world applications.

The ML Workflow

Every machine learning project follows the same steps:

1. Define the problem — What are you predicting?
2. Collect data — Get labeled examples
3. Explore and clean data — EDA and preprocessing
4. Choose a model — Pick an algorithm
5. Train the model — model.fit(X_train, y_train)
6. Evaluate the model — Measure accuracy on unseen data
7. Deploy and monitor — Use the model in production

Setup

pip install scikit-learn pandas numpy matplotlib seaborn

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn import datasets
print("scikit-learn version:", __import__("sklearn").__version__)

Your First ML Model: Predicting House Prices

Let us build a regression model to predict house prices.

Step 1: Load and Explore Data

import pandas as pd
import numpy as np
from sklearn.datasets import fetch_california_housing

# Load the dataset
housing = fetch_california_housing(as_frame=True)
df = housing.frame
target = "MedHouseVal"  # Median house value in $100K

print(df.head())
print(f"\nShape: {df.shape}")
print(f"\nTarget: {target}")
print(f"Min price: ${df[target].min() * 100:.0f}K")
print(f"Max price: ${df[target].max() * 100:.0f}K")
print(f"Average price: ${df[target].mean() * 100:.0f}K")
print(f"\nMissing values:\n{df.isnull().sum()}")

Step 2: Prepare Features

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Features (X) and target (y)
X = df.drop(columns=[target])
y = df[target]

# Split into training and test 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)}")

# Scale features (important for many algorithms)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)   # Fit on training data only!
X_test_scaled = scaler.transform(X_test)          # Transform test data

Important: always fit the scaler on training data only, then transform both sets. Fitting on test data causes "data leakage" — your model will appear to perform better than it really is.

Step 3: Train Multiple Models

from sklearn.linear_model import LinearRegression, Ridge
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.metrics import mean_absolute_error, r2_score

models = {
    "Linear Regression": LinearRegression(),
    "Ridge Regression": Ridge(alpha=1.0),
    "Random Forest": RandomForestRegressor(n_estimators=100, random_state=42),
    "Gradient Boosting": GradientBoostingRegressor(n_estimators=100, random_state=42),
}

results = {}

for name, model in models.items():
    # Train the model
    model.fit(X_train_scaled, y_train)
    
    # Predict on test data
    y_pred = model.predict(X_test_scaled)
    
    # Evaluate
    mae = mean_absolute_error(y_test, y_pred)
    r2 = r2_score(y_test, y_pred)
    
    results[name] = {"MAE": mae, "R²": r2}
    print(f"{name:25s} — MAE: {mae:.3f} | R²: {r2:.3f}")

Output:

Linear Regression         — MAE: 0.533 | R²: 0.576
Ridge Regression          — MAE: 0.533 | R²: 0.576
Random Forest             — MAE: 0.328 | R²: 0.804
Gradient Boosting         — MAE: 0.372 | R²: 0.775

Random Forest wins. R² of 0.80 means the model explains 80% of the variation in house prices.

Your Second Project: Classification — Spam Detection

Classification predicts a category (spam/not spam, churn/no churn, fraud/legitimate).

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns

# Synthetic dataset for demonstration
X, y = make_classification(
    n_samples=2000,
    n_features=20,
    n_informative=10,
    random_state=42
)

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

# Train classifier
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)

# Evaluate
y_pred = clf.predict(X_test)
print(classification_report(y_test, y_pred, target_names=["Not Spam", "Spam"]))

# Confusion matrix
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues",
            xticklabels=["Not Spam", "Spam"],
            yticklabels=["Not Spam", "Spam"])
plt.title("Confusion Matrix")
plt.ylabel("Actual")
plt.xlabel("Predicted")
plt.show()

Understanding Classification Metrics

For spam detection, high recall matters — missing spam is worse than occasionally flagging real email.

Cross-Validation

A single train/test split can be lucky or unlucky. Cross-validation gives a more reliable estimate:

from sklearn.model_selection import cross_val_score

model = RandomForestRegressor(n_estimators=100, random_state=42)

# 5-fold cross-validation
scores = cross_val_score(model, X, y, cv=5, scoring="r2")

print(f"R² scores: {scores}")
print(f"Mean R²: {scores.mean():.3f} ± {scores.std():.3f}")

The mean and standard deviation give you a realistic picture of model performance.

Hyperparameter Tuning

Algorithms have settings (hyperparameters) you can tune to improve performance:

from sklearn.model_selection import GridSearchCV

param_grid = {
    "n_estimators": [50, 100, 200],
    "max_depth": [None, 10, 20],
    "min_samples_split": [2, 5, 10],
}

grid_search = GridSearchCV(
    RandomForestRegressor(random_state=42),
    param_grid,
    cv=3,
    scoring="r2",
    n_jobs=-1,  # Use all CPU cores
    verbose=1,
)

grid_search.fit(X_train_scaled, y_train)

print(f"Best parameters: {grid_search.best_params_}")
print(f"Best R²: {grid_search.best_score_:.3f}")

best_model = grid_search.best_estimator_

Feature Importance — What the Model Learned

import pandas as pd
import matplotlib.pyplot as plt

# Get feature importances from trained Random Forest
importances = pd.Series(
    best_model.feature_importances_,
    index=X.columns if hasattr(X, "columns") else [f"feature_{i}" for i in range(X.shape[1])]
)

# Sort and plot
importances.sort_values().tail(10).plot(kind="barh", color="#4f46e5", figsize=(10, 6))
plt.title("Top 10 Most Important Features")
plt.xlabel("Importance Score")
plt.tight_layout()
plt.savefig("feature_importance.png", dpi=150)
plt.show()

Feature importance tells you which input variables the model relies on most. This builds intuition and can reveal unexpected patterns.

Saving and Loading Models

import joblib

# Save the trained model
joblib.dump(best_model, "house_price_model.pkl")
joblib.dump(scaler, "feature_scaler.pkl")
print("Model saved!")

# Load and use later
loaded_model = joblib.load("house_price_model.pkl")
loaded_scaler = joblib.load("feature_scaler.pkl")

# Make predictions on new data
new_house = pd.DataFrame({
    "MedInc": [3.5], "HouseAge": [15.0], "AveRooms": [5.5],
    "AveBedrms": [1.0], "Population": [500.0], "AveOccup": [2.5],
    "Latitude": [37.5], "Longitude": [-120.0]
})

new_scaled = loaded_scaler.transform(new_house)
prediction = loaded_model.predict(new_scaled)[0]
print(f"Predicted house value: ${prediction * 100:.0f}K")

Scikit-learn Algorithm Cheat Sheet

Start with Random Forest for most supervised problems — it works well out of the box, handles mixed feature types, and is not sensitive to feature scaling.

Your ML Learning Path

After completing this guide, your next steps:

1. Practice on real datasets: Kaggle has hundreds of datasets with competitions and notebooks
2. Deep learning: Once you master traditional ML, explore PyTorch for neural networks
3. AI APIs: Use pre-trained models via APIs — see our ChatGPT vs Claude vs Gemini guide for AI API options
4. Data skills: Master Pandas for data wrangling — the Python Pandas tutorial is your next read

Machine learning is a vast field, but every expert started exactly where you are now — running their first model.fit() and watching numbers appear. That first model is the hardest part. Everything after it gets easier and more exciting.

ML project templates and Kaggle starter notebooks available free in the AiTechWorlds Telegram channel!