Merge pull request #136 from codeharborhub/dev-1

Getting Started with ML Docs

Author: ajay-dhangar

docs/ai-ml/machine-learning/index.mdx

@@ -0,0 +1,92 @@
+---
+title: "What is Machine Learning (ML)?"
+sidebar_label: "What is ML?"
+description: "Define Machine Learning, its key characteristics, and how it differs from traditional programming."
+tags:
+  [
+    machine-learning,
+    ml,
+    definition,
+    ai,
+    traditional-programming,
+    data-driven,
+    algorithms,
+  ]
+---
+
+Machine Learning is a subset of Artificial Intelligence (AI) that focuses on building systems capable of learning patterns and making decisions or predictions directly from data, rather than following static, explicitly programmed instructions.
+
+## The Formal Definition
+
+A widely accepted, formal definition of Machine Learning was provided by computer scientist **Tom M. Mitchell** in 1997:
+
+> A computer program is said to learn from **Experience ($E$)** with respect to some **Task ($T$)** and some **Performance measure ($P$)**, if its performance on $T$, as measured by $P$, improves with experience $E$.
+
+Let's break down this concept with a simple example: **Spam Filtering**.
+
+| Component | Description | Spam Filtering Example |
+| :--- | :--- | :--- |
+| **Task ($T$)** | The problem the ML system is trying to solve. | Classifying an email as "Spam" or "Not Spam (Ham)". |
+| **Experience ($E$)** | The data the ML system uses to train itself. | A large dataset of historical emails labeled as either spam or ham. |
+| **Performance ($P$)** | A metric used to evaluate the system's success. | **Accuracy:** The percentage of emails correctly classified. |
+
+:::tip
+The core idea is that the program's ability to classify new, unseen emails gets better the more labeled examples it processes. The program *learns* the rules itself.
+:::
+
+## ML vs. Traditional Programming
+
+This is the most crucial concept when starting out. Machine Learning fundamentally shifts the paradigm of software development.
+
+
+
+<Tabs>
+  <TabItem value="traditional" label="Traditional Programming" default>
+
+  In traditional programming, you (the programmer) write explicit **Rules** (algorithms, logic, conditions) that process **Data** to produce an **Answer**.
+
+  ```mermaid
+  graph LR
+      A[Data] --> B(Rules/Program);
+      B --> C[Answer];
+  ```
+
+**Example (Temperature Conversion):**
+You explicitly write the formula: `Fahrenheit = (Celsius * 9/5) + 32`. The computer executes this static rule.
+
+</TabItem>
+<TabItem value="ml" label="Machine Learning">
+
+In Machine Learning, you feed the system the **Data** and the desired **Answers** (Labels), and the system autonomously generates the **Rules** (the Model/Algorithm) that maps the input to the output.
+
+```mermaid
+graph LR
+    A[Data] --> B(ML Algorithm);
+    C[Answers/Labels] --> B;
+    B --> D[Rules/Model];
+```
+
+**Example (Predicting House Price):**
+You feed it past house data (size, location) and the final sale price. The ML algorithm creates a complex mathematical model (the "Rule") that predicts the price of a *new* house based on its features.
+
+</TabItem>
+</Tabs>
+
+## Key Characteristics of Machine Learning
+
+  * **Data-Driven:** ML models require vast amounts of high-quality data to learn effectively.
+  * **Automatic Pattern Discovery:** The system discovers hidden patterns, correlations, and rules in the data without human intervention.
+  * **Generalization:** A good ML model can accurately predict or classify data it has never seen before (its performance improves with experience $E$).
+  * **Iterative Process:** Developing an ML model is a cyclical process of data collection, training, evaluation, and refinement.
+
+## Where is ML Used?
+
+Machine Learning is the engine behind many everyday technologies:
+
+| Domain | Application | ML Task |
+| :--- | :--- | :--- |
+| **E-commerce** | Recommendation Systems (e.g., "People who bought X also bought Y") | Classification / Ranking |
+| **Healthcare** | Tumor detection in X-rays or MRIs | Image Segmentation / Classification |
+| **Finance** | Fraud detection in credit card transactions | Anomaly Detection / Classification |
+| **Speech** | Voice assistants (Siri, Alexa) | Natural Language Processing (NLP) |
+| **Transportation**| Self-driving cars | Computer Vision / Reinforcement Learning |

docs/machine-learning/fundamentals/data-splitting.mdx

