Introduction to Artificial Intelligence & Machine Learning

Learning Objectives

After completing this chapter, you will be able to:

1. Define Artificial Intelligence using formal definitions by Turing, McCarthy, and Russell & Norvig.
2. Distinguish between AI, Machine Learning, Deep Learning, and Data Science with precise boundaries.
3. Classify ML paradigms: Supervised (classification & regression), Unsupervised (clustering & dimensionality reduction), Reinforcement, and Self-Supervised Learning.
4. Describe the end-to-end ML workflow from problem definition to deployment.
5. Explain why ML has become feasible now — data, compute, algorithms, and cloud.
6. Implement your first ML model using scikit-learn, TensorFlow, and pandas.
7. Analyze real-world AI applications in Indian systems (Aadhaar, UPI, CoWIN) and global platforms (Google, Tesla, Netflix).
8. Compare Narrow AI, General AI, and Super AI with examples and feasibility timelines.
9. Evaluate career paths in AI/ML with salary benchmarks for India and global markets.
10. Apply foundational mathematical concepts (probability, linear algebra) to ML problem formulation.

Introduction

Artificial Intelligence (AI) is no longer science fiction. Every time you unlock your phone with your face, ask Siri for the weather, or see a product recommendation on Flipkart, you're interacting with AI. In India alone, AI is projected to add $967 billion to the economy by 2035 (Accenture). Globally, the AI market will exceed $1.8 trillion by 2030 (Grand View Research).

But what exactly is AI? How does it relate to Machine Learning? And why has it suddenly become so powerful after decades of relative dormancy? This chapter answers these foundational questions with rigorous definitions, clear visual models, working Python code, and real-world case studies spanning both Indian and global ecosystems.

What is AI? — Four Authoritative Definitions

1. Alan Turing (1950) — The Imitation Game

In his seminal paper "Computing Machinery and Intelligence," Turing asked: "Can machines think?" He proposed the Turing Test: if a machine can carry on a conversation indistinguishable from a human's (to a human judge), it can be said to "think." This was a behavioral definition — it didn't care about internal mechanisms, only observable behavior.

2. John McCarthy (1956) — The Dartmouth Definition

McCarthy coined the term "Artificial Intelligence" for the famous 1956 Dartmouth Conference. He defined AI as: "The science and engineering of making intelligent machines, especially intelligent computer programs." This is a constructive definition — focused on building systems rather than just testing them.

3. Russell & Norvig (2020) — Four Approaches

In Artificial Intelligence: A Modern Approach (the most widely used AI textbook globally), Stuart Russell and Peter Norvig organize AI definitions along two dimensions:

Modern AI research primarily follows the rational agent approach — building agents that take the best possible action given available information.

4. Tom Mitchell (1997) — Formal ML Definition

Mitchell provided the most precise and widely-cited formal definition of Machine Learning:

Example: A spam filter (T = classifying emails as spam/not-spam) learns from labeled emails (E = dataset of emails marked spam/ham) and improves its accuracy (P = % of correctly classified emails) over time.

What is Machine Learning? — Arthur Samuel's Insight

Arthur Samuel (1959) defined ML as: "The field of study that gives computers the ability to learn without being explicitly programmed." Samuel created a checkers-playing program that improved by playing thousands of games against itself — one of the earliest examples of self-play, a concept that would later power AlphaGo.

The key insight of ML is the shift from rule-based programming to data-driven learning:

Historical Background

The history of AI spans nearly 80 years of breakthroughs, winters, and renaissances. Understanding this history helps you appreciate why certain techniques work and why progress was uneven.

Conceptual Explanation

AI vs ML vs Deep Learning vs Data Science

These terms are often used interchangeably, but they have distinct meanings. Think of them as nested sets:

Types of Machine Learning

1. Supervised Learning

The model learns from labeled data — input-output pairs. Like a student learning from a textbook with answer keys.

• Classification: Predict a discrete category. Examples: spam detection (spam/ham), disease diagnosis (malignant/benign), image recognition (cat/dog).
• Regression: Predict a continuous value. Examples: house price prediction, temperature forecasting, stock price estimation.

Algorithms: Linear Regression, Logistic Regression, Decision Trees, Random Forests, SVMs, k-NN, Neural Networks.

2. Unsupervised Learning

The model finds patterns in unlabeled data. Like organizing a library without knowing the categories beforehand.

