Basic Link To orphan pages align.. experimental Notes

Author: VR-Rathod

pages/Data Science.md

@@ -144,7 +144,7 @@ displayTitle: Data Science
 - # Python for Data Science
   collapsed:: true
 	- See [[Python]] for full language reference. This section covers the data science-specific stack.
-	- ## NumPy — Numerical Computing
+	- ## [[NumPy]] — Numerical Computing
 	  collapsed:: true
 		- ```python
 		  import numpy as np
@@ -185,7 +185,7 @@ displayTitle: Data Science
 		  print(m.max())         # 9
 		  print(m.argmax())      # 8 (flat index)
 		  ```
-	- ## Pandas — Data Manipulation
+	- ## [[Pandas]] — Data Manipulation
 	  collapsed:: true
 		- ```python
 		  import pandas as pd
@@ -245,7 +245,7 @@ displayTitle: Data Science
 		  ```
 - # Data Visualization
   collapsed:: true
-	- ## Matplotlib — Core Plotting
+	- ## [[Matplotlib]] — Core Plotting
 	  collapsed:: true
 		- ```python
 		  import matplotlib.pyplot as plt
@@ -279,7 +279,7 @@ displayTitle: Data Science
 		  plt.bar(categories, values, color="coral")
 		  plt.show()
 		  ```
-	- ## Seaborn — Statistical Visualization
+	- ## [[Seaborn]] — Statistical Visualization
 	  collapsed:: true
 		- ```python
 		  import seaborn as sns
@@ -309,7 +309,7 @@ displayTitle: Data Science
 		  sns.pairplot(tips, hue="sex")
 		  plt.show()
 		  ```