@@ -0,0 +1,154 @@
+---
+title: Introduction to Machine Learning
+sidebar_label: Introduction
+description: "A comprehensive introduction to the Machine Learning Tutorial structure, purpose, and key learning outcomes for CodeHarborHub learners."
+tags:
+  [
+    machine-learning,
+    ml,
+    introduction,
+    ai,
+    data-science,
+    tutorial,
+    codeharborhub,
+    roadmap,
+    ml-engineer,
+  ]
+---
+
+Welcome to the **CodeHarborHub Machine Learning Tutorial**! This is your official gateway into the transformative world of Artificial Intelligence, data analysis, and predictive modeling.
+
+:::info
+Machine Learning is not just about complex algorithms; it is about building systems that learn from data to make decisions or predictions *without* being explicitly programmed for every outcome.
+:::
+
+## Why Machine Learning Now?
+
+The demand for ML skills is soaring across every industry—from finance and healthcare to entertainment and autonomous technology. By learning ML, you are gaining one of the most valuable and future-proof skill sets in the 21st century.
+
+### What You Will Learn
+
+This tutorial provides a complete, structured roadmap to transform you into a proficient ML practitioner. By the end, you will master:
+
+1.  **Foundations:** The mathematical and statistical bedrock of ML.
+2.  **Core Algorithms:** Implementing models like Linear Regression, Support Vector Machines, and K-Means.
+3.  **Deep Learning:** Building advanced Neural Networks (CNNs, RNNs, Transformers).
+4.  **Practical Workflow:** Handling real-world data, evaluating models, and deploying solutions (MLOps).
+5.  **Coding:** Writing efficient, production-ready Python code using libraries like NumPy, Pandas, and Scikit-learn.
+
+## Tutorial Structure Overview
+
+This curriculum is designed as a deep, sequential progression. We move from the absolute basics (Math and Programming) to advanced deployment strategies.
+
+<Tabs>
+  <TabItem value="foundation" label="Foundations" default>
+    ### The Bedrock of ML
+    This initial stage ensures you have the solid academic footing required for understanding the algorithms.
+
+    * **Mathematics:** Linear Algebra (Vectors, Matrices, Tensors) and Calculus (Derivatives, Gradients). For instance, the **Gradient Descent** optimization algorithm relies heavily on the partial derivative concept:
+        $$
+        \theta_{j} := \theta_{j} - \alpha \frac{\partial}{\partial \theta_{j}} J(\theta)
+        $$
+    * **Statistics & Probability:** Concepts like probability distributions, conditional probability, and data visualization.
+    * **Programming Fundamentals:** Mastering Python, NumPy, and Pandas.
+  </TabItem>
+  <TabItem value="core_ml" label="ML & Deep Learning Core">
+    ### Algorithms and Architectures
+    Here, you start building models and diving into neural networks.
+
+    * **ML Core:** Supervised, Unsupervised, and Reinforcement Learning paradigms.
+    * **Data Engineering:** Preprocessing data, handling missing values, and the critical step of **Feature Engineering**.
+    * **Deep Learning:** Understanding Perceptrons, Backpropagation, and specialized networks (CNNs for images, RNNs/Transformers for text).
+  </TabItem>
+  <TabItem value="advanced_ml" label="Advanced & Production">
+    ### Real-World Application
+    The final stage focuses on specialized fields and moving models into production.
+
+    * **NLP:** Tokenization, Embeddings, and Attention Mechanisms for text processing.
+    * **Explainable AI (XAI):** Tools like LIME and SHAP to interpret complex model decisions.
+    * **MLOps:** The engineering discipline of deploying, monitoring, and maintaining ML models in a reliable and reproducible way (CI/CD, Model Versioning).
+  </TabItem>
+</Tabs>
+
+---
+
+## The Machine Learning Engineer Role
+
+Understanding the role helps you align your learning goals.
+
+| Aspect | ML Engineer | AI Engineer |
+| :--- | :--- | :--- |
+| **Primary Focus** | Production-level implementation, deployment, MLOps, scalability, data pipelines. | Research, development of novel AI models (especially Deep Learning/Generative AI), fine-tuning large models. |
+| **Core Skills** | Python, Cloud (AWS/Azure/GCP), Docker, CI/CD, Scikit-learn, TensorFlow/PyTorch, **Data Engineering**. | Strong math/research background, Deep Learning frameworks, model optimization, **State-of-the-Art** techniques. |
+| **Goal** | Make models reliably work in production at scale. | Create new intelligence capabilities or highly specialized models. |
+
+:::success
+This tutorial provides a strong foundation for **both** roles, with a dedicated focus on the practical implementation skills needed for the **ML Engineer** track.
+:::
+
+## Types of Machine Learning
+
+```mermaid
+mindmap
+  root((Machine Learning))
+    Supervised Learning
+      Regression
+      Classification
+    Unsupervised Learning
+      Clustering
+      Dimensionality Reduction
+    Reinforcement Learning
+      Reward Systems
+      Agents & Environment
+```
+
+<Tabs>
+  <TabItem value="Supervised Learning" label="Supervised Learning" default>
+    Learn from labeled data (input → correct output).  
+    Examples:  
+    * House price prediction  
+    * Spam detection  
+    * Disease prediction  .
+  </TabItem>
+
+  <TabItem value="Unsupervised Learning" label="Unsupervised Learning">
+    Find hidden patterns in data without labels.  
+    Examples:  
+    * Customer segmentation  
+    * Anomaly detection  
+    * Data clustering 
+  </TabItem>
+
+  <TabItem value="Reinforcement Learning" label="Reinforcement Learning">      
+    Learn through rewards and penalties.  
+    Examples:  
+    * Robotics  
+    * Game AI  
+    * Autonomous vehicles 
+  </TabItem>
+</Tabs>  
+
+## Tools You Will Use
+
+<Tabs>
+  <TabItem value="python" label="Python" default>
+    Python is the primary language for ML due to its simplicity and rich ecosystem.
+  </TabItem>
+
+  <TabItem value="libraries" label="Libraries">
+    - NumPy  
+    - Pandas  
+    - Matplotlib / Seaborn  
+    - Scikit-Learn  
+    - TensorFlow  
+    - PyTorch
+  </TabItem>
+
+  <TabItem value="notebooks" label="Notebooks">
+    Jupyter Notebooks help you write code, visualize results, and document your workflow.
+  </TabItem>
+</Tabs>
+
+## Ready to Begin?
+
+Start by learning the fundamental definition of Machine Learning and the core concepts that define this field.

