Machine Learning Tutorial with Python: from Theory to Practice | by Tani David | Apr, 2025

The easy means, for freshmen

Machine Studying (ML) is the science of coaching algorithms to be taught patterns from knowledge and make predictions or selections with out being explicitly programmed. It depends on statistical and mathematical rules to generalize from examples.

Options: Enter variables (e.g., age, wage).

Labels/Goal: Output variable to foretell (e.g., “spam” or “not spam”).

Coaching Information: Information used to coach the mannequin.

Take a look at Information: Information used to judge mannequin efficiency.

A. Supervised Studying

Idea:

• Learns from labeled knowledge (input-output pairs).
• Objective: Predict outputs for brand new inputs.

Examples:

• Regression: Predict steady values (e.g., home costs). Algorithm: Linear regression.
• Classification: Predict discrete courses (e.g., spam detection). Algorithm: Logistic regression, Resolution bushes.

B. Unsupervised Studying

Idea:

• Works with unlabeled knowledge (no predefined outputs).
• Objective: Uncover hidden patterns or groupings.

Examples:

• Clustering: Group comparable knowledge factors (e.g., buyer segmentation). Algorithm: Okay-Means.
• Dimensionality Discount: Cut back options whereas preserving data. Algorithm: PCA (Principal Part Evaluation).

C. Reinforcement Studying

Idea:

• Agent learns by interacting with an surroundings to maximise rewards.
• Utilized in robotics, sport AI (e.g., AlphaGo).

Idea:

• Bias: Error resulting from overly simplistic assumptions (underfitting).
• Variance: Error resulting from sensitivity to noise in coaching knowledge (overfitting).

Steadiness:

• Excessive Bias: Mannequin is just too easy (misses patterns).
• Excessive Variance: Mannequin is just too advanced (memorizes noise).
• Objective: Discover a mannequin with low bias and low variance.

A. Loss perform

A metric that quantifies how unhealthy the mannequin’s predictions are.

B. Gradient descent

Idea:

• Optimization algorithm to decrease the loss perform.
• Steps:

1. Compute the gradient (slope) of the loss with respect to mannequin parameters.
2. Replace parameters within the route of the steepest descent.
3. Repeat till convergence.

C. Overfitting vs. Underfitting

• Overfitting: Mannequin performs properly on coaching knowledge however poorly on check knowledge.
• Repair: Regularization (L1/L2), scale back mannequin complexity, or get extra knowledge.
• Underfitting: Mannequin performs poorly on each coaching and check knowledge.
• Repair: Enhance mannequin complexity or add options.

1. Outline the issue: What are you making an attempt to foretell?
2. Accumulate and put together knowledge: Clear, normalize, cut up into practice/check units.
3. Select a mannequin: Primarily based on drawback kind (e.g., regression → Linear regression).
4. Prepare the mannequin: Modify parameters to attenuate loss.
5. Consider: Take a look at on unseen knowledge utilizing metrics.
6. Deploy: Combine the mannequin into functions.

Idea:

• NumPy: Environment friendly numerical computations (arrays, matrices).
• Pandas: Information manipulation and evaluation (DataFrames).
• Scikit-learn: Implements ML algorithms (regression, classification, clustering).
• Matplotlib/Seaborn: Visualize knowledge distributions and outcomes.
• TensorFlow/Keras: Construct and practice neural networks.

Set up

# Set up libraries
pip set up numpy pandas matplotlib scikit-learn tensorflow

Step 1: Load knowledge

Idea: Uncooked knowledge is usually messy or incomplete. Loading it right into a structured format (e.g., DataFrame) is step one.

Follow:

import pandas as pd
knowledge = pd.read_csv('knowledge.csv')  # Load CSV file

Step 2: Deal with lacking ata

Idea: Lacking values (e.g., NaN) can bias fashions. Widespread methods:

• Drop rows/columns: If lacking knowledge is minimal.
• Impute: Fill lacking values with imply/median (numeric) or mode (categorical).

Follow:

from sklearn.impute import SimpleImputer
imputer = SimpleImputer(technique='imply')  # Change NaNs with column imply
knowledge[['age']] = imputer.fit_transform(knowledge[['age']])

Step 3: Encode categorical knowledge

Idea:

Most ML algorithms work with numbers, not textual content. Convert categorical knowledge (e.g., “crimson”, “blue”) to numeric labels.