• Clustering: Group similar items. Examples: customer segmentation, gene expression grouping, document clustering.
• Dimensionality Reduction: Reduce features while preserving structure. Examples: PCA for visualization, t-SNE for embeddings.
• Association: Find co-occurrence patterns. Example: market basket analysis ("customers who buy X also buy Y").

Algorithms: k-Means, DBSCAN, Hierarchical Clustering, PCA, t-SNE, Autoencoders, Apriori.

3. Reinforcement Learning (RL)

An agent learns by interacting with an environment, receiving rewards or penalties. Like training a dog with treats.

• No labeled data — only reward signals
• Explores vs exploits (exploration-exploitation tradeoff)
• Examples: AlphaGo, robotic control, autonomous driving, game playing

Algorithms: Q-Learning, Deep Q-Networks (DQN), Policy Gradient, PPO, Actor-Critic, SARSA.

4. Self-Supervised Learning

A newer paradigm where the model creates its own labels from the data structure itself. This is how GPT (predict next word), BERT (predict masked word), and contrastive learning (SimCLR) work.

• Technically unsupervised, but uses supervisory signals derived from data
• Powers modern foundation models (LLMs, vision transformers)
• Scales to massive unlabeled datasets (entire internet)

The AI Landscape: Narrow AI vs General AI vs Super AI

Why ML Now? The Four Catalysts

1. Data Explosion: We generate 2.5 quintillion bytes/day. Social media, IoT, sensors, transactions — all fuel for ML.
2. Compute Power: GPUs (NVIDIA A100: 312 TFLOPS), TPUs (Google), and cloud computing make training massive models feasible. Training GPT-3 cost ~$4.6M in compute.
3. Better Algorithms: Transformers, attention mechanisms, batch normalization, dropout, Adam optimizer — algorithmic breakthroughs made deep learning practical.
4. Open-Source Ecosystem: TensorFlow, PyTorch, scikit-learn, Hugging Face — anyone can access state-of-the-art tools for free.

Mathematical Foundation

ML is built on four mathematical pillars: Linear Algebra, Probability & Statistics, Calculus, and Optimization. In this introductory chapter, we cover the essentials.

1. Probability Basics

ML Connection: Bayes' theorem is the foundation of Naive Bayes classifiers (spam detection), Bayesian networks, and probabilistic graphical models. It tells us how to update our beliefs when new evidence arrives.

2. Linear Algebra Essentials

3. Calculus for Optimization

4. Mean Squared Error (MSE)

5. Accuracy, Precision, Recall

Formula Derivations

Deriving Gradient Descent for Linear Regression from First Principles

Goal: Find the weights w and bias b that minimize the error between our predictions and actual values.

Step 1: Define the Model

Step 2: Define the Loss Function (MSE)

Step 3: Compute Partial Derivative with respect to w

Step 4: Compute Partial Derivative with respect to b

Step 5: Update Rule

Deriving Bayes' Theorem from Joint Probability

Worked Numerical Examples

Example 1: Linear Regression — Predicting House Prices

Example 2: Bayes' Theorem — Spam Classification

Example 3: Computing Accuracy, Precision, Recall

Visual Diagrams

Flowcharts

Python Implementation

10.1 Hello World — Iris Classification with scikit-learn

Python
# ============================================================
# ML Hello World: Iris Flower Classification
# Dataset: 150 flowers, 4 features, 3 species
# ============================================================

# Step 1: Import libraries
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report
import numpy as np

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

print(f"Dataset shape: {X.shape}")           # (150, 4)
print(f"Feature names: {iris.feature_names}")
print(f"Class names: {iris.target_names}")

# Step 3: Split into train and test sets (80/20)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
print(f"\nTraining samples: {len(X_train)}")  # 120
print(f"Testing samples: {len(X_test)}")      # 30

# Step 4: Train a Decision Tree Classifier
model = DecisionTreeClassifier(
    max_depth=3,           # Limit depth to prevent overfitting
    random_state=42
)
model.fit(X_train, y_train)

# Step 5: Make predictions
y_pred = model.predict(X_test)

# Step 6: Evaluate
accuracy = accuracy_score(y_test, y_pred)
print(f"\nAccuracy: {accuracy:.2%}")          # ~96.67%
print("\nClassification Report:")
print(classification_report(y_test, y_pred,
      target_names=iris.target_names))

# Step 7: Predict on new data
new_flower = np.array([[5.1, 3.5, 1.4, 0.2]])  # Measurements
prediction = model.predict(new_flower)
print(f"\nPredicted species: {iris.target_names[prediction[0]]}")

