From fc2039330b8b72d16f10d19644e0c65a31679e35 Mon Sep 17 00:00:00 2001 From: Ajay Dhangar Date: Sun, 21 Dec 2025 19:09:24 +0530 Subject: [PATCH] Doneprogramming fundamentals --- .../basic-syntax/conditionals.mdx | 129 ++++++++++++++++++ .../basic-syntax/data-structures.mdx | 100 ++++++++++++++ .../basic-syntax/exceptions.mdx | 115 ++++++++++++++++ .../basic-syntax/functions.mdx | 121 ++++++++++++++++ .../basic-syntax/loops.mdx | 124 +++++++++++++++++ .../basic-syntax/variables-and-data-types.mdx | 100 ++++++++++++++ .../essential-libraries/matplotlib.mdx | 113 +++++++++++++++ .../essential-libraries/numpy.mdx | 109 +++++++++++++++ .../essential-libraries/pandas.mdx | 121 ++++++++++++++++ .../essential-libraries/seaborn.mdx | 104 ++++++++++++++ .../object-oriented-programming.mdx | 89 ++++++++++++ .../programming-fundamentals/python.mdx | 121 ++++++++++++++++ .../img/tutorials/ml/bubble-visualization.jpg | Bin 0 -> 102318 bytes 13 files changed, 1346 insertions(+) create mode 100644 static/img/tutorials/ml/bubble-visualization.jpg diff --git a/docs/machine-learning/programming-fundamentals/basic-syntax/conditionals.mdx b/docs/machine-learning/programming-fundamentals/basic-syntax/conditionals.mdx index e69de29..28206a5 100644 --- a/docs/machine-learning/programming-fundamentals/basic-syntax/conditionals.mdx +++ b/docs/machine-learning/programming-fundamentals/basic-syntax/conditionals.mdx @@ -0,0 +1,129 @@ +--- +title: Conditionals and Branching +sidebar_label: Conditionals +description: "Mastering If, Else, and Elif statements to control program flow and handle logic in Machine Learning pipelines." +tags: [python, programming, logic, conditionals, branching, mathematics-for-ml] +--- + +Machine Learning is often about making decisions. **Conditionals** allow our code to react differently depending on the input. Whether it's checking if a dataset is empty or deciding which model to load, `if-else` logic is the foundation of programmatic decision-making. + +## 1. The `if`, `elif`, and `else` Structure + +Python uses indentation to define the scope of conditional blocks. + +```python +accuracy = 0.85 + +if accuracy > 0.90: + print("Excellent model performance!") +elif accuracy > 0.70: + print("Good performance, but could be improved.") +else: + print("Model needs retraining.") + +``` + +```mermaid +flowchart TD + Start([Check Accuracy]) --> C1{Acc > 0.90?} + C1 -- Yes --> R1[Print: Excellent] + C1 -- No --> C2{Acc > 0.70?} + C2 -- Yes --> R2[Print: Good] + C2 -- No --> R3[Print: Retrain] + +``` + +## 2. Comparison and Logical Operators + +Conditionals rely on boolean expressions that evaluate to either `True` or `False`. + +### A. Comparison Operators + +* `==` (Equal to) +* `!=` (Not equal to) +* `>` / `<` (Greater/Less than) +* `>=` / `<=` (Greater/Less than or equal to) + +### B. Logical Operators (Chaining) + +* `and`: Both conditions must be True. +* `or`: At least one condition must be True. +* `not`: Reverses the boolean value. + +```python +# Check if learning rate is within a safe range +lr = 0.001 +if lr > 0 and lr < 0.1: + print("Learning rate is valid.") + +``` + +## 3. The "ReLU" Example: Math meets Logic + +One of the most famous conditional operations in Deep Learning is the **Rectified Linear Unit (ReLU)** activation function. + +$$ +\text{ReLU}(x) = \max(0, x) +$$ + +In Python code, this is a simple conditional: + +```python +def relu(x): + if x > 0: + return x + else: + return 0 + +``` + +## 4. Truthiness and Identity + +In ML data cleaning, we often check if a variable actually contains data. + +* **Falsy values:** `None`, `0`, `0.0`, `""` (empty string), `[]` (empty list), `{}` (empty dict). +* **Truthy values:** Everything else. + +```python +features = get_features() + +if not features: + print("Warning: No features found in dataset!") + +``` + +### `is` vs `==` + +* `==` checks for **Value equality** (Are the numbers the same?). +* `is` checks for **Identity** (Are they the exact same object in memory?). + +## 5. Inline Conditionals (Ternary Operator) + +For simple logic, Python allows a one-liner known as a ternary operator. + +```python +# status = "Spam" if probability > 0.5 else "Not Spam" +prediction = "Positive" if y_hat > 0.5 else "Negative" + +``` + +## 6. Match-Case (Python 3.10+) + +For complex branching based on specific patterns (like different file extensions or model types), the `match` statement provides a cleaner syntax than multiple `elif` blocks. + +```python +optimizer_type = "adam" + +match optimizer_type: + case "sgd": + print("Using Stochastic Gradient Descent") + case "adam": + print("Using Adam Optimizer") + case _: + print("Using Default Optimizer") + +``` + +--- + +Decision-making is key, but to keep our code clean, we shouldn't repeat our logic. We need to wrap our conditionals and loops into reusable components. \ No newline at end of file diff --git a/docs/machine-learning/programming-fundamentals/basic-syntax/data-structures.mdx b/docs/machine-learning/programming-fundamentals/basic-syntax/data-structures.mdx index e69de29..8355139 100644 --- a/docs/machine-learning/programming-fundamentals/basic-syntax/data-structures.mdx +++ b/docs/machine-learning/programming-fundamentals/basic-syntax/data-structures.mdx @@ -0,0 +1,100 @@ +--- +title: Data Structures +sidebar_label: Data Structures +description: "Mastering Python's built-in collections: Lists, Tuples, Dictionaries, and Sets, and their specific roles in data science pipelines." +tags: [python, data-structures, lists, dictionaries, tuples, sets, mathematics-for-ml] +--- + +While basic types hold single values, **Data Structures** allow us to group, organize, and manipulate large amounts of information. In ML, choosing the wrong structure can lead to code that runs $100\times$ slower than it should. + +## 1. Lists: The Versatile Workhorse + +A **List** is an ordered, mutable collection of items. Think of it as a flexible array that can grow or shrink. + +* **Syntax:** `my_list = [0.1, 0.2, 0.3]` +* **ML Use Case:** Storing the history of "Loss" values during training so you can plot them later. + +```python +losses = [] +for epoch in range(10): + current_loss = train_step() + losses.append(current_loss) # Dynamic growth + +``` + +## 2. Tuples: The Immutable Safeguard + +A **Tuple** is like a list, but it **cannot be changed** after creation (immutable). + +* **Syntax:** `shape = (224, 224, 3)` +* **ML Use Case:** Defining image dimensions or model architectures. Since these shouldn't change accidentally during execution, a tuple is safer than a list. + +```mermaid +graph LR + L[List: Mutable] --> L_Edit["Can change: my_list[0] = 5"] + T[Tuple: Immutable] --> T_Edit["Error: 'tuple' object does not support assignment"] + style T fill:#fffde7,stroke:#fbc02d,color:#333 + +``` + +## 3. Dictionaries: Key-Value Mapping + +A **Dictionary** stores data in pairs: a unique **Key** and its associated **Value**. It uses a "Hash Table" internally, making lookups incredibly fast ( complexity). + +* **Syntax:** `params = {"learning_rate": 0.001, "batch_size": 32}` +* **ML Use Case:** Managing hyperparameters or mapping integer IDs back to human-readable text labels. + +```mermaid +graph TD + Key["Key: 'Cat'"] --> Hash["Hash Function"] + Hash --> Index["Memory Index: 0x42"] + Index --> Val["Value: [0.98, 0.02, ...]"] + style Hash fill:#e1f5fe,stroke:#01579b,color:#333 + +``` + +## 4. Sets: Uniqueness and Logic + +A **Set** is an unordered collection of **unique** items. + +* **Syntax:** `classes = {"dog", "cat", "bird"}` +* **ML Use Case:** Finding the unique labels in a messy dataset or performing mathematical operations like Union and Intersection on feature sets. + +## 5. Performance Comparison + +Choosing the right structure is about balancing **Speed** and **Memory**. + +| Feature | List | Tuple | Dictionary | Set | +| --- | --- | --- | --- | --- | +| **Ordering** | Ordered | Ordered | Ordered (Python 3.7+) | Unordered | +| **Mutable** | **Yes** | No | **Yes** | **Yes** | +| **Duplicates** | Allowed | Allowed | Keys must be unique | Must be unique | +| **Search Speed** | (Slow) | (Slow) | (Very Fast) | (Very Fast) | + +```mermaid +xychart-beta + title "Search Speed (Lower is Better)" + x-axis ["List", "Tuple", "Set", "Dict"] + y-axis "Time Complexity" 0 --> 120 + bar [100, 100, 5, 5] + +``` + +## 6. Slicing and Indexing + +In ML, we often need to "slice" our data (e.g., taking the first 80% for training and the last 20% for testing). + +$$ +\text{Syntax: } \text{data}[\text{start} : \text{stop} : \text{step}] +$$ + +```python +data = [10, 20, 30, 40, 50, 60] +train = data[:4] # [10, 20, 30, 40] +test = data[4:] # [50, 60] + +``` + +--- + +Now that we can organize data, we need to control the flow of our program—making decisions based on that data and repeating tasks efficiently. \ No newline at end of file diff --git a/docs/machine-learning/programming-fundamentals/basic-syntax/exceptions.mdx b/docs/machine-learning/programming-fundamentals/basic-syntax/exceptions.mdx index e69de29..335fddc 100644 --- a/docs/machine-learning/programming-fundamentals/basic-syntax/exceptions.mdx +++ b/docs/machine-learning/programming-fundamentals/basic-syntax/exceptions.mdx @@ -0,0 +1,115 @@ +--- +title: Exception Handling +sidebar_label: Exceptions +description: "Learning to handle errors gracefully in Python to build robust and fault-tolerant Machine Learning pipelines." +tags: [python, programming, exceptions, error-handling, debugging, mathematics-for-ml] +--- + +In Machine Learning, things often go wrong: a dataset file is missing, a GPU runs out of memory, or a feature contains a `NaN` (Not a Number) that crashes a calculation. **Exception Handling** allows your program to "fail gracefully" rather than crashing completely. + +## 1. The Try-Except Block + +The basic tool for handling errors is the `try...except` block. You "try" a piece of code, and if it raises an error, the "except" block catches it. + +```python +try: + # Attempting to load a large dataset + data = load_dataset("huge_data.csv") +except FileNotFoundError: + print("Error: The dataset file was not found. Please check the path.") + +``` + +```mermaid +flowchart TD + Start([Start Try Block]) --> Op[Execute Code] + Op --> Success{Error Occurred?} + Success -- No --> End([Continue Program]) + Success -- Yes --> Catch[Match Exception Type] + Catch --> Handle[Execute Except Block] + Handle --> End + style Catch fill:#ffebee,stroke:#c62828,color:#333 + +``` + +## 2. Handling Multiple Exceptions + +Different operations can fail in different ways. You can catch specific errors to provide tailored solutions. + +* **`ValueError`**: Raised when a function receives an argument of the right type but inappropriate value (e.g., trying to take the square root of a negative number). +* **`TypeError`**: Raised when an operation is applied to an object of inappropriate type. +* **`ZeroDivisionError`**: Common in manual normalization logic. + +```python +try: + result = total_loss / num_samples +except ZeroDivisionError: + result = 0 + print("Warning: num_samples was zero. Setting loss to 0.") +except TypeError: + print("Error: Check if total_loss and num_samples are numbers.") + +``` + +## 3. The Full Lifecycle: `else` and `finally` + +To build truly robust pipelines (like those that open and close database connections), we use the extended syntax: + +1. **`try`**: The code that might fail. +2. **`except`**: Code that runs only if an error occurs. +3. **`else`**: Code that runs only if **no** error occurs. +4. **`finally`**: Code that runs **no matter what** (perfect for closing files or releasing GPU memory). + +```python +try: + file = open("model_weights.bin", "rb") + weights = file.read() +except IOError: + print("Could not read file.") +else: + print("Weights loaded successfully.") +finally: + file.close() + print("File resource released.") + +``` + +## 4. Raising Exceptions + +Sometimes, you *want* to stop the program if a specific condition isn't met. For example, if a user provides a negative learning rate. + +```python +def set_learning_rate(lr): + if lr <= 0: + raise ValueError(f"Learning rate must be positive. Received: {lr}") + return lr + +``` + +## 5. Exceptions in ML Data Pipelines + +In production ML, we use exceptions to ensure data quality. + +```mermaid +graph LR + Input[Data Source] --> Check{Check Data} + Check -->|Valid| Train[Start Training] + Check -->|Corrupted| Exc[Raise DataValidationError] + Exc --> Log[Log Error to Dashboard] + Exc --> Fallback[Use Last Known Good Data] + style Exc fill:#ffc107,stroke:#ff8f00,color:#333 + +``` + +## 6. Summary of Common ML Exceptions + +| Exception | When it happens in ML | +| --- | --- | +| **`IndexError`** | Trying to access a non-existent column or row index in an array. | +| **`KeyError`** | Looking for a hyperparameter in a config dictionary that doesn't exist. | +| **`AttributeError`** | Calling a method (like `.predict()`) on a model that hasn't been trained yet. | +| **`MemoryError`** | Loading a dataset that is larger than the available RAM. | + +--- + +Handling errors ensures your code doesn't crash, but how do we organize our code so it's easy to read and maintain? Let's explore the world of Classes and Objects. \ No newline at end of file diff --git a/docs/machine-learning/programming-fundamentals/basic-syntax/functions.mdx b/docs/machine-learning/programming-fundamentals/basic-syntax/functions.mdx index e69de29..5174ffe 100644 --- a/docs/machine-learning/programming-fundamentals/basic-syntax/functions.mdx +++ b/docs/machine-learning/programming-fundamentals/basic-syntax/functions.mdx @@ -0,0 +1,121 @@ +--- +title: Functions and Scope +sidebar_label: Functions +description: "Mastering reusable code blocks in Python: defining functions, handling arguments, and understanding global vs. local scope in ML workflows." +tags: [python, programming, functions, scope, modularity, mathematics-for-ml] +--- + +In Machine Learning, we often repeat complex logic—calculating the distance between points, normalizing features, or computing gradients. **Functions** allow us to package this logic into reusable blocks, reducing errors and making our code "DRY" (Don't Repeat Yourself). + +## 1. Anatomy of a Function + +A function takes an **input** (parameters), performs an **action**, and returns an **output**. + +```python +def calculate_mse(y_true, y_pred): + """Calculates Mean Squared Error.""" + error = (y_true - y_pred) ** 2 + return error.mean() + +``` + +```mermaid +graph LR + In["Input: $$y_{true}, y_{pred}$$"] --> Logic["Function Logic: $$(y - \hat{y})^2$$"] + Logic --> Out["Output: Mean Error"] + style Logic fill:#e1f5fe,stroke:#01579b,color:#333 +``` + +## 2. Arguments and Parameters + +Python offers flexible ways to pass data into functions, which is essential for managing dozens of hyperparameters. + +### A. Positional vs. Keyword Arguments + +* **Positional:** Order matters. +* **Keyword:** Explicitly naming parameters (safer and more readable). + +```python +def train_model(learning_rate, epochs): + print(f"LR: {learning_rate}, Epochs: {epochs}") + +# Keyword arguments are preferred in ML for clarity +train_model(epochs=100, learning_rate=0.001) + +``` + +### B. Default Values + +Useful for hyperparameters that have a standard "sane" default. + +```python +def initialize_weights(size, distribution="normal"): + # If distribution isn't provided, it defaults to "normal" + pass + +``` + +## 3. Lambda Functions (Anonymous Functions) + +For simple, one-line operations, Python uses **Lambda** functions. These are frequently used in data cleaning with `pandas`. + +$$ +\text{Syntax: } \text{lambda } \text{arguments} : \text{expression} +$$ + +```python +# Convert Celsius to Fahrenheit for a feature +c_to_f = lambda c: (c * 9/5) + 32 +print(c_to_f(0)) # 32.0 + +``` + +## 4. Understanding Scope + +**Scope** determines where a variable can be seen or accessed. + +```mermaid +graph TD + Global["Global Scope: Variables defined outside any function"] --> Local["Local Scope: Variables defined inside a function"] + Local -->|Access| Global + Global -.->|Cannot Access| Local + +``` + +* **Global Scope:** Variables available throughout the entire script (e.g., a dataset loaded at the top). +* **Local Scope:** Variables created inside a function (e.g., a temporary calculation). They "die" once the function finishes. + +Bubble visualization + +## 5. Args and Kwargs (`*args`, `**kwargs`) + +In advanced ML libraries (like Scikit-Learn), you'll see these used to pass a variable number of arguments. + +* `*args`: Passes a list of positional arguments. +* `**kwargs`: Passes a dictionary of keyword arguments. + +```python +def build_layer(**hyperparams): + for key, value in hyperparams.items(): + print(f"{key}: {value}") + +build_layer(units=64, activation="relu", dropout=0.2) + +``` + +## 6. Functions as First-Class Citizens + +In Python, you can pass a function as an argument to *another* function. This is how we pass different **activation functions** or **optimizers** into a training function. + +```python +def apply_activation(value, func): + return func(value) + +# Passing the 'relu' function as data +output = apply_activation(10, relu) + +``` + +--- + +Functions help us stay organized, but sometimes code fails due to unexpected data or math errors. We need a way to catch those errors without crashing our entire training pipeline. \ No newline at end of file diff --git a/docs/machine-learning/programming-fundamentals/basic-syntax/loops.mdx b/docs/machine-learning/programming-fundamentals/basic-syntax/loops.mdx index e69de29..4a06e81 100644 --- a/docs/machine-learning/programming-fundamentals/basic-syntax/loops.mdx +++ b/docs/machine-learning/programming-fundamentals/basic-syntax/loops.mdx @@ -0,0 +1,124 @@ +--- +title: Loops and Iteration +sidebar_label: Loops +description: "Mastering For loops, While loops, and the logic of iteration in Machine Learning pipelines." +tags: [python, programming, loops, iteration, training-loop, mathematics-for-ml] +--- + +In Machine Learning, we rarely do something once. We repeat operations thousands of times: passing data through a network, updating weights, or pre-processing thousands of images. This repetition is handled by **Loops**. + +## 1. The `for` Loop: Iterating over Sequences + +The `for` loop is the most common loop in Python. It iterates over any "iterable" (like a list, tuple, or dictionary). + +* **ML Use Case:** Iterating through a list of filenames to load images. + +```python +models = ["Linear", "SVM", "RandomForest"] + +for model in models: + print(f"Training {model}...") + +``` + +### Using `range()` + +When you need to repeat an action a specific number of times (like **Epochs**), use the `range()` function. + +```python +# Training for 5 epochs +for epoch in range(5): + print(f"Epoch {epoch + 1}/5") + +``` + +## 2. The `while` Loop: Conditional Iteration + +A `while` loop continues as long as a certain condition is `True`. + +* **ML Use Case:** **Early Stopping**. You might want to keep training a model until the error (loss) drops below a specific threshold. + +```python +loss = 1.0 +threshold = 0.01 + +while loss > threshold: + loss -= 0.005 # Simulate model learning + print(f"Current Loss: {loss:.4f}") + +``` + +```mermaid +flowchart TD + Start([Start Loop]) --> Cond{Loss > Threshold?} + Cond -- Yes --> Train[Train Model & Update Loss] + Train --> Cond + Cond -- No --> Stop([Stop: Convergence reached]) + style Cond fill:#fff3e0,stroke:#ef6c00,color:#333 + +``` + +## 3. Loop Control: `break` and `continue` + +Sometimes you need to alter the flow inside a loop: + +* **`break`**: Exits the loop entirely. (e.g., if the model starts over-fitting). +* **`continue`**: Skips the rest of the current block and moves to the next iteration. (e.g., skipping a corrupted image file). + +```python +for image in dataset: + if image.is_corrupted: + continue # Move to next image + process(image) + +``` + +## 4. The "ML Training Loop" Pattern + +In deep learning (PyTorch/TensorFlow), you will almost always see this nested structure: + +```mermaid +block-beta + columns 1 + block:outer["Outer Loop: Epochs (Going through the whole dataset)"] + block:inner["Inner Loop: Batches (Processing chunks of data)"] + Step["Forward Pass -> Calculate Loss -> Update Weights"] + end + end + style outer fill:#e1f5fe,stroke:#01579b,color:#333 + style inner fill:#f3e5f5,stroke:#7b1fa2,color:#333 + +``` + +## 5. Efficiency Tip: List Comprehensions + +Python offers a concise way to create lists using a single line of code. It is often faster and more readable than a standard `for` loop for simple transformations. + +**Standard Way:** + +```python +squared_errors = [] +for e in errors: + squared_errors.append(e**2) + +``` + +**Pythonic Way (List Comprehension):** + +```python +squared_errors = [e**2 for e in errors] + +``` + +## 6. The "Vectorization" Warning + +While loops are fundamental, **Standard Python loops are slow for mathematical operations.** If you are multiplying two matrices of size , a nested Python `for` loop will take seconds, while a **Vectorized** operation in NumPy will take milliseconds. + +| Operation | Python `for` loop | NumPy Vectorized | +| --- | --- | --- | +| **Summing 1M numbers** | ~50ms | ~1ms | +| **Matrix Multiplication** | $O(n^3)$ | Optimized BLAS/LAPACK | + +--- + +Loops help us repeat tasks, but how do we bundle those tasks into reusable blocks? This is where functions come in. \ No newline at end of file diff --git a/docs/machine-learning/programming-fundamentals/basic-syntax/variables-and-data-types.mdx b/docs/machine-learning/programming-fundamentals/basic-syntax/variables-and-data-types.mdx index e69de29..9899bbd 100644 --- a/docs/machine-learning/programming-fundamentals/basic-syntax/variables-and-data-types.mdx +++ b/docs/machine-learning/programming-fundamentals/basic-syntax/variables-and-data-types.mdx @@ -0,0 +1,100 @@ +--- +title: Variables and Data Types +sidebar_label: Variables & Types +description: "Understanding Python's dynamic typing system, memory management, and the core data types essential for data science." +tags: [python, programming, variables, data-types, mutability, mathematics-for-ml] +--- + +In Python, variables are not "buckets" that hold values; they are **labels** (references) that point to objects in memory. In Machine Learning, understanding how these labels work is the difference between writing clean code and hunting for memory-leak bugs. + +## 1. Dynamic Typing + +Python is **dynamically typed**. You don't need to declare that a variable is an integer or a string; Python figures it out at runtime. + +```python +x = 0.01 # Initially a float (learning rate) +x = "Adam" # Now a string (optimizer name) + +``` + +```mermaid +graph LR + Label[Variable Label: 'x'] -->|Points to| Obj1["Float Object: $$0.01$$"] + Label -.->|Reassigned to| Obj2["String Object: 'Adam'"] + style Obj1 fill:#f5f5f5,stroke:#999,color:#333 + style Obj2 fill:#e1f5fe,stroke:#01579b,color:#333 +``` + +## 2. Fundamental Data Types in ML + +Every feature in your dataset will eventually be mapped to one of these fundamental Python types. + +### A. Numerical Types + +* **`int`**: Whole numbers (e.g., number of layers, epochs). +* **`float`**: Decimal numbers. Most weights and probabilities in ML are 64-bit or 32-bit floats. +* **`complex`**: Used in signal processing and Fourier transforms. + +### B. Boolean Type (`bool`) + +* Represents `True` or `False`. Used for binary masks (e.g., selecting rows in a dataset where `age > 30`). + +### C. Sequence Types + +* **`str`**: Strings are used for category labels or raw text in Natural Language Processing (NLP). +* **`list`**: A mutable, ordered sequence. +* **`tuple`**: An immutable (unchangeable) sequence. Often used for tensor shapes like `(3, 224, 224)`. + +## 3. Mutability: The "Gotcha" in ML + +Understanding **Mutability** is crucial when passing data through pre-processing functions. + +* **Mutable (Can be changed):** `list`, `dict`, `set`, `numpy.ndarray`. +* **Immutable (Cannot be changed):** `int`, `float`, `str`, `tuple`. + +```mermaid +graph TD + Data[Object in Memory] --> Mut[Mutable] + Data --> Immut[Immutable] + + Mut -->|Impact| M_Effect["Changing a copy changes the original if not 'deep-copied'"] + Immut -->|Impact| I_Effect["Any 'change' creates a brand new object"] + + style Mut fill:#fff3e0,stroke:#ef6c00,color:#333 + style Immut fill:#e8f5e9,stroke:#2e7d32,color:#333 + +``` + +:::warning ML Common Bug +If you pass a list of hyperparameters to a function and the function modifies that list, the original list *outside* the function will also be changed. Always use `.copy()` if you want to preserve the original data! +::: + +## 4. Type Casting + +In ML, we frequently need to convert data types (e.g., converting integer pixel values `0-255` to floats `0.0-1.0`). + +```python +# Converting types +pixel_val = 255 +normalized = float(pixel_val) / 255.0 + +# Checking types +print(type(normalized)) # Output: + +``` + +## 5. Summary Reference Table + +| Type | Example | Mutable? | Typical ML Usage | +| --- | --- | --- | --- | +| **int** | `32` | No | Batch size, epoch count. | +| **float** | `0.001` | No | Learning rate, weights. | +| **str** | `"cat"` | No | Target labels, text data. | +| **list** | `[1, 2, 3]` | **Yes** | Collecting loss values over time. | +| **tuple** | `(28, 28)` | No | Input dimensions of an image. | +| **dict** | `{"id": 1}` | **Yes** | Storing model configuration. | + + +--- + +Now that we know how to store single values and lists, we need to know how to organize them logically for complex tasks. Let's look at more advanced data structures. \ No newline at end of file diff --git a/docs/machine-learning/programming-fundamentals/essential-libraries/matplotlib.mdx b/docs/machine-learning/programming-fundamentals/essential-libraries/matplotlib.mdx index e69de29..a9ac921 100644 --- a/docs/machine-learning/programming-fundamentals/essential-libraries/matplotlib.mdx +++ b/docs/machine-learning/programming-fundamentals/essential-libraries/matplotlib.mdx @@ -0,0 +1,113 @@ +--- +title: "Data Visualization: Matplotlib & Seaborn" +sidebar_label: Matplotlib +description: "Mastering the art of data visualization in Python: from basic line plots to complex statistical heatmaps." +tags: [python, matplotlib, seaborn, data-viz, eda, mathematics-for-ml] +--- + +In Machine Learning, a picture is worth a thousand rows of data. **Matplotlib** is the foundational "grandfather" library for plotting in Python, while **Seaborn** sits on top of it to provide beautiful, statistically-informed visualizations with much less code. + +## 1. The Anatomy of a Plot + +To master Matplotlib, you must understand its hierarchy. Every plot is contained within a **Figure**, which can hold one or more **Axes** (the actual plots). + +```mermaid +graph TD + Fig[Figure: The Window/Canvas] --> Ax1[Axes: Plot 1] + Fig --> Ax2[Axes: Plot 2] + + Ax1 --> Elements[Labels, Ticks, Legend, Data] + +``` + +## 2. Matplotlib: The Basics + +The most common interface is `pyplot`. It follows a state-machine logic similar to MATLAB. + +```python +import matplotlib.pyplot as plt + +# Data +epochs = [1, 2, 3, 4, 5] +loss = [0.9, 0.7, 0.5, 0.3, 0.2] + +# Plotting +plt.plot(epochs, loss, label='Training Loss', marker='o') +plt.title("Model Training Progress") +plt.xlabel("Epochs") +plt.ylabel("Loss") +plt.legend() +plt.show() + +``` + +## 3. Essential ML Plots + +In your ML workflow, you will constantly use these four types of visualizations: + +| Plot Type | Best Use Case | Library Choice | +| --- | --- | --- | +| **Line Plot** | Monitoring Loss/Accuracy over time (epochs). | Matplotlib | +| **Scatter Plot** | Finding correlations between two features ( vs ). | Seaborn | +| **Histogram** | Checking if a feature follows a **Normal Distribution**. | Seaborn | +| **Heatmap** | Visualizing a **Correlation Matrix** or **Confusion Matrix**. | Seaborn | + +## 4. Seaborn: Statistical Beauty + +Seaborn makes complex plots easy. It integrates directly with Pandas DataFrames and handles the labeling and coloring automatically. + +```python +import seaborn as sns + +# Load a built-in dataset +iris = sns.load_dataset("iris") + +# A single line to see relationships across all features +sns.pairplot(iris, hue="species") +plt.show() + +``` + +## 5. Visualizing Model Performance + +### The Heatmap (Confusion Matrix) + +A heatmap is the standard way to visualize where a classification model is getting confused. + +```python +# Assuming 'cm' is your confusion matrix array +sns.heatmap(cm, annot=True, cmap='Blues') +plt.xlabel("Predicted Label") +plt.ylabel("True Label") + +``` + +### Subplots + +Sometimes you need to compare multiple plots side-by-side (e.g., Training Loss vs. Validation Loss). + +```python +fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4)) + +ax1.plot(loss) +ax1.set_title("Loss") + +ax2.plot(accuracy) +ax2.set_title("Accuracy") + +``` + +## 6. The "Object-Oriented" vs "Pyplot" Debate + +* **`plt.plot()` (Pyplot):** Great for quick interactive exploration. +* **`fig, ax = plt.subplots()` (OO style):** Better for complex layouts and production scripts where you need fine-grained control over every element. + +## References for More Details + +* **[Matplotlib Plot Gallery](https://matplotlib.org/stable/gallery/index.html):** Finding code templates for literally any type of plot. + +* **[Seaborn Tutorial](https://seaborn.pydata.org/tutorial.html):** Learning how to visualize statistical relationships. + +--- + +Visualization is the final piece of our programming foundations. Now that you can process data with NumPy, clean it with Pandas, and visualize it with Matplotlib, you are ready to start building actual models. \ No newline at end of file diff --git a/docs/machine-learning/programming-fundamentals/essential-libraries/numpy.mdx b/docs/machine-learning/programming-fundamentals/essential-libraries/numpy.mdx index e69de29..5d13877 100644 --- a/docs/machine-learning/programming-fundamentals/essential-libraries/numpy.mdx +++ b/docs/machine-learning/programming-fundamentals/essential-libraries/numpy.mdx @@ -0,0 +1,109 @@ +--- +title: "NumPy: Numerical Python" +sidebar_label: NumPy +description: "Mastering N-dimensional arrays, vectorization, and broadcasting: the foundational tools for numerical computing in ML." +tags: [python, numpy, arrays, vectorization, broadcasting, mathematics-for-ml] +--- + +If Python is the skeleton of Machine Learning, **NumPy** is the muscle. It is a library for scientific computing that introduces the **ndarray** (N-dimensional array), which is significantly faster and more memory-efficient than standard Python lists. + +## 1. Why NumPy? (Speed & Efficiency) + +Python lists are flexible but slow because they store pointers to objects scattered in memory. NumPy arrays store data in **contiguous memory blocks**, allowing the CPU to process them using SIMD (Single Instruction, Multiple Data). + +```mermaid +graph LR + List[Python List] --> L_Ptr["Scattered Memory (Slow)"] + Array[NumPy Array] --> A_Cont["Contiguous Block (Fast)"] + style Array fill:#e1f5fe,stroke:#01579b,color:#333 + +``` + +## 2. Array Anatomy and Shapes + +In ML, we describe data by its **Rank** (number of dimensions) and **Shape**. + +* **Scalar (Rank 0):** A single number. +* **Vector (Rank 1):** A line of numbers (e.g., a single sample's features). +* **Matrix (Rank 2):** A table of numbers (e.g., a whole dataset). +* **Tensor (Rank 3+):** Higher dimensional arrays (e.g., a batch of color images). + +```python +import numpy as np + +# Creating a 2D Matrix +data = np.array([[1, 2, 3], [4, 5, 6]]) +print(data.shape) # Output: (2, 3) -> 2 rows, 3 columns + +``` + +## 3. Vectorization + +**Vectorization** is the practice of replacing explicit `for` loops with array expressions. This is how we achieve high performance in Python. + +**Instead of this:** + +```python +# Slow: Element-wise addition with a loop +result = [] +for i in range(len(a)): + result.append(a[i] + b[i]) + +``` + +**Do this:** + +```python +# Fast: NumPy handles the loop in C +result = a + b + +``` + +## 4. Broadcasting: The Magic of NumPy + +Broadcasting allows NumPy to perform arithmetic operations on arrays with **different shapes**, provided they meet certain compatibility rules. + +```mermaid +graph TD + A["Matrix: (3, 3)"] + B["Scalar: (1,)"] + A -->|Add| B + B -->|Broadcast| B_Stretch["Stretched to (3, 3)"] + B_Stretch --> Result["Element-wise Sum"] + +``` + +**Example:** Adding a constant bias to every row in a dataset. + +```python +features = np.array([[10, 20], [30, 40]]) # Shape (2, 2) +bias = np.array([5, 5]) # Shape (2,) +result = features + bias # [[15, 25], [35, 45]] + +``` + +## 5. Critical ML Operations in NumPy + +| Operation | NumPy Function | ML Use Case | +| --- | --- | --- | +| **Dot Product** | `np.dot(a, b)` | Calculating weighted sums in a neuron. | +| **Reshaping** | `arr.reshape(1, -1)` | Changing an image from 2D to a 1D feature vector. | +| **Transposing** | `arr.T` | Aligning dimensions for matrix multiplication. | +| **Aggregations** | `np.mean()`, `np.std()` | Normalizing data (Standard Scaling). | +| **Slicing** | `arr[:, 0]` | Extracting a single column (feature) from a dataset. | + +## 6. Slicing and Masking + +NumPy allows for "Boolean Indexing," which is incredibly powerful for filtering data. + +```python +# Select all values in the array greater than 0.5 +weights = np.array([0.1, 0.8, -0.2, 0.9]) +positive_weights = weights[weights > 0] +# Result: [0.1, 0.8, 0.9] + +``` + +--- + +While NumPy handles the raw numbers, we need a way to manage data with column names, different data types, and missing values. For that, we turn to the most popular data manipulation library. \ No newline at end of file diff --git a/docs/machine-learning/programming-fundamentals/essential-libraries/pandas.mdx b/docs/machine-learning/programming-fundamentals/essential-libraries/pandas.mdx index e69de29..08721e7 100644 --- a/docs/machine-learning/programming-fundamentals/essential-libraries/pandas.mdx +++ b/docs/machine-learning/programming-fundamentals/essential-libraries/pandas.mdx @@ -0,0 +1,121 @@ +--- +title: "Pandas: Data Manipulation" +sidebar_label: Pandas +description: "Mastering DataFrames, Series, and data cleaning techniques: the essential toolkit for exploratory data analysis (EDA)." +tags: [python, pandas, dataframe, data-cleaning, eda, mathematics-for-ml] +--- + +In Machine Learning, data rarely arrives ready for training. It comes in messy CSVs, Excel files, or SQL databases with missing values and inconsistent formatting. **Pandas** is the library designed to handle this "Data Wrangling." + +## 1. Core Data Structures + +Pandas is built on top of NumPy, but it adds labels (indices and column names) to the data. + +```mermaid +graph TD + Data[Pandas Data Structures] --> Series["Series (1D)"] + Data --> DF["DataFrame (2D)"] + + Series --> S_Desc["A single column of data with an index"] + DF --> DF_Desc["A table with rows and columns (The 'Excel' of Python)"] + +``` + +### The DataFrame + +A DataFrame is essentially a dictionary of Series objects. It is the primary object you will use to store your features () and targets (). + +```python +import pandas as pd + +# Creating a DataFrame from a dictionary +df = pd.DataFrame({ + 'Age': [25, 30, 35], + 'Salary': [50000, 60000, 70000] +}) + +``` + +## 2. Loading and Inspecting Data + +Pandas can read almost any format. Once loaded, we use specific methods to "peek" into the data. + +* **`pd.read_csv('data.csv')`**: The most common way to load data. +* **`df.head()`**: View the first 5 rows. +* **`df.info()`**: Check data types and memory usage. +* **`df.describe()`**: Get statistical summaries (mean, std, min, max). + +## 3. Selecting and Filtering Data + +In ML, we often need to separate our target variable from our features. We use `.loc` (label-based) and `.iloc` (integer-based) indexing. + +```python +# Select all rows, but only the 'Salary' column +target = df['Salary'] + +# Select rows where Age is greater than 30 +seniors = df[df['Age'] > 30] + +``` + +## 4. Data Cleaning: The "ML Pre-processing" Step + +Before a model can learn, the data must be "clean." Pandas provides high-level functions for the most common cleaning tasks: + +### A. Handling Missing Values + +Most ML algorithms cannot handle `NaN` (Not a Number) values. + +* **`df.isnull().sum()`**: Count missing values. +* **`df.dropna()`**: Remove rows with missing values. +* **`df.fillna(df.mean())`**: Fill missing values with the average (Imputation). + +### B. Handling Categorical Data + +ML models require numbers. We use Pandas to convert text to categories. + +* **`pd.get_dummies(df['City'])`**: One-Hot Encoding (turns "City" into multiple 0/1 columns). + +## 5. Grouping and Aggregation + +Commonly used in **Exploratory Data Analysis (EDA)** to find patterns. + +```python +# Calculate the average salary per city +avg_sal = df.groupby('City')['Salary'].mean() + +``` + +```mermaid +flowchart LR + A[Raw DataFrame] --> B["Split (by Category)"] + B --> C["Apply (Mean/Sum)"] + C --> D["Combine (New Table)"] + style B fill:#e1f5fe,stroke:#01579b,color:#333 + +``` + +## 6. Vectorized String Operations + +Pandas allows you to perform operations on entire text columns without writing loops—essential for **Natural Language Processing (NLP)**. + +```python +# Lowercase all text in a 'Reviews' column +df['Reviews'] = df['Reviews'].str.lower() + +``` + +## References for More Details + +* **Pandas Official "10 Minutes to Pandas":** +* [Link](https://pandas.pydata.org/docs/user_guide/10min.html) +* *Best for:* A quick syntax cheat sheet. + + +* **Kaggle - Data Cleaning Course:** +* [Link](https://www.kaggle.com/learn/data-cleaning) +* *Best for:* Practical, hands-on experience with messy real-world data. + +--- + +Pandas helps us clean the data, but "seeing is believing." To truly understand our dataset, we need to visualize the relationships between variables. \ No newline at end of file diff --git a/docs/machine-learning/programming-fundamentals/essential-libraries/seaborn.mdx b/docs/machine-learning/programming-fundamentals/essential-libraries/seaborn.mdx index e69de29..fba429f 100644 --- a/docs/machine-learning/programming-fundamentals/essential-libraries/seaborn.mdx +++ b/docs/machine-learning/programming-fundamentals/essential-libraries/seaborn.mdx @@ -0,0 +1,104 @@ +--- +title: "Seaborn: Statistical Visualization" +sidebar_label: Seaborn +description: "Mastering high-level statistical plotting: visualizing distributions, regressions, and categorical relationships." +tags: [python, seaborn, data-viz, eda, statistics, mathematics-for-ml] +--- + +**Seaborn** is a Python data visualization library based on Matplotlib. It provides a high-level interface for drawing attractive and informative statistical graphics. In Machine Learning, we use Seaborn to quickly understand the distribution of our features and the correlations between them. + +## 1. Why Seaborn over Matplotlib? + +Seaborn is designed to work directly with **Pandas DataFrames**. It automates much of the boilerplate code (like labeling axes and handling colors) that Matplotlib requires. + +```mermaid +graph LR + P[Pandas DataFrame] --> S[Seaborn] + S -->|Automated Logic| M[Matplotlib Engine] + M --> Out[Professional Statistical Plot] + + style S fill:#e1f5fe,stroke:#01579b,color:#333 + +``` + +## 2. Visualizing Distributions + +Before training a model, you need to know if your data is "Normal" (Gaussian) or skewed. + +### Histograms and KDEs + +The `displot()` (distribution plot) combines a histogram with a **Kernel Density Estimate (KDE)** to show the "shape" of your data. + +```python +import seaborn as sns +import matplotlib.pyplot as plt + +# Visualizing the distribution of a feature +sns.displot(df['feature_name'], kde=True, color="skyblue") +plt.show() + +``` + +## 3. Visualizing Relationships + +### Scatter Plots and Regressions + +In ML, we often want to see if one feature can predict another. `regplot()` draws a scatter plot and fits a **Linear Regression** line automatically. + +```python +# Check for linear relationship between 'SquareFootage' and 'Price' +sns.regplot(data=df, x="SquareFootage", y="Price") + +``` + +### The Pair Plot + +The `pairplot()` is perhaps the most useful tool in EDA. It creates a matrix of plots, showing every feature's relationship with every other feature. + +```python +# Instant overview of the entire dataset +sns.pairplot(df, hue="Target_Class") + +``` + +## 4. Visualizing Categorical Data + +When dealing with discrete categories (like "City" or "Product Type"), we use plots that show the central tendency and variance. + +* **Box Plot:** Shows the median, quartiles, and **outliers**. +* **Violin Plot:** Combines a box plot with a KDE to show the density of the data at different values. + +```python +# Comparing distribution across categories +sns.boxplot(data=df, x="Category", y="Value") + +``` + +## 5. Matrix Plots: Correlation Analysis + +Before selecting features for your model, you must check for **Multicollinearity** (features that are too similar to each other). We do this using a Correlation Matrix visualized as a Heatmap. + +```python +# Compute correlation matrix +corr = df.corr() + +# Visualize with Heatmap +sns.heatmap(corr, annot=True, cmap='coolwarm', fmt=".2f") + +``` + +## 6. Seaborn "Themes" and Aesthetics + +Seaborn makes it easy to change the look of your plots globally to match a professional report or dark-mode dashboard. + +* `sns.set_theme(style="whitegrid")` +* `sns.set_context("talk")` (Scales labels for presentations) + +## References for More Details + +* **[Seaborn Example Gallery](https://seaborn.pydata.org/examples/index.html):** Finding the specific "look" you want for your data. +* **[Python Graph Gallery](https://python-graph-gallery.com/seaborn/):** Learning how to customize Seaborn plots beyond the defaults. + +--- + +You have now mastered the "Big Three" of Python data science: NumPy for math, Pandas for data, and Matplotlib/Seaborn for sight. You are ready to stop preparing and start predicting. \ No newline at end of file diff --git a/docs/machine-learning/programming-fundamentals/object-oriented-programming.mdx b/docs/machine-learning/programming-fundamentals/object-oriented-programming.mdx index e69de29..2949b21 100644 --- a/docs/machine-learning/programming-fundamentals/object-oriented-programming.mdx +++ b/docs/machine-learning/programming-fundamentals/object-oriented-programming.mdx @@ -0,0 +1,89 @@ +--- +title: OOP in Machine Learning +sidebar_label: OOP Basics +description: "Understanding Classes, Objects, and the four pillars of OOP in the context of Machine Learning model development." +tags: [python, oop, classes, objects, inheritance, mathematics-for-ml] +--- + +Most beginner code is **Procedural** (a long list of instructions). However, professional Machine Learning code is almost always **Object-Oriented**. OOP allows us to bundle data (like model weights) and functions (like the training logic) into a single unit called an **Object**. + +## 1. Classes vs. Objects + +Think of a **Class** as a blueprint and an **Object** as the actual house built from that blueprint. + +* **Class:** The template for a "Model" (e.g., defines that all models need a `fit` and `predict` method). +* **Object:** A specific instance (e.g., a `RandomForest` trained on housing data). + +```mermaid +graph TD + Blueprint[Class: LinearModel] --> Instance1[Object: Model_for_Price] + Blueprint --> Instance2[Object: Model_for_Sales] + + style Blueprint fill:#e1f5fe,stroke:#01579b,color:#333 + style Instance1 fill:#f3e5f5,stroke:#7b1fa2,color:#333 + +``` + +## 2. The Core Components: Attributes and Methods + +In ML, an object typically consists of: + +1. **Attributes (Data):** The "State" of the model. (e.g., `self.weights`, `self.learning_rate`). +2. **Methods (Behavior):** The "Actions" the model can take. (e.g., `self.fit()`, `self.predict()`). + +```python +class SimpleModel: + def __init__(self, lr): + # Attribute: Initializing the state + self.learning_rate = lr + self.weights = None + + def fit(self, X, y): + # Method: Defining behavior + print(f"Training with LR: {self.learning_rate}") + +``` + +## 3. The Four Pillars of OOP in ML + +### A. Encapsulation + +Hiding the internal complexity. You don't need to know the calculus inside `.fit()` to use it; you just call the method. It "encapsulates" the math away from the user. + +### B. Inheritance + +Creating a new class based on an existing one. In libraries like PyTorch, your custom neural network **inherits** from a base `Module` class. + +### C. Polymorphism + +The ability for different objects to be treated as instances of the same general class. For example, you can loop through a list of different models and call `.predict()` on all of them, regardless of their internal math. + +### D. Abstraction + +Using simple interfaces to represent complex tasks. An "Optimizer" object abstracts away the specific update rules (SGD, Adam, RMSProp). + +## 4. Why use OOP for ML? + +1. **Organization:** Keeps weights and training logic together. Without OOP, you'd have to pass `weights` as an argument to every single function. +2. **Reproducibility:** You can save an entire object (the "state_dict") and reload it later to get the exact same results. +3. **Extensibility:** Want to try a new loss function? You can create a subclass and just override one method without rewriting the whole training loop. + +## 5. Standard ML Pattern: The Class Structure + +```python +class MyNeuralNet: + def __init__(self, input_size): + self.weights = initialize(input_size) # State + + def forward(self, x): + return x @ self.weights # Behavior 1 + + def backward(self, grad): + # Update weights logic # Behavior 2 + pass + +``` + +--- + +Now that you understand how objects work, you can begin to navigate the source code of major ML libraries. But before we build complex classes, we need to master the math engine that powers them. \ No newline at end of file diff --git a/docs/machine-learning/programming-fundamentals/python.mdx b/docs/machine-learning/programming-fundamentals/python.mdx index e69de29..774691c 100644 --- a/docs/machine-learning/programming-fundamentals/python.mdx +++ b/docs/machine-learning/programming-fundamentals/python.mdx @@ -0,0 +1,121 @@ +--- +title: Python for Machine Learning +sidebar_label: Python +description: "Mastering the Python essentials required for ML: from data structures to vectorization and the scientific ecosystem." +tags: [python, programming, numpy, pandas, mathematics-for-ml] +--- + +Python is the "lingua franca" of Machine Learning. Its simplicity allows researchers to focus on algorithms rather than syntax, while its robust ecosystem of libraries provides the heavy lifting for mathematical computations. + +## 1. Why Python for ML? + +The power of Python in ML doesn't come from its speed (it is actually quite slow compared to C++), but from its **ecosystem**. + +```mermaid +mindmap + root((Python ML Ecosystem)) + Data Processing + Pandas + NumPy + Visualization + Matplotlib + Seaborn + Plotly + Modeling + Scikit-Learn + PyTorch + TensorFlow + Deployment + FastAPI + Flask + +``` + +## 2. Core Data Structures for ML + +In ML, we don't just store values; we store **features** and **labels**. Understanding how Python holds this data is vital. + +| Structure | Syntax | Best Use Case in ML | +| --- | --- | --- | +| **List** | `[1, 2, 3]` | Storing a sequence of layer sizes or hyperparameter values. | +| **Dictionary** | `{"lr": 0.01}` | Passing hyperparameters to a model. | +| **Tuple** | `(640, 480)` | Storing immutable shapes of images or tensors. | +| **Set** | `{1, 2}` | Finding unique classes/labels in a dataset. | + +## 3. The Power of Vectorization (NumPy) + +Standard Python `for` loops are slow. In ML, we use **Vectorization** via NumPy to perform operations on entire arrays at once. This pushes the computation down to optimized C and Fortran code. + +```python +import numpy as np + +# Standard Python (Slow) +result = [x + 5 for x in range(1000000)] + +# NumPy Vectorization (Fast) +arr = np.arange(1000000) +result = arr + 5 + +``` + +### Multi-dimensional Data + +Most ML data is represented as **Tensors** (ND-Arrays): + +* **1D Array:** A single feature vector. +* **2D Array:** A dataset (rows = samples, columns = features). +* **3D Array:** A batch of grayscale images. +* **4D Array:** A batch of color images (Batch, Height, Width, Channels). + +## 4. Functional Programming Tools + +ML code often involves transforming data. These three tools are used constantly for feature engineering: + +1. **List Comprehensions:** Creating new lists from old ones in one line. +* `normalized_data = [x / 255 for x in pixels]` + + +2. **Lambda Functions:** Small, anonymous functions for quick transformations. +* `clean_text = lambda x: x.lower().strip()` + + +3. **Map/Filter:** Applying functions across datasets efficiently. + +--- + +## 5. Object-Oriented Programming (OOP) in ML + +Most ML frameworks (like Scikit-Learn and PyTorch) use Classes to define models. Understanding `self`, `__init__`, and `inheritance` is necessary for building custom model pipelines. + +```mermaid +classDiagram + class Model { + +weights: array + +bias: float + +train(data) + +predict(input) + } + Model <-- LinearRegression + Model <-- LogisticRegression + +``` + +## 6. Common ML Patterns in Python + +### The Fit-Transform Pattern + +Almost all Python ML libraries follow this logical flow: + +```mermaid +flowchart LR + A[Raw Data] --> B["fit() : Learn parameters from data"] + B --> C["transform() : Apply changes to data"] + C --> D["predict() : Generate output"] + style B fill:#e1f5fe,stroke:#01579b,color:#333 + style D fill:#f9f,stroke:#333,color:#333 + +``` + +--- + +Python provides the syntax, but for heavy mathematical operations, we need a specialized engine. Let's dive into the core library that makes numerical computing in Python possible. \ No newline at end of file diff --git a/static/img/tutorials/ml/bubble-visualization.jpg b/static/img/tutorials/ml/bubble-visualization.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e25a2c6acf84693af2b459a7a6b23d376ab28a65 GIT binary patch literal 102318 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%0AOKah8eAD@ujwvd2T^;gRENxJ2MHk~gUcR1 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 z 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≺^!Ju0lXgKjhU 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