-	- ## Plotly — Interactive Visualization
+	- ## [[Plotly]] — Interactive Visualization
 	  collapsed:: true
 		- ```python
 		  import plotly.express as px

pages/Matplotlib.md

@@ -1,7 +1,78 @@
 ---
-seoTitle: Matplotlib Python Library – Data Visualization Reference Guide
+seoTitle: Matplotlib Python Library - Data Visualization Reference Guide
 description: "Matplotlib creates static, animated, and interactive visualizations in Python. Covers pyplot, axes, subplots, plot types, customization, and saving figures."
 keywords: "Matplotlib, Python visualization, pyplot, subplots, plot types, data visualization, charts, graphs, figure customization, Python library, scientific plotting"
 ---
 
-- [Docs](https://matplotlib.org/stable/contents.html)
+- # 📘 **Overview**
+	- **What is it?**: Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations in Python. It is the core graphics engine behind many other plotting libraries (such as Seaborn and Pandas plotting).
+	- **Key Features**:
+		- **Highly Customizable**: Total control over fonts, axes, line styles, colors, and layout configurations.
+		- **Two Interfaces**: State-based interface (via `pyplot` - good for quick plots) and Object-Oriented interface (recommended for clean, robust layouts).
+		- **Export Options**: Export figures to multiple high-quality formats (PNG, PDF, SVG, etc.).
+	- **Installation**:
+		- ```bash
+		  pip install matplotlib
+		  ```
+- # 🧾 **Core Concepts**
+	- **Figure**: The overall window or page that contains all plot elements (axes, title, legend, etc.). Think of it as a canvas.
+	- **Axes**: A coordinate area within a Figure where data is plotted. A single Figure can contain multiple Axes (subplots).
+	- **Axis**: The actual helper lines and ticks marking scale values (e.g. X-axis, Y-axis).
+- # 💻 **Common Code Patterns & Cheat Sheet**
+	- **Basic Line Plot (Object-Oriented Style)**:
+		- ```python
+		  import matplotlib.pyplot as plt
+		  import numpy as np
+		  
+		  # Generate data
+		  x = np.linspace(0, 10, 100)
+		  y = np.sin(x)
+		  
+		  # Create Figure and Axes
+		  fig, ax = plt.subplots(figsize=(8, 4))
+		  
+		  # Plot data
+		  ax.plot(x, y, label="Sine Wave", color="purple", linewidth=2, linestyle="-")
+		  
+		  # Customize labels & grid
+		  ax.set_title("Simple Sine Plot", fontsize=14)
+		  ax.set_xlabel("X-Axis")
+		  ax.set_ylabel("Y-Axis")
+		  ax.legend(loc="upper right")
+		  ax.grid(True, linestyle="--", alpha=0.6)
+		  
+		  # Render / Show
+		  plt.tight_layout()
+		  plt.show()
+		  ```
+	- **Creating Subplots (Multi-plot Layouts)**:
+		- ```python
+		  # Create 1 row with 2 columns of plots
+		  fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
+		  
+		  # Left plot: Scatter
+		  ax1.scatter(np.random.rand(50), np.random.rand(50), color="blue", alpha=0.5)
+		  ax1.set_title("Scatter Plot")
+		  
+		  # Right plot: Histogram
+		  ax2.hist(np.random.randn(1000), bins=30, color="orange", edgecolor="black")
+		  ax2.set_title("Histogram")
+		  
+		  plt.tight_layout()
+		  plt.show()
+		  ```
+	- **Saving Plots**:
+		- ```python
+		  fig, ax = plt.subplots()
+		  ax.plot([1, 2, 3], [4, 5, 6])
+		  
+		  # Save as PNG with transparent background and high resolution
+		  fig.savefig("my_plot.png", dpi=300, bbox_inches="tight", transparent=True)
+		  ```
+- # 💡 **Best Practices & Tips**
+	- **Object-Oriented API**: Always prefer using `fig, ax = plt.subplots()` rather than calling `plt.plot()` directly. The OO API keeps your code cleaner when working with subplots or complex layouts.
+	- **Tight Layout**: Always call `plt.tight_layout()` before saving or showing a plot to prevent axes labels and titles from overlapping.
+	- **Closing Figures**: If you are generating many plots in a loop (e.g., in a background job or web server), always call `plt.close(fig)` or `plt.close('all')` to prevent memory leaks.
+- # 🔗 **Navigation & Internal Links**
+	- **Parent**: [[Python]]
+	- **Related Notes**: [[Data Science]] | [[Machine Learning]] | [[NumPy]] | [[Pandas]] | [[Seaborn]] | [[Plotly]]

pages/NumPy.md

@@ -1,7 +1,65 @@
 ---
-seoTitle: NumPy Python Library – Array Operations and Scientific Computing
+seoTitle: NumPy Python Library - Array Operations and Scientific Computing
 description: "NumPy is the foundation of scientific Python. Covers ndarray, broadcasting, indexing, linear algebra, random number generation, and performance optimization."
 keywords: "NumPy, Python arrays, ndarray, broadcasting, linear algebra, scientific computing, random numbers, indexing, slicing, Python library, numerical computing"
 ---
 
-- [docs](https://numpy.org/doc/)
+- # 📘 **Overview**
+	- **What is it?**: NumPy (Numerical Python) is the foundational package for scientific computing in Python. It provides support for large, multi-dimensional arrays and matrices, along with a collection of high-level mathematical functions to operate on these arrays.
+	- **Key Features**:
+		- **ndarray**: A fast and space-efficient multidimensional array providing vectorized arithmetic operations.
+		- **Broadcasting**: A powerful mechanism that allows operations on arrays of different shapes.
+		- **Vectorization**: Elimination of explicit Python loops in numerical operations, leading to C-level execution speeds.
+	- **Installation**:
+		- ```bash
+		  pip install numpy
+		  ```
+- # 🧾 **Core Concepts**
+	- **ndarray**: An N-dimensional array object where all elements must be of the same data type (`dtype`).
+	- **Vectorization**: Running element-wise calculations directly in C, which avoids the overhead of standard Python loops.
+	- **Broadcasting**: Rules specifying how operations work on arrays of different shapes (e.g., adding a scalar to an array, or multiplying a 2D array by a 1D array).
+	- **Slicing and Views**: Sub-arrays created by slicing are "views" of the original data. Modifying a view modifies the original array (no copy is made unless explicitly requested with `.copy()`).
+- # 💻 **Common Code Patterns & Cheat Sheet**
+	- **Array Creation & Properties**:
+		- ```python
+		  import numpy as np
+		  
+		  # Creation from list
+		  arr = np.array([1, 2, 3, 4])
+		  
+		  # Help helper functions
+		  zeros = np.zeros((2, 3))            # 2x3 matrix of zeros
+		  ones = np.ones((3, 3), dtype=int)   # 3x3 matrix of ones
+		  steps = np.arange(0, 10, 2)         # [0 2 4 6 8]
+		  linspace = np.linspace(0, 1, 5)     # [0. 0.25 0.5 0.75 1.]
+		  identity = np.eye(3)                # 3x3 Identity matrix
+		  ```
+	- **Indexing, Slicing & Boolean Masking**:
+		- ```python
+		  grid = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+		  
+		  # Slice: first two rows, last two columns
+		  sub_grid = grid[:2, 1:]
+		  
+		  # Boolean Masking (extremely fast filtering)
+		  mask = grid > 5
+		  filtered_vals = grid[mask]          # [6 7 8 9]
+		  ```
+	- **Vectorized Operations & Broadcasting**:
+		- ```python
+		  a = np.array([1, 2, 3])
+		  b = np.array([[10], [20], [30]])
+		  
+		  # Broadcasting: adds (3,) to (3,1) resulting in a (3,3) matrix
+		  result = a + b
+		  # [[11 12 13],
+		  #  [21 22 23],
+		  #  [31 32 33]]
+		  ```
+- # 💡 **Best Practices & Tips**
+	- **Avoid Explicit Loops**: Never loop over NumPy arrays using Python `for` loops if a vectorized alternative exists.
+	- **View vs Copy**: Be careful when slicing: `slice = arr[1:3]` does not copy memory. Use `slice = arr[1:3].copy()` if you want a new independent array.
+	- **Dtype Management**: Choose specific dtypes (like `np.int8`, `np.float32`) to save memory when working with large datasets.
+- # 🔗 **Navigation & Internal Links**
+	- **Parent**: [[Python]]
+	- **Related Notes**: [[Data Science]] | [[Machine Learning]] | [[Pandas]] | [[Matplotlib]] | [[SciPy]]

pages/Pandas.md

@@ -1,7 +1,69 @@
 ---
-seoTitle: Pandas Python Library – DataFrame Operations Reference Guide
+seoTitle: Pandas Python Library - DataFrame Operations Reference Guide
 description: "Pandas provides powerful data manipulation with DataFrames. Covers indexing, groupby, merge, pivot tables, time series, missing data handling, and I/O."
 keywords: "Pandas, Python DataFrame, groupby, merge, pivot table, time series, missing data, indexing, data manipulation, Python library, data analysis, CSV reading"
 ---
 
-- [Docs]( https://pandas.pydata.org/pandas-docs/stable/)
+- # 📘 **Overview**
+	- **What is it?**: Pandas is a fast, powerful, flexible, and easy-to-use open-source data analysis and manipulation tool built on top of the Python programming language.
+	- **Key Features**:
+		- **DataFrame**: A two-dimensional tabular data structure with labeled axes (rows and columns).
+		- **Series**: A one-dimensional labeled array capable of holding any data type.
+		- **Alignment**: Auto-alignment of data in operations based on row/column indices.
+		- **File Support**: Out-of-the-box reading and writing support for CSV, Excel, SQL databases, JSON, Parquet, and more.
+	- **Installation**:
+		- ```bash
+		  pip install pandas
+		  ```
+- # 🧾 **Core Concepts**
+	- **Series**: The basic 1D building block of Pandas.
+	- **DataFrame**: The 2D table representing data, composed of multiple Series (columns) sharing the same Index.
+	- **Indexing (`loc` vs `iloc`)**:
+		- `loc`: Label-based selection (e.g. `df.loc[0, 'column_name']`).
+		- `iloc`: Integer/Position-based selection (e.g. `df.iloc[0, 1]`).
+	- **Missing Data**: Pandas uses `NaN` (Not a Number) to represent missing values and provides native functions like `isnull()`, `dropna()`, and `fillna()`.
+- # 💻 **Common Code Patterns & Cheat Sheet**
+	- **DataFrame Creation & Loading**:
+		- ```python
+		  import pandas as pd
+		  
+		  # Load from CSV
+		  df = pd.read_csv("data.csv")
+		  
+		  # Create from dictionary
+		  data = {"Name": ["Alice", "Bob"], "Age": [25, 30]}
+		  df = pd.DataFrame(data)
+		  ```
+	- **Selection & Filtering**:
+		- ```python
+		  # Select single column
+		  ages = df["Age"]
+		  
+		  # Filter rows based on conditions
+		  adults = df[df["Age"] >= 18]
+		  
+		  # Select specific rows and columns using loc
+		  subset = df.loc[df["Age"] > 20, ["Name"]]
+		  ```
+	- **Grouping & Aggregation**:
+		- ```python
+		  # Calculate mean age by city
+		  grouped = df.groupby("City")["Age"].mean()
+		  
+		  # Perform multiple aggregations
+		  summary = df.groupby("City").agg({"Age": ["mean", "min", "max"]})
+		  ```
+	- **Data Merging & Joining**:
+		- ```python
+		  # Merge two DataFrames on a common column
+		  df1 = pd.DataFrame({"ID": [1, 2], "Val": ["A", "B"]})
+		  df2 = pd.DataFrame({"ID": [2, 3], "Score": [88, 95]})
+		  merged = pd.merge(df1, df2, on="ID", how="inner")
+		  ```
+- # 💡 **Best Practices & Tips**
+	- **Avoid `.iterrows()`**: Never iterate over rows using `.iterrows()` for numerical calculations. Instead, use vectorized operations or `.apply()` (and prefer `.apply()` only when vectorization is not possible).
+	- **SettingWithCopyWarning**: When modifying a slice, always make an explicit copy: `df_slice = df[df['Age'] > 20].copy()`.
+	- **Categorical Columns**: Convert text columns with low cardinality to `category` dtype using `df['Col'] = df['Col'].astype('category')` to save substantial memory.
+- # 🔗 **Navigation & Internal Links**
+	- **Parent**: [[Python]]
+	- **Related Notes**: [[Data Science]] | [[Machine Learning]] | [[NumPy]] | [[Matplotlib]]

pages/PyTorch.md

@@ -1,7 +1,87 @@
 ---
-seoTitle: PyTorch Python Library – Deep Learning Framework Reference Guide
+seoTitle: PyTorch Python Library - Deep Learning Framework Reference Guide
 description: "PyTorch is a dynamic deep learning framework. Covers tensors, autograd, neural networks, optimizers, DataLoader, GPU acceleration, and model training patterns."
 keywords: "PyTorch, deep learning, tensors, autograd, neural networks, optimizers, DataLoader, GPU, CUDA, model training, Python library, machine learning"
 ---
 
-- [Docs](https://pytorch.org/docs/stable/)
+- # 📘 **Overview**
+	- **What is it?**: PyTorch is an open-source machine learning library developed by Meta's AI Research lab. It is widely used for applications such as computer vision and natural language processing, due to its dynamic computation graph and Pythonic nature.
+	- **Key Features**:
+		- **Dynamic Computation Graphs**: Computations are defined dynamically at runtime (Imperative / Eager mode), allowing easy debugging and dynamic model architectures.
+		- **Tensor Computation**: Support for multi-dimensional arrays (Tensors) with strong GPU acceleration via CUDA.
+		- **Autograd Module**: Automatic differentiation engine that powers backpropagation.
+	- **Installation**:
+		- ```bash
+		  # Core CPU/GPU installation (verify CUDA version on pytorch.org)
+		  pip install torch torchvision torchaudio
+		  ```
+- # 🧾 **Core Concepts**
+	- **Tensors**: The core data structure in PyTorch, similar to NumPy's `ndarray` but capable of running on a GPU.
+	- **Autograd**: The automatic differentiation engine. By setting `requires_grad=True` on a tensor, PyTorch tracks operations on it and automatically computes gradients during the backward pass.
+	- **nn.Module**: The base class for all neural network modules. Models inherit from this class and implement the `forward` pass.
+	- **Dataset & DataLoader**: Classes to manage data parsing and batching during training.
+- # 💻 **Common Code Patterns & Cheat Sheet**
+	- **Tensor Operations & GPU Usage**:
+		- ```python
+		  import torch
+		  
+		  # Create tensor from list
+		  x = torch.tensor([[1.0, 2.0], [3.0, 4.0]], requires_grad=True)
+		  
+		  # Move to GPU if available
+		  device = "cuda" if torch.cuda.is_available() else "cpu"
+		  x = x.to(device)
+		  
+		  # Basic math
+		  y = x ** 2 + 2
+		  z = y.mean()
+		  
+		  # Backpropagation
+		  z.backward()
+		  print(x.grad)  # prints gradients of z w.r.t x
+		  ```
+	- **Defining a Neural Network**:
+		- ```python
+		  import torch.nn as nn
+		  
+		  class SimpleClassifier(nn.Module):
+		      def __init__(self, input_dim, hidden_dim, output_dim):
+		          super().__init__()
+		          self.linear1 = nn.Linear(input_dim, hidden_dim)
+		          self.relu = nn.ReLU()
+		          self.linear2 = nn.Linear(hidden_dim, output_dim)
+		          
+		      def forward(self, x):
+		          out = self.linear1(x)
+		          out = self.relu(out)
+		          out = self.linear2(out)
+		          return out
+		  ```
+	- **Training Loop Pattern**:
+		- ```python
+		  import torch.optim as optim
+		  
+		  # Instantiate model, optimizer, and loss function
+		  model = SimpleClassifier(input_dim=10, hidden_dim=20, output_dim=2).to(device)
+		  optimizer = optim.Adam(model.parameters(), lr=0.001)
+		  criterion = nn.CrossEntropyLoss()
+		  
+		  # Dummy input & target
+		  inputs = torch.randn(32, 10).to(device)
+		  targets = torch.randint(0, 2, (32,)).to(device)
+		  
+		  # Single step of training
+		  model.train()               # set to training mode
+		  optimizer.zero_grad()       # clear previous gradients
+		  outputs = model(inputs)     # forward pass
+		  loss = criterion(outputs, targets)
+		  loss.backward()             # backward pass (compute gradients)
+		  optimizer.step()            # update weights
+		  ```
+- # 💡 **Best Practices & Tips**
+	- **Inference Mode**: Always wrap validation/inference code blocks in `with torch.no_grad():` to save memory and compute.
+	- **Mode Toggling**: Toggle `model.train()` and `model.eval()` to correctly configure modules like Dropout and BatchNorm.
+	- **Gradient Zeroing**: Never forget to run `optimizer.zero_grad()` before computing gradients, otherwise gradients will accumulate.
+- # 🔗 **Navigation & Internal Links**
+	- **Parent**: [[Python]]
+	- **Related Notes**: [[Machine Learning]] | [[Data Science]] | [[NumPy]] | [[Pandas]]