10.2 Exploratory Data Analysis with pandas & matplotlib

Python
# ============================================================
# EDA: Exploring the Iris Dataset
# ============================================================

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from sklearn.datasets import load_iris

# Load data into a DataFrame
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['species'] = pd.Categorical.from_codes(iris.target, iris.target_names)

# Basic statistics
print("=" * 60)
print("DATASET OVERVIEW")
print("=" * 60)
print(f"Shape: {df.shape}")
print(f"\nFirst 5 rows:\n{df.head()}")
print(f"\nData types:\n{df.dtypes}")
print(f"\nMissing values:\n{df.isnull().sum()}")  # None! 🎉
print(f"\nStatistical summary:\n{df.describe()}")

# Distribution of species
print(f"\nSpecies distribution:\n{df['species'].value_counts()}")

# Correlation matrix
print(f"\nCorrelation matrix:")
print(df.iloc[:, :4].corr().round(2))

# ---- Visualization ----
fig, axes = plt.subplots(2, 2, figsize=(12, 10))
fig.suptitle('Iris Dataset — Exploratory Data Analysis', fontsize=16)

# 1. Histogram of petal length
axes[0, 0].hist([df[df.species == s]['petal length (cm)']
                 for s in iris.target_names],
                label=iris.target_names, bins=15, alpha=0.7)
axes[0, 0].set_title('Petal Length Distribution')
axes[0, 0].set_xlabel('Petal Length (cm)')
axes[0, 0].legend()

# 2. Scatter: petal length vs petal width
colors = {'setosa': '#059669', 'versicolor': '#0891b2', 'virginica': '#7c3aed'}
for species in iris.target_names:
    subset = df[df.species == species]
    axes[0, 1].scatter(subset['petal length (cm)'],
                       subset['petal width (cm)'],
                       label=species, alpha=0.7, c=colors[species])
axes[0, 1].set_title('Petal Length vs Width')
axes[0, 1].set_xlabel('Petal Length (cm)')
axes[0, 1].set_ylabel('Petal Width (cm)')
axes[0, 1].legend()

# 3. Box plot of sepal width by species
df.boxplot(column='sepal width (cm)', by='species', ax=axes[1, 0])
axes[1, 0].set_title('Sepal Width by Species')

# 4. Feature importance bar chart (from Decision Tree)
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier(max_depth=3, random_state=42)
model.fit(iris.data, iris.target)
importances = model.feature_importances_
axes[1, 1].barh(iris.feature_names, importances, color='#059669')
axes[1, 1].set_title('Feature Importance (Decision Tree)')

plt.tight_layout()
plt.savefig('iris_eda.png', dpi=150, bbox_inches='tight')
plt.show()
print("✅ EDA complete! Plot saved to iris_eda.png")

10.3 Gradient Descent from Scratch

Python
# ============================================================
# Gradient Descent for Linear Regression — From Scratch
# ============================================================

import numpy as np
import matplotlib.pyplot as plt

# Generate synthetic data: y = 3x + 7 + noise
np.random.seed(42)
X = np.random.uniform(1, 10, 100)
y = 3 * X + 7 + np.random.normal(0, 2, 100)

# Initialize parameters
w = 0.0    # weight
b = 0.0    # bias
lr = 0.01  # learning rate
epochs = 100
n = len(X)
history = []

# Gradient Descent
for epoch in range(epochs):
    # Forward pass: predictions
    y_pred = w * X + b

    # Compute loss (MSE)
    loss = np.mean((y - y_pred) ** 2)
    history.append(loss)

    # Compute gradients
    dw = -(2/n) * np.sum((y - y_pred) * X)
    db = -(2/n) * np.sum(y - y_pred)

    # Update parameters
    w -= lr * dw
    b -= lr * db

    if (epoch + 1) % 20 == 0:
        print(f"Epoch {epoch+1:3d} | Loss: {loss:.4f} | w: {w:.4f} | b: {b:.4f}")

print(f"\nFinal: y = {w:.3f}x + {b:.3f}")
print(f"Target: y = 3.000x + 7.000")

# Plot loss curve
plt.figure(figsize=(8, 4))
plt.plot(history, color='#059669', linewidth=2)
plt.title('Gradient Descent Convergence')
plt.xlabel('Epoch')
plt.ylabel('MSE Loss')
plt.grid(alpha=0.3)
plt.show()

