ML Notes
HubAI vs ML vs Deep Learning — Machine LearningApplications of Machine LearningHistory of Machine LearningMachine Learning RoadmapWhat is Machine Learning?Calculus for Machine LearningData Preprocessing BasicsLinear Algebra for Machine LearningProbability Basics for Machine LearningPython for Machine LearningStatistics Basics for Machine LearningBias vs Variance TradeoffModel Evaluation OverviewOverfitting and UnderfittingReinforcement Learning Fundamentals — Machine LearningSupervised LearningTraining vs Testing DataTypes of Machine LearningUnsupervised LearningData Cleaning — Machine LearningData Collection for Machine LearningData Visualization for MLEncoding Categorical DataFeature EngineeringFeature ScalingHandling Missing ValuesTrain-Test SplitElastic Net RegressionLasso Regression (L1 Regularization)Multiple Linear RegressionPolynomial RegressionIntroduction to RegressionRegression ProjectsRidge Regression (L2 Regularization)Simple Linear RegressionIntroduction to ClassificationClassification ProjectsDecision TreesK-Nearest Neighbors (KNN)Logistic RegressionNaive Bayes ClassifierRandom Forest ClassificationSupport Vector Machine (SVM)XGBoost for ClassificationClustering in Machine Learning: Complete Guide to Unsupervised LearningClustering Projects: Real-World Applications and Implementation GuidesDBSCAN ClusteringGaussian Mixture Models (GMM): Probabilistic Clustering for Advanced Data AnalysisHierarchical ClusteringK-Means ClusteringDimensionality Reduction: Comprehensive Guide to Feature Reduction TechniquesFeature Selection Techniques: Choosing Informative Variables for ML ModelsLinear Discriminant Analysis (LDA): Supervised Dimensionality ReductionPrincipal Component Analysis (PCA)t-SNE: Non-Linear Dimensionality Reduction for Data VisualizationUMAP: Uniform Manifold Approximation and Projection for Modern Data VisualizationAdaBoost: Adaptive Boosting Algorithm Explained with ExamplesBagging: Bootstrap Aggregating for Reducing Model VarianceBoosting: Sequential Ensemble Learning for Bias and Variance ReductionEnsemble Learning: Complete Guide to Combining ML Models for Better PredictionsGradient Boosting: Building Powerful ML Models Through Sequential OptimizationRandom Forest: Complete Guide to Tree Ensembles and Feature ImportanceStacking: Advanced Ensemble Method Using Meta-Learners for Superior ML PredictionsActivation Functions in Neural NetworksBackpropagation: Complete Algorithm for Training Neural NetworksIntroduction to Deep Learning: Neural Networks, Architectures, and ApplicationsDeep Learning Projects: Hands-On Applications and Case StudiesNeural Networks Basics: Perceptron, Architecture, and TrainingPerceptron: Foundational Single-Neuron Classifier for Binary ClassificationPyTorch Basics: Building and Training Neural NetworksTensorFlow Basics: Building and Training Neural NetworksIntroduction to Natural Language Processing: Fundamentals and ApplicationsNLP Projects: Practical Applications from Sentiment Analysis to Machine TranslationStemming and Lemmatization: Reducing Words to Root Forms in NLPText Preprocessing: Essential Steps for NLP ApplicationsTF-IDF: Term Frequency-Inverse Document Frequency for Text Feature ExtractionTokenization in NLP: Breaking Text into Meaningful UnitsTransformers: The Architecture Behind Modern NLP ModelsWord Embeddings: Representing Words as Vectors for NLPIntroduction to Computer VisionComputer Vision ProjectsImage Classification: Building and Deploying CNN ModelsImage Processing BasicsImage Segmentation — Machine LearningObject DetectionOpenCV BasicsAgents and Environments in RLDeep Q-Networks (DQN)Policy Gradient Methods — Machine LearningQ-Learning AlgorithmReinforcement Learning: IntroductionReinforcement Learning ProjectsAccuracy, Precision, Recall: Classification Metrics Explained for ML InterviewConfusion Matrix: Complete Guide to Classification EvaluationCross-Validation: Comprehensive Guide to Robust Model EvaluationF1 Score: Balanced Classification Metric for Imbalanced DataGrid Search: Complete Guide to Hyperparameter Tuning in Machine LearningHyperparameter Tuning: Complete Guide to Optimizing Machine Learning ModelsModel Selection: Choosing the Best Algorithm for Your ML ProblemROC and AUC: Complete Guide to Classification Threshold EvaluationBuild an AI Assistant with LLMsBuild a Conversational ChatbotCustomer Churn PredictionFace Recognition System — Machine LearningHouse Price PredictionRecommendation System ProjectSentiment Analysis Project — Machine LearningSpam Email ClassifierML Case Study Questions for InterviewsML Coding Questions for Technical InterviewsMachine Learning Interview CheatsheetEssential Machine Learning Interview QuestionsStatistics for Machine Learning InterviewsDatasets for ML PracticeImportant ML FormulasMachine Learning GlossaryRecommended ML Books and CoursesCI/CD for Machine LearningDocker for Machine LearningFastAPI for Machine Learning APIsFlask API for Machine LearningMLOps: IntroductionModel Deployment StrategiesML Model Monitoring & Observability
A complete guide to the three main types of machine learning: supervised, unsupervised, and reinforcement learning with examples, comparisons, and Python code.
Machine learning algorithms are broadly categorized based on how they learn from data. The three main types are supervised learning, unsupervised learning, and reinforcement learning. Each has distinct characteristics and is suited for different kinds of problems.
Overview of ML Types
| Supervised | Unsupervised | Reinforcement | ||
|---|---|---|---|---|
| Learning | Learning | Learning | ||
| Has Labels | No Labels | Has Rewards | ||
| (X → y) | (X only) | (Action→R) |
Supervised Learning
In supervised learning, the algorithm learns from labeled training data — each input has a corresponding correct output (label). The model learns to map inputs to outputs.
Types of Supervised Problems
| │ ├── Binary | spam/not spam |
| │ ├── Multi-class | cat/dog/bird |
| │ └── Multi-label | tags on a blog post |
Example: Classification
python example
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# Supervised: we have features (X) AND labels (y)
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)
# The model learns the mapping: X -> y
model = DecisionTreeClassifier(random_state=42)
model.fit(X_train, y_train) # Learning from labeled examples
predictions = model.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, predictions):.2%}")Example: Regression
Example
from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression
import numpy as np
# Generate regression data with known relationship
X, y = make_regression(n_samples=100, n_features=1, noise=10, random_state=42)
model = LinearRegression()
model.fit(X, y)
print(f"Learned coefficient: {model.coef_[0]:.2f}")
print(f"Learned intercept: {model.intercept_:.2f}")
print(f"R² score: {model.score(X, y):.4f}")
Unsupervised Learning
In unsupervised learning, the algorithm works with unlabeled data — no correct answers are provided. The model must discover hidden patterns or structures on its own.
Types of Unsupervised Problems
Unsupervised Learning
├── Clustering (group similar items)
│ ├── K-Means
│ ├── DBSCAN
│ └── Hierarchical
│
├── Dimensionality Reduction (compress features)
│ ├── PCA
│ ├── t-SNE
│ └── UMAP
│
└── Association (find rules)
└── Market basket analysis (Apriori)
Example: Clustering
python example
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
import numpy as np
# No labels! We only have features
X, _ = make_blobs(n_samples=300, centers=4, random_state=42)
# The model discovers groups on its own
kmeans = KMeans(n_clusters=4, random_state=42)
clusters = kmeans.fit_predict(X)
print(f"Found {len(set(clusters))} clusters")
print(f"Cluster centers:\n{kmeans.cluster_centers_}")
print(f"Cluster sizes: {np.bincount(clusters)}")Reinforcement Learning
In reinforcement learning, an agent learns by interacting with an environment. It receives rewards or penalties based on its actions and learns to maximize cumulative reward over time.
Key Concepts
| Agent | ────────────────► | Environment |
|---|---|---|
| ◄──────────────── |
Simple Example: Q-Learning
Example
import numpy as np
# Simple grid world: agent learns to reach goal
# States: 0,1,2,3,4 (4 is the goal)
# Actions: 0=left, 1=right
n_states = 5
n_actions = 2
Q = np.zeros((n_states, n_actions))
# Reward: +10 for reaching state 4, -1 for each step
def get_reward(state, action):
next_state = max(0, min(4, state + (1 if action == 1 else -1)))
reward = 10 if next_state == 4 else -1
return next_state, reward
# Q-Learning
alpha = 0.1 # learning rate
gamma = 0.9 # discount factor
epsilon = 0.1 # exploration rate
for episode in range(1000):
state = 0
for step in range(20):
# Epsilon-greedy action selection
if np.random.random() < epsilon:
action = np.random.randint(n_actions)
else:
action = np.argmax(Q[state])
next_state, reward = get_reward(state, action)
# Q-value update
Q[state, action] += alpha * (reward + gamma * np.max(Q[next_state]) - Q[state, action])
state = next_state
if state == 4:
break
print("Learned Q-table (rows=states, cols=actions[left,right]):")
print(Q.round(2))
print("\nThe agent learned: always go RIGHT to reach the goal!")
Comparison Table
| Aspect | Supervised | Unsupervised | Reinforcement |
|---|---|---|---|
| Data | Labeled (X, y) | Unlabeled (X only) | Environment + rewards |
| Goal | Predict labels | Find patterns | Maximize reward |
| Feedback | Correct answer | No feedback | Delayed reward signal |
| Examples | Spam detection | Customer segmentation | Game playing |
| Algorithms | SVM, Random Forest | K-Means, PCA | Q-Learning, DQN |
| Evaluation | Accuracy, F1, MSE | Silhouette score | Cumulative reward |
Semi-Supervised Learning
A hybrid approach using a small amount of labeled data with a large amount of unlabeled data.
Example
# Conceptual semi-supervised approach
from sklearn.semi_supervised import LabelSpreading
import numpy as np
# Most labels are unknown (-1)
X = np.array([[1,1], [2,2], [3,3], [8,8], [9,9], [10,10],
[5,5], [4,4], [7,7], [6,6]])
# Only 2 labeled, rest unknown
y = np.array([0, -1, -1, 1, -1, -1, -1, -1, -1, -1])
model = LabelSpreading()
model.fit(X, y)
print(f"Predictions for all points: {model.predict(X)}")
print("The model used 2 labels to classify all 10 points!")
Self-Supervised Learning
The model creates its own labels from the data structure — popular in modern NLP and vision.
Examples:
- Language models: Predict the next word in a sentence
- Masked language models: Fill in blanked-out words (BERT)
- Contrastive learning: Learn similar vs. different images
When to Use Each Type
| ├── YES (lots) | Supervised Learning |
| ├── YES (few) | Semi-supervised or Transfer Learning |
| ├── NO | Is there a clear reward signal? |
| │ ├── YES | Reinforcement Learning |
| │ └── NO | Unsupervised Learning |
Interview Questions
- What is the fundamental difference between supervised and unsupervised learning?
Supervised learning uses labeled data (input-output pairs) to learn a mapping function. Unsupervised learning works with unlabeled data to discover hidden patterns or structures.
- Give a real-world scenario where you'd use each type of ML.
Supervised: Email spam classifier (labeled spam/not spam). Unsupervised: Customer segmentation (no predefined groups). Reinforcement: Training a robot to walk (learns through trial and error).
- Can you convert an unsupervised problem into a supervised one?
Yes. For example, after clustering customers, you can label each cluster and train a supervised classifier to assign new customers to segments.
- What is the difference between classification and regression?
Classification predicts discrete categories (cat/dog), while regression predicts continuous values (price = $250,000).
- Why is reinforcement learning harder than supervised learning?
RL has delayed rewards (don't know immediately if action was good), credit assignment problem (which past action led to reward), and exploration-exploitation tradeoff.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Types of Machine Learning.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Machine Learning topic.
Search Terms
machine-learning, machine learning, machine, learning, fundamentals, types, types of machine learning
Related Machine Learning Topics
Continue learning this concept
Machine Learning FundamentalsBias vs Variance TradeoffMaster the bias-variance tradeoff in machine learning with intuitive explanations, mathematical formulations, visual examples, and practical strategies to balance model complexity.Machine Learning FundamentalsModel Evaluation OverviewComplete overview of model evaluation strategies in machine learning including metrics for classification and regression, validation techniques, and comparison methods.Machine Learning FundamentalsOverfitting and UnderfittingLearn to identify and prevent overfitting and underfitting in machine learning models with practical techniques, code examples, and regularization strategies.Machine Learning FundamentalsReinforcement Learning Fundamentals — Machine LearningIntroduction to reinforcement learning concepts including agents, environments, rewards, policies, and value functions with Python examples.Machine Learning FundamentalsSupervised LearningDeep dive into supervised learning covering classification, regression, common algorithms, training process, and practical Python implementations with sklearn.Machine Learning FundamentalsTraining vs Testing DataUnderstanding the importance of splitting data into training, validation, and test sets with proper techniques, ratios, and common mistakes to avoid.