Trying to resolve conflict

Author: aatidua

bin/concept-of-the-week.txt

@@ -1 +1 @@
-content/general/concepts/machine-code/machine-code.md
+content/typescript/concepts/interfaces/interfaces.md

content/ai/concepts/machine-learning/terms/classification/classification.md

@@ -0,0 +1,103 @@
+---
+Title: 'Classification'
+Description: 'Classification is a supervised technique in machine learning used to categorize data into predefined classes or labels.'
+Subjects:
+  - 'AI'
+  - 'Machine Learning'
+Tags:
+  - 'AI'
+  - 'Machine Learning'
+  - 'Supervised Learning'
+  - 'Unsupervised Learning'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/intermediate-machine-learning-skill-path'
+---
+
+**Classification** is a supervised technique in machine learning used to categorize data into predefined classes or labels. It involves training a model using labeled data and then using the model to predict labels for new data. Common applications include spam detection, sentiment analysis, and medical diagnosis.
+
+## Classification Process
+
+The general process for performing classification involves the following steps:
+
+```pseudo
+1. Import necessary libraries
+2. Load and preprocess the dataset
+3. Split the dataset into training and testing sets
+4. Initialize the classifier (e.g., Logistic Regression, Decision Tree, SVM).
+5. Fit the model on the training set
+6. Make predictions on the test set
+7. Evaluate the model using metrics such as accuracy, precision, recall, and F1-score
+```
+
+## Example
+
+[Python](https://www.codecademy.com/resources/docs/python) provides several libraries for performing classification, such as [Scikit-learn](https://www.codecademy.com/resources/docs/sklearn).
+
+Here is an example that demonstrates how to perform classification using Logistic Regression in Scikit-learn:
+
+```py
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score
+
+# Load the Iris dataset
+iris = load_iris()
+X = iris.data
+y = iris.target
+
+# Split the dataset into training and testing sets
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# Initialize the classifier (Logistic Regression)
+model = LogisticRegression()
+
+# Fit the model on the training set
+model.fit(X_train, y_train)
+
+# Make predictions on the test set
+y_pred = model.predict(X_test)
+
+# Evaluate the model
+accuracy = accuracy_score(y_test, y_pred)
+print(f"Accuracy: {accuracy:.2f}")
+```
+
+The above code produces the following output:
+
+```shell
+Accuracy: 1.00
+```
+
+## Codebyte Example
+
+The following codebyte example demonstrates how to perform classification using [Decision Tree](https://www.codecademy.com/resources/docs/sklearn/decision-trees) in Scikit-learn:
+
+```codebyte/python
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.metrics import accuracy_score
+
+# Load the Iris dataset
+iris = load_iris()
+X = iris.data
+y = iris.target
+
+# Split the dataset into training and testing sets
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# Define the base classifier (Decision Tree)
+model = DecisionTreeClassifier()
+
+# Fit the model on the training set
+model.fit(X_train, y_train)
+
+# Make predictions on the test set
+y_pred = model.predict(X_test)
+
+# Evaluate the model
+accuracy = accuracy_score(y_test, y_pred)
+print(f"Accuracy: {accuracy:.2f}")
+```

content/ai/concepts/neural-networks/terms/vanishing-gradient/vanishing-gradient.md

@@ -0,0 +1,114 @@
+---
+Title: 'Vanishing Gradient Problem'
+Description: 'When gradients become very small during backpropagation, slowing or halting the training process.'
+Subjects:
+  - 'AI'
+  - 'Data Science'
+Tags:
+  - 'Machine Learning'
+  - 'Deep Learning'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/computer-science'
+---
+
+The **Vanishing gradient problem** occurs when gradients shrink as they move backward through a deep neural network. This causes slow or stalled training because updates to early layers become extremely small. It often appears in neural networks that use certain activation functions, such as sigmoid or hyperbolic tangent, or when the network has many layers.
+
+## How does it occur?
+
+- **Deep Architectures**: Deeper networks have more layers that can multiply small gradient values.
+- **Sigmoid or Tanh Activations**: These functions squash input values into a narrow range, which can reduce gradient magnitude.
+- **Poor Weight Initialization**: Wrong initial weight scales can cause gradients to vanish.
+
+## How to Fix It
+
+- **Use ReLU or Related Activations**: ReLU functions help avoid squashing the gradient in early layers.
+- **Proper Initialization**: Techniques like Xavier or He initialization maintain stable gradients.
+- **Batch Normalization**: Normalizing layer inputs can stabilize gradient flow.
+- **Skip Connections**: Shortcut paths reduce the effective depth of the network.
+
+## Example: Demonstrating and Addressing the Vanishing Gradient Problem
+
+The following PyTorch example shows a simple deep network with sigmoid activation. The gradients in the earliest layers may become too small, slowing training. Switching to ReLU in the final code snippet provides a potential fix:
+
+```py
+import torch
+import torch.nn as nn
+import torch.optim as optim
+
+# Deep feedforward network with Sigmoid
+class DeepSigmoidNet(nn.Module):
+  def __init__(self):
+    super().__init__()
+    self.layers = nn.Sequential(
+      nn.Linear(100, 128),
+      nn.Sigmoid(),
+      nn.Linear(128, 128),
+      nn.Sigmoid(),
+      nn.Linear(128, 128),
+      nn.Sigmoid(),
+      nn.Linear(128, 10)
+    )
+
+  def forward(self, x):
+    return self.layers(x)
+
+# Create random data
+x = torch.randn(32, 100)  # batch of 32
+y = torch.randint(0, 10, (32,))  # target classes
+
+model = DeepSigmoidNet()
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.SGD(model.parameters(), lr=0.01)
+
+# Forward pass
+outputs = model(x)
+loss = criterion(outputs, y)
+
+# Backward pass
+loss.backward()
+
+# Check the gradient norm of the first layer
+grad_norm = model.layers[0].weight.grad.norm().item()
+print(f"Gradient norm (Sigmoid net, first layer): {grad_norm:.6f}")
+
+# Potential fix: Using ReLU
+class DeepReLUNet(nn.Module):
+  def __init__(self):
+    super().__init__()
+    self.layers = nn.Sequential(
+      nn.Linear(100, 128),
+      nn.ReLU(),
+      nn.Linear(128, 128),
+      nn.ReLU(),
+      nn.Linear(128, 128),
+      nn.ReLU(),
+      nn.Linear(128, 10)
+    )
+
+  def forward(self, x):
+    return self.layers(x)
+
+model_relu = DeepReLUNet()
+optimizer = optim.SGD(model_relu.parameters(), lr=0.01)
+
+outputs_relu = model_relu(x)
+loss_relu = criterion(outputs_relu, y)
+
+loss_relu.backward()
+grad_norm_relu = model_relu.layers[0].weight.grad.norm().item()
+print(f"Gradient norm (ReLU net, first layer): {grad_norm_relu:.6f}")
+```
+
+The above code returns the following output:
+
+```shell
+Gradient norm (Sigmoid net, first layer): 0.004324
+Gradient norm (ReLU net, first layer): 0.118170
+```
+
+1. **DeepSigmoidNet**: A fully connected network with multiple layers of sigmoid activation. The gradient often shrinks as it propagates back through each layer.
+2. **Gradient Norm**: The code checks the gradient norm of the first layer. A very small value suggests that those parameters receive negligible updates.
+3. **DeepReLUNet**: Switching to ReLU reduces the vanishing effect, which can be seen in the larger gradient norm for the first layer.
+
+Using suitable activations, initialization, or techniques like batch normalization and skip connections makes the vanishing gradient problem less severe, making training faster and more reliable.

content/c-sharp/concepts/data-types/data-types.md

@@ -24,15 +24,15 @@ Value types are data types that are built-in to C#. The available types and thei
 | --------- | ----------------------- | ------------ |
 | `bool`    | Boolean                 | 1 byte       |
 | `byte`    | Byte                    | 1 byte       |
-| `sbyte`   | Short Byte              | 1 byte       |
+| `sbyte`   | Signed Byte             | 1 byte       |
 | `char`    | Character               | 2 bytes      |
 | `decimal` | Decimal                 | 16 bytes     |
 | `double`  | Double                  | 8 bytes      |
 | `float`   | Float                   | 4 bytes      |
 | `int`     | Integer                 | 4 bytes      |
 | `uint`    | Unsigned Integer        | 4 bytes      |
 | `nint`    | Native Integer          | 4 or 8 bytes |
-| `unint`   | Unsigned Native Integer | 4 or 8 bytes |
+| `nuint`   | Unsigned Native Integer | 4 or 8 bytes |
 | `long`    | Long                    | 8 bytes      |
 | `ulong`   | Unsigned Long           | 8 bytes      |
 | `short`   | Short                   | 2 bytes      |
@@ -51,7 +51,7 @@ float heightOfGiraffe = 908.32f;
 int seaLevel = -24;
 uint year = 2023u;
 nint pagesInBook = 412;
-unint milesToNewYork = 2597;
+nuint milesToNewYork = 2597;
 long circumferenceOfEarth = 25000l;
 ulong depthOfOcean = 28000ul;
 short tableHeight = 4;