TensorFlow Implementation

TensorFlow Hello World — MNIST Digit Classification

Python / TensorFlow
# ============================================================
# TF Hello World: MNIST Handwritten Digit Classification
# Dataset: 70,000 grayscale images (28x28) of digits 0-9
# ============================================================

import tensorflow as tf
from tensorflow import keras
import numpy as np

print(f"TensorFlow version: {tf.__version__}")

# Step 1: Load MNIST dataset
(X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data()
print(f"Training: {X_train.shape}, Testing: {X_test.shape}")
# Training: (60000, 28, 28), Testing: (10000, 28, 28)

# Step 2: Preprocess — normalize pixel values to [0, 1]
X_train = X_train.astype('float32') / 255.0
X_test = X_test.astype('float32') / 255.0

# Flatten 28x28 images to 784-dim vectors (for simple dense network)
X_train_flat = X_train.reshape(-1, 784)
X_test_flat = X_test.reshape(-1, 784)

# Step 3: Build the model
model = keras.Sequential([
    keras.layers.Dense(128, activation='relu', input_shape=(784,),
                       name='hidden_layer_1'),
    keras.layers.Dropout(0.2, name='dropout_regularization'),
    keras.layers.Dense(64, activation='relu', name='hidden_layer_2'),
    keras.layers.Dense(10, activation='softmax', name='output_layer')
])

# Step 4: Compile
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

model.summary()

# Step 5: Train
history = model.fit(
    X_train_flat, y_train,
    epochs=10,
    batch_size=32,
    validation_split=0.1,
    verbose=1
)

# Step 6: Evaluate on test set
test_loss, test_acc = model.evaluate(X_test_flat, y_test, verbose=0)
print(f"\nTest Accuracy: {test_acc:.2%}")     # ~97.5%

# Step 7: Make a prediction
sample = X_test_flat[:1]                       # First test image
prediction = model.predict(sample)
predicted_digit = np.argmax(prediction)
actual_digit = y_test[0]
print(f"Predicted: {predicted_digit}, Actual: {actual_digit}")
print(f"Confidence: {prediction[0][predicted_digit]:.2%}")

# Step 8: Plot training history
import matplotlib.pyplot as plt
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
ax1.plot(history.history['accuracy'], label='Train')
ax1.plot(history.history['val_accuracy'], label='Validation')
ax1.set_title('Accuracy'); ax1.legend()
ax2.plot(history.history['loss'], label='Train')
ax2.plot(history.history['val_loss'], label='Validation')
ax2.set_title('Loss'); ax2.legend()
plt.tight_layout(); plt.show()

Scikit-Learn Complete Pipeline

Python / scikit-learn
# ============================================================
# Production-Ready ML Pipeline with scikit-learn
# Task: Predict if a customer will churn (binary classification)
# ============================================================

import numpy as np
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.impute import SimpleImputer
from sklearn.model_selection import (train_test_split,
                                     cross_val_score,
                                     GridSearchCV)
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (accuracy_score, classification_report,
                             confusion_matrix, roc_auc_score)
import warnings
warnings.filterwarnings('ignore')

# --- Generate synthetic customer data ---
np.random.seed(42)
n = 1000
data = pd.DataFrame({
    'age': np.random.randint(18, 70, n),
    'monthly_charges': np.random.uniform(200, 5000, n),
    'tenure_months': np.random.randint(1, 72, n),
    'support_tickets': np.random.poisson(2, n),
    'contract_type': np.random.choice(['month-to-month', '1-year', '2-year'], n),
})

# Create target: churn is more likely for short tenure + high charges
churn_prob = 1 / (1 + np.exp(-(
    -2 + 0.03 * data['monthly_charges']/100
    - 0.05 * data['tenure_months']
    + 0.3 * data['support_tickets']
)))
data['churned'] = (np.random.random(n) < churn_prob).astype(int)
print(f"Churn rate: {data['churned'].mean():.1%}")

# --- Preprocessing ---
# Encode categorical variable
le = LabelEncoder()
data['contract_encoded'] = le.fit_transform(data['contract_type'])

features = ['age', 'monthly_charges', 'tenure_months',
            'support_tickets', 'contract_encoded']
X = data[features]
y = data['churned']

# Train/test split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# --- Build Pipeline ---
pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler()),
    ('classifier', RandomForestClassifier(random_state=42))
])

