Introduction to Machine Learning

1. What Is Machine Learning?

In traditional software engineering, a programmer writes explicit rules and logic: if temperature > 30, turn on cooling. The computer takes data and applies human-written rules to calculate answers.

Machine Learning (ML) flips this paradigm upside down: instead of writing the rules yourself, you feed the computer data and observed outcomes, and the algorithm discovers the mathematical patterns and rules automatically.

2. The Three Primary Types of Machine Learning

Machine learning problems generally fall into three overarching paradigms based on the nature of the data and learning objective:

A. Supervised Learning (Learning with a Teacher)

The training data includes both input features (X) and labeled target answers (y). The algorithm learns a mapping function from input to output.

• Regression: Predicting continuous numerical quantities (e.g., forecasting house prices, customer lifetime value, or tomorrow's temperature).
• Classification: Predicting discrete category labels (e.g., email spam detection, credit fraud classification, or tumor malignancy).

B. Unsupervised Learning (Finding Hidden Structure)

The model receives unlabeled data (only features X, no target y). Its objective is to uncover inherent groupings, anomalies, or compressed representations.

• Clustering: Grouping similar observations together (e.g., customer market segmentation with K-Means).
• Dimensionality Reduction: Compressing high-dimensional datasets while preserving variance (e.g., PCA).
• Anomaly Detection: Identifying rare observations that deviate from normal patterns (e.g., network intrusion detection).

C. Reinforcement Learning (Learning by Trial and Reward)

An autonomous agent interacts with an environment, executing actions and receiving scalar rewards or penalties. Through exploration and exploitation, it learns an optimal policy to maximize cumulative rewards (e.g., self-driving navigation, robotic arm manipulation, and game playing).

3. The End-to-End Machine Learning Workflow

Successful applied machine learning follows a systematic engineering lifecycle:

1. Problem Definition: Frame the business problem as an ML task (classification, regression, or clustering) and define success metrics (e.g., RMSE, F1-score, latency).
2. Data Collection & Exploration (EDA): Gather representative datasets, inspect distributions, detect anomalies, and uncover feature correlations.
3. Data Preprocessing: Handle missing values, encode categorical variables, scale numerical features, and perform train/test splits (covered in detail in Module 2).
4. Model Training: Train candidate algorithms (e.g., Linear Regression, Random Forest, XGBoost) on historical training data.
5. Evaluation & Validation: Measure performance on unseen test data using cross-validation to guard against overfitting.
6. Deployment & Monitoring: Serve predictions via APIs, monitor data drift, and retrain models as underlying distributions evolve.

4. Your First Model in Python: 5 Lines of Scikit-Learn

Python's scikit-learn library provides a consistent, clean API across all classical algorithms: fit() to train, and predict() to infer.

from sklearn.neighbors import KNeighborsClassifier

# 1. Feature data: [Age, Annual Salary in k]
X_train = [[22, 25], [28, 45], [35, 80], [45, 120], [50, 140]]
# 2. Labels: 0 = No purchase, 1 = Purchase premium service
y_train = [0, 0, 1, 1, 1]

# 3. Instantiate model
model = KNeighborsClassifier(n_neighbors=3)

# 4. Train the model (find mathematical patterns)
model.fit(X_train, y_train)

# 5. Make a prediction on a new prospective customer
new_customer = [[30, 60]]
prediction = model.predict(new_customer)
print("Predicted class:", prediction[0]) # Output: 1