docs/machine-learning/fundamentals/ml-workflow.mdx

@@ -0,0 +1,70 @@
+---
+title: "ML Engineer vs. AI Engineer"
+sidebar_label: "MLE vs. AIE"
+description: "A clear comparison of the Machine Learning Engineer, AI Engineer, and Data Scientist roles, focusing on responsibilities, tools, and project scope."
+tags:
+  [
+    ml-engineer,
+    ai-engineer,
+    data-scientist,
+    comparison,
+    roles,
+    career-path,
+    ai,
+    ml,
+  ]
+---
+
+The titles in the Artificial Intelligence (AI) domain often overlap, leading to confusion. While job descriptions vary widely by company, we can define the typical focus area for the three core roles: **Data Scientist (DS)**, **Machine Learning Engineer (MLE)**, and **AI Engineer (AIE)**.
+
+
+## 1. Data Scientist (DS): The Statistician & Modeler
+
+The DS role is primarily focused on **discovery and experimentation**.
+
+* **Goal:** To answer business questions using data, uncover patterns, and build predictive models in an experimental environment (e.g., Jupyter Notebooks).
+* **Focus:** **Why** and **What** is the data telling us? They are the domain experts in statistical modeling and analysis.
+* **Key Responsibilities:**
+    * Statistical analysis and hypothesis testing.
+    * Developing novel modeling approaches.
+    * Data visualization and storytelling with data.
+    * Communicating insights to stakeholders.
+* **Tools:** Python, R, Pandas, Scikit-learn, statistical packages.
+
+## 2. Machine Learning Engineer (MLE): The Production Expert
+
+The MLE role is the bridge between the experimental DS model and the production system.
+
+* **Goal:** To turn high-performing models into reliable, scalable services used by millions of users.
+* **Focus:** **How** do we integrate this model into the product pipeline? They are system-level engineers specializing in ML.
+* **Key Responsibilities:**
+    * Designing and implementing robust data pipelines.
+    * Deploying models using MLOps tools (Docker, Kubernetes).
+    * Monitoring model performance (drift detection, latency).
+    * Optimizing model code for speed and efficiency.
+* **Tools:** Python, Cloud Platforms (AWS, Azure, GCP), Docker, Kubernetes, CI/CD, MLflow/DVC.
+
+## 3. AI Engineer (AIE): The Advanced Modeler & Specialist
+
+The AIE role is often used interchangeably with MLE, but when distinct, it typically focuses on **cutting-edge AI domains**.
+
+* **Goal:** To work with and advance complex, high-impact AI systems, particularly in Deep Learning, NLP, and Computer Vision.
+* **Focus:** **What** state-of-the-art model should we use? They specialize in specific deep learning architectures.
+* **Key Responsibilities:**
+    * Implementing and fine-tuning large, complex models (e.g., Transformers, LLMs, Generative Models).
+    * Optimizing GPU/TPU utilization for training large neural networks.
+    * Researching and adopting new AI architectures.
+* **Tools:** PyTorch, TensorFlow, Hugging Face, distributed training frameworks.
+
+## Comparison Table
+
+| Feature | Data Scientist (DS) | ML Engineer (MLE) | AI Engineer (AIE) |
+| :--- | :--- | :--- | :--- |
+| **Primary Output** | Insights, Reports, Experimental Models | Production-Ready ML Services/APIs | Specialized Deep Learning Systems |
+| **Core Skill** | Statistics, Modeling, Domain Knowledge | Software Engineering, MLOps, System Design | Deep Learning, Advanced AI Architectures |
+| **Project Stage** | Exploration & Proof-of-Concept | Deployment & Maintenance | Research & Implementation of Advanced Models |
+| **Typical Stack** | Python/R, Jupyter, Scikit-learn | Python, Docker, Kubernetes, Cloud SDKs | Python, PyTorch/TensorFlow, GPUs/TPUs |
+
+:::important
+**CodeHarborHub's Focus:** This tutorial is geared towards the **Machine Learning Engineer** skillset. We will give you the *modeling foundation* of a Data Scientist and the *engineering discipline* of a Software Engineer, emphasizing the MLOps skills needed for real-world production.
+:::