# --- Cross-Validation ---
cv_scores = cross_val_score(pipeline, X_train, y_train, cv=5, scoring='accuracy')
print(f"\nCross-validation accuracy: {cv_scores.mean():.2%} ± {cv_scores.std():.2%}")

# --- Hyperparameter Tuning with GridSearchCV ---
param_grid = {
    'classifier__n_estimators': [50, 100, 200],
    'classifier__max_depth': [3, 5, 10, None],
    'classifier__min_samples_split': [2, 5, 10],
}

grid_search = GridSearchCV(
    pipeline, param_grid, cv=3,
    scoring='roc_auc', n_jobs=-1, verbose=0
)
grid_search.fit(X_train, y_train)

print(f"Best params: {grid_search.best_params_}")
print(f"Best AUC-ROC: {grid_search.best_score_:.4f}")

# --- Final Evaluation ---
best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test)
y_proba = best_model.predict_proba(X_test)[:, 1]

print(f"\n{'='*50}")
print(f"FINAL TEST RESULTS")
print(f"{'='*50}")
print(f"Accuracy:  {accuracy_score(y_test, y_pred):.2%}")
print(f"AUC-ROC:   {roc_auc_score(y_test, y_proba):.4f}")
print(f"\nClassification Report:\n{classification_report(y_test, y_pred)}")
print(f"Confusion Matrix:\n{confusion_matrix(y_test, y_pred)}")

Indian Case Studies

🔹 Case Study 1: Aadhaar — Biometric Authentication at Billion Scale

🔹 Case Study 2: UPI — Real-Time Fraud Detection

🔹 Case Study 3: CoWIN — Vaccine Scheduling Optimization

🔹 Case Study 4: ISRO — Satellite Image Classification

ISRO uses deep learning (U-Net, ResNet) on satellite imagery from Cartosat and RISAT for:

• Crop classification: Identifying crop types across millions of hectares for Fasal Bima Yojana (crop insurance)
• Disaster assessment: Flood mapping, forest fire detection, cyclone tracking
• Urban planning: Change detection in urban sprawl, illegal construction identification
• Water body monitoring: Tracking reservoir levels for drought prediction

🔹 Case Study 5: DigiLocker — Document Verification

DigiLocker (170M+ users) uses ML for:

• OCR (Optical Character Recognition): Extracting text from uploaded documents using CNN-based models
• Document classification: Automatically categorizing uploaded documents (Aadhaar, PAN, marksheets, etc.)
• Tamper detection: Using image forensics and anomaly detection to flag potentially altered documents

Global Case Studies

🌍 Case Study 1: Google Search — PageRank + ML Ranking

🌍 Case Study 2: Tesla Autopilot — Computer Vision

🌍 Case Study 3: Netflix — Recommendation Engine

🌍 Case Study 4: Amazon Alexa — NLU Pipeline

Alexa processes voice commands through a multi-stage ML pipeline:

1. Wake Word Detection: Small neural network runs continuously, listens for "Alexa" (keyword spotting)
2. ASR (Automatic Speech Recognition): Converts audio → text using CTC-based models + language models
3. NLU (Natural Language Understanding): Intent classification ("play music" vs "set timer") + entity extraction ("play Bollywood songs")
4. Dialog Management: Maintains conversation state for multi-turn interactions
5. TTS (Text-to-Speech): Neural TTS (WaveNet-style) generates natural-sounding responses

🌍 Case Study 5: OpenAI ChatGPT — Architecture Overview

ChatGPT is built on the GPT (Generative Pre-trained Transformer) architecture:

1. Pre-training: Self-supervised learning on trillions of tokens from the internet. The model learns to predict the next token. Cost: ~$100M for GPT-4.
2. Supervised Fine-Tuning (SFT): Trained on high-quality human-written conversations to follow instructions.
3. RLHF (Reinforcement Learning from Human Feedback): A reward model is trained on human preferences (which response is better?). Then PPO (Proximal Policy Optimization) optimizes the language model to generate preferred responses.

Scale: GPT-4 has an estimated 1.8 trillion parameters across 120 layers. Inference runs on thousands of NVIDIA A100/H100 GPUs. ChatGPT reached 100 million users in 2 months — the fastest-growing consumer application in history.

Startup Applications

Government Applications

Industry Applications

Mini Projects

🔬 Mini Project 1: Complete Iris Flower Classifier

