Merge pull request #175 from codeharborhub/dev-1

more content added...

Author: ajay-dhangar

docs/machine-learning/deep-learning/deep-learning-libraries/keras.mdx

@@ -0,0 +1,121 @@
+---
+title: "Keras: Deep Learning for Humans"
+sidebar_label: Keras
+description: "Understanding the high-level API that makes building neural networks as easy as stacking LEGO blocks."
+tags: [deep-learning, keras, tensorflow, neural-networks, api, python]
+---
+
+**Keras** is an open-source deep learning library written in Python. It was designed by François Chollet with a simple mission: **to enable fast experimentation.** Being able to go from idea to result with the least possible delay is key to doing good research.
+
+Since the release of TensorFlow 2.0, Keras has become the official high-level API for TensorFlow, providing a polished, user-friendly interface for the powerful engine beneath.
+
+## 1. The Design Philosophy
+
+Keras is built on four core principles:
+1.  **User Friendliness:** It provides consistent and simple APIs that minimize the number of user actions required for common use cases.
+2.  **Modularity:** A model is understood as a sequence or a graph of standalone, fully configurable modules (layers, loss functions, optimizers).
+3.  **Easy Extensibility:** New modules are easy to add as new classes and functions.
+4.  **Work with Python:** Keras models are defined in Python code, which is compact, easy to debug, and easy to extend.
+
+## 2. Three Ways to Build Models
+
+Keras offers three different APIs to balance ease of use with flexibility:
+
+### A. The Sequential API
+The simplest way to build a model. You literally "stack" layers one on top of the other. It is perfect for $90\%$ of use cases where you have one input and one output.
+
+```python title="Building a Sequential Model"
+from tensorflow.keras import Sequential
+from tensorflow.keras.layers import Dense
+
+model = Sequential([
+    Dense(64, activation='relu', input_shape=(20,)),
+    Dense(10, activation='softmax')
+])
+
+```
+
+### B. The Functional API
+
+Used for more complex models. It allows you to build graphs of layers with multiple inputs, multiple outputs, or shared layers. It treats layers as functions.
+
+```python title="Building a Functional Model"
+from tensorflow.keras import Input, Model
+from tensorflow.keras.layers import Dense
+inputs = Input(shape=(20,))
+x = Dense(64, activation='relu')(inputs)
+outputs = Dense(10, activation='softmax')(x)
+model = Model(inputs=inputs, outputs=outputs)
+```
+
+### C. Model Subclassing
+
+The "pro" way. You define everything from scratch by subclassing the `Model` class. This gives you total control over the forward pass, which is essential for custom research or complex dynamic networks.
+
+```python title="Building a Subclassed Model"
+from tensorflow.keras import Model
+from tensorflow.keras.layers import Dense
+class MyModel(Model):
+    def __init__(self):
+        super(MyModel, self).__init__()
+        self.dense1 = Dense(64, activation='relu')
+        self.dense2 = Dense(10, activation='softmax')
+
+    def call(self, inputs):
+        x = self.dense1(inputs)
+        return self.dense2(x)
+model = MyModel()
+```
+
+## 3. The Keras Workflow
+
+Building and training a model in Keras always follows this 5-step lifecycle:
+
+1. **Define:** Specify the layers and architecture.
+2. **Compile:** Choose an **Optimizer** (e.g., Adam), a **Loss Function** (e.g., MSE), and **Metrics** (e.g., Accuracy).
+3. **Fit:** Train the model on your data.
+4. **Evaluate:** Check how the model performs on unseen data.
+5. **Predict:** Use the model to generate outputs for new samples.
+
+```python title="Keras Workflow Example"
+# The 'Compile' step is where the math meets the code
+model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
+
+# The 'Fit' step starts the training loop
+model.fit(X_train, y_train, epochs=10, batch_size=32)
+
+```
+
+## 4. Key Components: Layers & Callbacks
+
+### Common Layers:
+
+* `Dense`: Standard fully connected layer.
+* `Conv2D`: Used for image processing (Computer Vision).
+* `LSTM` / `GRU`: Used for sequence data (NLP).
+* `Dropout`: A regularization technique to prevent overfitting by randomly "killing" neurons during training.
+
+### Callbacks:
+
+Callbacks are tools that perform actions at various stages of training, such as:
+
+* **EarlyStopping:** Stop training when the model stops improving.
+* **ModelCheckpoint:** Save the "best" version of your model automatically.
+
+## 5. Pros and Cons
+
+| Advantages | Disadvantages |
+| --- | --- |
+| **Simplicity:** The most beginner-friendly library in the ecosystem. | **Lower-level Control:** It can be harder to implement highly experimental, custom logic compared to PyTorch. |
+| **Speed of Prototyping:** Build a working CNN in under 20 lines of code. | **Opaque Errors:** Because it is high-level, stack traces can sometimes be harder to interpret. |
+| **Large Community:** Thousands of tutorials and pre-trained models. | **Performance:** Occasionally slightly slower than raw TensorFlow code due to the abstraction layer. |
+
+## References
+
+* **Official Keras Site:** [keras.io](https://keras.io/)
+* **Book:** *Deep Learning with Python* by François Chollet.
+* **Guide:** [The Functional API vs Sequential API](https://www.tensorflow.org/guide/keras/functional)
+
+---
+
+**Keras makes building models easy. But what if you want more "Pythonic" control and dynamic computation graphs?** Check out our guide on [PyTorch](./pytorch)!

docs/machine-learning/deep-learning/deep-learning-libraries/pytorch.mdx

@@ -0,0 +1,93 @@
+---
+title: "PyTorch: The Researcher's Powerhouse"
+sidebar_label: PyTorch
+description: "Exploring Facebook's PyTorch library, dynamic computational graphs, and its Pythonic approach to deep learning."
+tags: [deep-learning, pytorch, facebook, meta, neural-networks, research]
+---
+
+**PyTorch**, developed by Meta's (Facebook) AI Research lab (FAIR), is an open-source machine learning library based on the Torch library. Since its release, it has overtaken other frameworks in the research community due to its **Dynamic Computational Graphs** and its seamless integration with the Python ecosystem.
+
+## 1. The Core Philosophy: "Pythonic" Design
+
+Unlike other frameworks that feel like a separate language ported into Python, PyTorch feels like **native Python**. 
+* If you know how to use NumPy, you already know 80% of PyTorch.
+* It uses standard Python debugging tools (like `pdb` or print statements).
+* It follows Object-Oriented Programming (OOP) principles strictly.
+
+## 2. Dynamic vs. Static Graphs
+
+The defining feature of PyTorch is the **Dynamic Computational Graph** (also known as *Define-by-Run*).
+
+* **Static Graphs (Old TensorFlow):** You build a roadmap, then send cars (data) through it. You cannot change the road once the cars are moving.
+* **Dynamic Graphs (PyTorch):** The roadmap is built as the car moves. You can change the network's behavior on the fly based on the data it receives.
+
+This makes PyTorch exceptionally good for **Natural Language Processing (NLP)**, where sentences have different lengths and require flexible architectures.
+
+## 3. The Building Blocks: Tensors and Autograd
+
+### Tensors
+
+The fundamental unit in PyTorch is the `torch.Tensor`. It is essentially an n-dimensional array that can be moved to a **GPU** with a single line of code (`.to('cuda')`) for massive speedups.
+
+### Autograd
+
+PyTorch’s `autograd` engine automatically calculates derivatives (gradients). When you perform operations on tensors, PyTorch remembers the "math history" and can automatically apply the **Chain Rule** to find gradients during backpropagation.
+
+$$
+\text{loss.backward()} \rightarrow \text{Automatically calculates } \frac{\partial Loss}{\partial w}
+$$
+
+## 4. Building a Model in PyTorch
+
+In PyTorch, you define a model by creating a class that inherits from `nn.Module`.
+
+```python
+import torch
+import torch.nn as nn
+
+class SimpleNet(nn.Module):
+    def __init__(self):
+        super(SimpleNet, self).__init__()
+        # Define the layers
+        self.hidden = nn.Linear(10, 32)
+        self.output = nn.Linear(32, 1)
+        self.relu = nn.ReLU()
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        # Define the flow of data
+        x = self.relu(self.hidden(x))
+        x = self.sigmoid(self.output(x))
+        return x
+
+model = SimpleNet()
+
+```
+
+## 5. The PyTorch Ecosystem
+
+PyTorch isn't just for building models; it has a rich set of libraries for specific domains:
+
+| Library | Domain | Key Features |
+| --- | --- | --- |
+| **TorchVision** | Computer Vision | Pre-trained models (ResNet, VGG), image transforms. |
+| **TorchText** | NLP | Data loaders for text, tokenization tools. |
+| **TorchAudio** | Audio | Signal processing and audio data manipulation. |
+| **PyTorch Lightning** | Boilerplate | A high-level wrapper that organizes PyTorch code for better readability. |
+
+## 6. Pros and Cons
+
+| Advantages | Disadvantages |
+| --- | --- |
+| **Debuggability:** Error messages are clear and standard Python debuggers work. | **Deployment:** Historically, it was harder to put into production than TensorFlow (though this is changing with TorchScript). |
+| **Community:** Most modern AI research papers are published with PyTorch code. | **Verbosity:** You have to write your own training loops (manual control). |
+| **Flexibility:** Easiest library for building custom, complex architectures. | **Mobile:** Smaller ecosystem for mobile/edge deployment compared to TF Lite. |
+
+## References
+
+* **PyTorch Tutorials:** [Welcome to PyTorch Tutorials](https://pytorch.org/tutorials/)
+* **Deep Learning with PyTorch:** [Free e-book by Eli Stevens](https://pytorch.org/assets/deep-learning/Deep-Learning-with-PyTorch.pdf)
+
+---
+
+**PyTorch gives you total control over your training loop. But how do you handle data that doesn't fit into a standard table, like images?**

docs/machine-learning/deep-learning/deep-learning-libraries/tensorflow.mdx

@@ -0,0 +1,96 @@
+---
+title: "TensorFlow: Production-Grade Deep Learning Library"
+sidebar_label: TensorFlow
+description: "An introduction to Google's TensorFlow ecosystem, Keras API, and the dataflow graph architecture."
+tags: [deep-learning, tensorflow, keras, google, neural-networks, production]
+---
+
+**TensorFlow**, developed by the Google Brain team, is one of the most popular open-source libraries for high-performance numerical computation and machine learning. Its name comes from **Tensors** (multi-dimensional arrays) and the **Flow** of data through a computational graph.
+
+## 1. The Core Concept: Tensors
+
+In TensorFlow, all data is represented as a **Tensor**. 
+* **Scalar:** Rank 0 (a single number)
+* **Vector:** Rank 1 (a list of numbers)
+* **Matrix:** Rank 2 (a table of numbers)
+* **n-Tensor:** Rank n (multi-dimensional arrays)
+
+Tensors flow through a **computational graph**, where nodes represent operations (like addition or multiplication) and edges represent the tensors being passed between them. This graph-based approach allows TensorFlow to optimize computations for performance and scalability, making it suitable for both research and production environments.
+
+## 2. Evolution: TensorFlow 1.x vs. 2.x
+
+One of the biggest shifts in the library's history was the move to version 2.0.
+
+* **TF 1.x (Static Graphs):** You had to define the entire architecture (the "Graph") before running any data through it using a `Session`. It was powerful but notoriously difficult to debug.
+* **TF 2.x (Eager Execution):** TensorFlow now runs operations immediately, just like standard Python code. It also fully integrated **Keras** as the official high-level API, making it much more user-friendly.
+
+This change made TensorFlow more accessible to beginners while retaining its powerful capabilities for advanced users.
+
+## 3. The TensorFlow Ecosystem
+
+What sets TensorFlow apart is that it isn't just a library; it's a full production ecosystem:
+
+| Component | Purpose |
+| :--- | :--- |
+| **TensorFlow Core** | The base engine for building and training models. |
+| **Keras** | The high-level API for rapid prototyping (Human-centric). |
+| **TF Hub** | A repository of pre-trained models for Transfer Learning. |
+| **TensorBoard** | A suite of visualization tools to track training progress and graphs. |
+| **TF Lite** | Optimized for mobile and IoT devices. |
+| **TF Serving** | For deploying models in production environments via APIs. |
+
+## 4. Building Your First Model (Keras API)
+
+The `Sequential` API is the easiest way to stack layers in TensorFlow.
+
+```python
+import tensorflow as tf
+from tensorflow.keras import layers
+
+# 1. Define the architecture
+model = tf.keras.Sequential([
+    layers.Dense(64, activation='relu', input_shape=(10,)),
+    layers.Dense(32, activation='relu'),
+    layers.Dense(1, activation='sigmoid') # Binary output
+])
+
+# 2. Compile the model
+model.compile(
+    optimizer='adam',
+    loss='binary_crossentropy',
+    metrics=['accuracy']
+)
+
+# 3. View the structure
+model.summary()
+
+```
+
+## 5. Visualization with TensorBoard
+
+TensorBoard is TensorFlow's "secret weapon." It allows you to visualize your loss curves, layer distributions, and even the computational graph in real-time through a web browser.
+
+```python
+# To use it, simply add a callback during training:
+tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir="./logs")
+
+model.fit(x_train, y_train, epochs=5, callbacks=[tensorboard_callback])
+
+```
+
+## 6. Pros and Cons
+
+| Advantages | Disadvantages |
+| --- | --- |
+| **Scalability:** Built to run on everything from mobile phones to massive TPU clusters. | **Steep Learning Curve:** Even with TF 2.x, the lower-level API can be complex. |
+| **Deployment:** Best-in-class tools for putting models into production. | **API Fragmentation:** Older tutorials for 1.x are incompatible with 2.x, which can be confusing. |
+| **Community:** Massive support and extensive pre-trained models. | **Heavyweight:** Larger library size compared to PyTorch. |
+
+## References
+
+* **TensorFlow Official:** [Install and Get Started](https://www.tensorflow.org/install)
+* **Keras Documentation:** [Simple. Flexible. Powerful.](https://keras.io/)
+
+---
+
+**TensorFlow is a powerhouse for production. But many researchers prefer a more "Pythonic" and flexible approach.** If you're looking for that, check out our guide on [PyTorch](./pytorch)!