• Label Encoding: Convert classes to integers (e.g., “crimson” → 0, “blue” → 1).
• One-Scorching Encoding: Create binary columns for every class.

Follow:

from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder()
knowledge['color'] = encoder.fit_transform(knowledge['color'])  # "crimson" → 0, "blue" → 1

Step 4: Function scaling

Idea: Options on completely different scales (e.g., age: 0–100 vs. wage: 0–1,000,000) can distort distance-based algorithms (e.g., Okay-Means, SVM).

• Standardization: Scale options to have imply=0 and variance=1.
• Normalization: Scale options to a spread (e.g., 0–1).

Follow:

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)  # Match on coaching knowledge
X_test = scaler.remodel(X_test)        # Apply similar scaling to check knowledge

Idea:

• Objective: Predict a steady worth (e.g., home worth).
• Equation: y=β0+β1×1+β2×2+…+βnxny=β0​+β1​x1​+β2​x2​+…+βn​xn​, the place ββ are coefficients realized from knowledge.
• Loss Operate: Imply Squared Error (MSE) quantifies prediction errors.
• Optimization: Gradient Descent adjusts coefficients to attenuate MSE.

Follow:

from sklearn.linear_model import LinearRegression
mannequin = LinearRegression()       # Create mannequin
mannequin.match(X_train, y_train)      # Prepare: Modify β to attenuate MSE
y_pred = mannequin.predict(X_test)   # Predict on new knowledge
# Consider
from sklearn.metrics import mean_squared_error
print("MSE:", mean_squared_error(y_test, y_pred))

Idea:

• Objective: Predict binary courses (e.g., spam vs. not spam).
• Logistic Operate: Squashes output to [0, 1] to characterize possibilities.
• Loss Operate: Cross-Entropy Loss penalizes mistaken class possibilities.

Follow:

from sklearn.linear_model import LogisticRegression
mannequin = LogisticRegression()
mannequin.match(X_train, y_train)      # Prepare: Modify β to attenuate cross-entropy
y_pred = mannequin.predict(X_test)   # Predict class labels (0 or 1)

# Consider
from sklearn.metrics import accuracy_score
print("Accuracy:", accuracy_score(y_test, y_pred))

Idea:

• Objective: Group comparable knowledge factors into ok clusters.
• Algorithm:

1. Randomly initialize ok cluster facilities.
2. Assign every level to the closest heart.
3. Replace facilities to the imply of assigned factors.
4. Repeat till convergence.

Follow:

from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=3)    # Create mannequin with 3 clusters
kmeans.match(X)                    # Discover clusters in knowledge
labels = kmeans.predict(X)       # Assign cluster labels

# Visualize
import matplotlib.pyplot as plt
plt.scatter(X[:,0], X[:,1], c=labels)
plt.present()

Idea:

• Prepare-Take a look at Break up: Consider on unseen knowledge to detect overfitting.
• Cross-Validation: Break up knowledge into ok folds; practice on k-1 folds, check on the remaining fold.

Follow:

from sklearn.model_selection import train_test_split, cross_val_score
# Break up knowledge
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Cross-validation
scores = cross_val_score(mannequin, X, y, cv=5)  # 5-fold CV
print("Common CV Accuracy:", scores.imply())

Idea:

• Hyperparameters: Settings for algorithms (e.g., n_clusters in Okay-Means, C in SVM).
• Grid Search: Take a look at all mixtures of hyperparameters to search out the perfect performer.

Follow:

from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC

param_grid = {'C': [0.1, 1, 10], 'kernel': ['linear', 'rbf']}
grid = GridSearchCV(SVC(), param_grid, cv=5)
grid.match(X_train, y_train)
print("Finest Parameters:", grid.best_params_)

A bit understanding

Idea:

• Neural Networks: Layers of interconnected nodes (neurons) that be taught hierarchical options.
• Activation capabilities: Introduce non-linearity (e.g., ReLU, Sigmoid).
• Backpropagation: Modify weights utilizing gradient descent to attenuate loss.

Follow:

from tensorflow.keras.fashions import Sequential
from tensorflow.keras.layers import Dense

mannequin = Sequential([
Dense(64, activation='relu', input_shape=(10,)),  # Input layer
Dense(32, activation='relu'),                    # Hidden layer
Dense(1, activation='sigmoid')                   # Output layer
])
mannequin.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
mannequin.match(X_train, y_train, epochs=10, batch_size=32)