Python — Mini Project 1
# ============================================================
# MINI PROJECT 1: Iris Flower Classifier — Model Comparison
# ============================================================

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report
import warnings
warnings.filterwarnings('ignore')

# Load data
iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Define models to compare
models = {
    'Logistic Regression': LogisticRegression(max_iter=200),
    'Decision Tree': DecisionTreeClassifier(max_depth=4),
    'Random Forest': RandomForestClassifier(n_estimators=100),
    'SVM (RBF)': SVC(kernel='rbf', probability=True),
    'k-NN (k=5)': KNeighborsClassifier(n_neighbors=5),
}

# Train and evaluate each model
print(f"{'Model':<25} {'CV Accuracy':>12} {'Test Accuracy':>14}")
print("=" * 55)

results = {}
for name, model in models.items():
    # Build pipeline with scaling
    pipe = Pipeline([
        ('scaler', StandardScaler()),
        ('model', model)
    ])

    # 5-fold cross-validation on training data
    cv_scores = cross_val_score(pipe, X_train, y_train, cv=5, scoring='accuracy')

    # Train on full training set and test
    pipe.fit(X_train, y_train)
    test_acc = pipe.score(X_test, y_test)

    results[name] = {'cv': cv_scores.mean(), 'test': test_acc}
    print(f"{name:<25} {cv_scores.mean():>11.2%} {test_acc:>13.2%}")

# Best model
best = max(results, key=lambda k: results[k]['test'])
print(f"\n🏆 Best model: {best} (Test: {results[best]['test']:.2%})")

🔬 Mini Project 2: Simple Sentiment Analyzer

Python — Mini Project 2
# ============================================================
# MINI PROJECT 2: Simple Sentiment Analyzer
# Using TF-IDF + Logistic Regression
# ============================================================

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
from sklearn.pipeline import Pipeline

# --- Sample dataset (replace with real dataset for production) ---
reviews = [
    "This product is absolutely amazing! Best purchase ever.",
    "Terrible quality. Broke after one day. Complete waste of money.",
    "Love it! Works perfectly and arrived on time.",
    "Worst experience. Would not recommend to anyone.",
    "Great value for money. My family loves it.",
    "Disgusting. The food was stale and overpriced.",
    "Excellent service. The staff was very helpful.",
    "Horrible. Never buying from this company again.",
    "Fantastic quality. Exceeded my expectations!",
    "Very disappointing. Nothing like the advertisement.",
    "The movie was brilliant. Outstanding performances!",
    "Waste of two hours. The plot made no sense.",
    "Superb build quality. Premium feel throughout.",
    "Pathetic customer service. Ignored my complaints.",
    "Beautifully designed. Elegant and functional.",
    "Utter rubbish. Falls apart immediately.",
    "The food was delicious and the ambiance wonderful.",
    "Terrible app. Crashes constantly and drains battery.",
    "Very impressed with the speed and accuracy.",
    "Complete scam. They never delivered my order.",
]

# Labels: 1 = Positive, 0 = Negative
labels = [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]

X_train, X_test, y_train, y_test = train_test_split(
    reviews, labels, test_size=0.3, random_state=42
)

# Build pipeline: TF-IDF → Logistic Regression
sentiment_pipeline = Pipeline([
    ('tfidf', TfidfVectorizer(
        max_features=5000,
        ngram_range=(1, 2),    # Unigrams + bigrams
        stop_words='english',
        min_df=1
    )),
    ('classifier', LogisticRegression(max_iter=1000))
])

# Train
sentiment_pipeline.fit(X_train, y_train)

# Evaluate
y_pred = sentiment_pipeline.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, y_pred):.2%}")
print(f"\nClassification Report:\n")
print(classification_report(y_test, y_pred,
      target_names=['Negative', 'Positive']))

# --- Predict on new sentences ---
new_reviews = [
    "This is the best phone I've ever used!",
    "Terrible experience, I want a refund.",
    "Decent product, nothing special but works fine.",
    "The delivery was quick and the quality is top-notch!",
    "Absolutely horrible. The worst investment I've made.",
]

predictions = sentiment_pipeline.predict(new_reviews)
print("\n--- New Predictions ---")
for review, pred in zip(new_reviews, predictions):
    sentiment = "✅ Positive" if pred == 1 else "❌ Negative"
    print(f"{sentiment}: \"{review[:60]}...\"")

# Show top features
feature_names = sentiment_pipeline.named_steps['tfidf'].get_feature_names_out()
coefs = sentiment_pipeline.named_steps['classifier'].coef_[0]
top_positive = np.argsort(coefs)[-10:]
top_negative = np.argsort(coefs)[:10]

print("\n📊 Top Positive Words:", [feature_names[i] for i in top_positive])
print("📊 Top Negative Words:", [feature_names[i] for i in top_negative])

End-of-Chapter Exercises

Multiple Choice Questions

Interview Questions

Research Problems

Key Takeaways

• AI is the field of making machines intelligent; ML is its most successful method today, where machines learn from data rather than explicit rules. DL is a subset of ML using multi-layer neural networks.
• Tom Mitchell's definition is foundational: ML = learning from Experience (E) to perform Task (T), measured by Performance (P). Apply this framework to any ML problem.
• Four types of ML: Supervised (labeled data → classification/regression), Unsupervised (unlabeled → clustering/dim-reduction), Reinforcement (rewards → optimal policy), Self-Supervised (data creates its own labels → foundation models).
• The ML pipeline is systematic: Problem → Data → EDA → Features → Model → Evaluate → Deploy. Each step matters; garbage in = garbage out.
• ML is feasible now because of four catalysts: data explosion (IoT, internet), compute (GPUs/TPUs), better algorithms (Transformers, attention), and open-source tools (TensorFlow, PyTorch, scikit-learn).
• Metrics matter more than accuracy: For imbalanced datasets (fraud, disease), use Precision, Recall, F1, and AUC-ROC. A 95% accuracy model can be useless if it misses all positive cases.
• India is a global AI powerhouse: Aadhaar (1.4B biometrics), UPI (12B monthly txns), CoWIN (2.2B vaccines), ISRO satellite imagery — India runs some of the world's largest AI systems.
• Mathematics is the language of ML: Linear algebra (matrices, vectors), calculus (gradients), probability (Bayes' theorem), and optimization (gradient descent) underpin every algorithm.
• Practice beats theory: Implement every concept in code. The gap between "understanding" gradient descent and implementing it from scratch is where real learning happens.
• AI raises ethical questions: Bias, fairness, explainability, privacy, and job displacement are active research areas. Responsible AI development is not optional — it's essential.

References & Further Reading

Textbooks

1. Russell, S. & Norvig, P. (2020). Artificial Intelligence: A Modern Approach (4th ed.). Pearson.
2. Mitchell, T. (1997). Machine Learning. McGraw-Hill.
3. Goodfellow, I., Bengio, Y. & Courville, A. (2016). Deep Learning. MIT Press.
4. Bishop, C. (2006). Pattern Recognition and Machine Learning. Springer.
5. Géron, A. (2022). Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow (3rd ed.). O'Reilly.

Seminal Papers

1. Turing, A.M. (1950). "Computing Machinery and Intelligence." Mind, 59(236), 433-460.
2. Rosenblatt, F. (1958). "The Perceptron: A Probabilistic Model." Psychological Review, 65(6).
3. Rumelhart, D., Hinton, G. & Williams, R. (1986). "Learning Representations by Back-Propagating Errors." Nature, 323.
4. Vaswani, A. et al. (2017). "Attention Is All You Need." NeurIPS.
5. Brown, T. et al. (2020). "Language Models are Few-Shot Learners." NeurIPS (GPT-3).

Indian AI Resources

1. NITI Aayog (2018). "National Strategy for Artificial Intelligence." Government of India.
2. IndiaAI Mission (2024). Ministry of Electronics & IT. indiaai.gov.in
3. UIDAI Annual Report (2024). Aadhaar Authentication Statistics.
4. NPCI (2024). UPI Transaction Data. npci.org.in
5. ISRO (2024). Remote Sensing Applications. isro.gov.in

Online Courses (Free)

1. Andrew Ng — Machine Learning (Coursera/Stanford)
2. fast.ai — Practical Deep Learning for Coders
3. MIT 6.S191 — Introduction to Deep Learning
4. NPTEL — Machine Learning by Prof. Sudeshna Sarkar (IIT Kharagpur)
5. Google ML Crash Course

Tools & Libraries

• scikit-learn: scikit-learn.org — Classical ML algorithms
• TensorFlow: tensorflow.org — Google's deep learning framework
• PyTorch: pytorch.org — Meta's research-focused DL framework
• pandas: pandas.pydata.org — Data manipulation
• Hugging Face: huggingface.co — Pre-trained model hub