Merge branch 'main' into Adding-skewX-entry

Author: mamtawardhani

bin/concept-of-the-week.txt

@@ -1 +1 @@
-content/kotlin/concepts/interfaces/interfaces.md
+content/swift/concepts/ranges/ranges.md

content/dart/concepts/map/terms/cast/cast.md

@@ -0,0 +1,58 @@
+---
+Title: '.cast()'
+Description: 'Returns a new map with the same entries but with keys and values cast to the specified types.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Dart'
+  - 'Map'
+  - 'Methods'
+CatalogContent:
+  - 'learn-dart'
+  - 'paths/computer-science'
+---
+
+In Dart, the **`.cast()`** method returns a new `Map` containing the same key–value pairs as the original map, but with the specified key and value types. The returned map performs runtime type checks when reading or writing entries. If a key or value does not match the specified types, a `TypeError` is thrown.
+
+This method is commonly used when working with dynamically typed maps that need to be treated as a map with specific types.
+
+## Syntax
+
+```pseudo
+mapVariable.cast<NewKeyType, NewValueType>()
+```
+
+`mapVariable` is the `Map` object whose entries are cast to new types.
+
+**Parameters:**
+
+- `NewKeyType`: The target key type to cast the map’s keys to.
+- `NewValueType`: The target value type to cast the map’s values to.
+
+**Return value:**
+
+Returns a new `Map<K, V>` view of the original map, where keys and values are cast to the specified types.
+
+## Example
+
+In this example, a dynamically typed map is cast to a `Map<String, int>` so its entries can be accessed with strong typing:
+
+```dart
+void main() {
+  Map<dynamic, dynamic> rawData = {
+    'Alice': 90,
+    'Bob': 85,
+  };
+
+  Map<String, int> scores = rawData.cast<String, int>();
+
+  print(scores);
+}
+```
+
+The output of this code is:
+
+```shell
+{Alice: 90, Bob: 85}
+```

content/pytorch/concepts/tensor-operations/terms/argmin/argmin.md

@@ -0,0 +1,68 @@
+---
+Title: '.argmin()'
+Description: 'Returns the index of the minimum value in a PyTorch tensor, or along a specified dimension.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Deep Learning'
+  - 'Methods'
+  - 'PyTorch'
+  - 'Tensor'
+CatalogContent:
+  - 'intro-to-py-torch-and-neural-networks'
+  - 'paths/data-science'
+---
+
+The **`.argmin()`** method in PyTorch returns the index of the minimum value in a flattened [tensor](https://www.codecademy.com/resources/docs/pytorch/tensors) tensor by default, or along a specified dimension. This method is commonly used in tasks such as finding the closest data point, selecting the best prediction, or identifying the least likely class in machine learning workflows.
+
+## Syntax
+
+```pseudo
+torch.argmin(input, dim=None, keepdim=False)
+```
+
+**Parameters:**
+
+- `input` (Tensor): The input tensor to search for the minimum value.
+- `dim` (int, optional): The dimension to reduce. If not specified, the index of the minimum value in the flattened tensor is returned.
+- `keepdim` (bool, optional): Whether the output tensor retains the reduced dimension. Defaults to `False`.
+
+**Return value:**
+
+The `.argmin()` method returns a `LongTensor` containing the index or indices of the minimum value(s). If `dim` is not specified, a scalar tensor is returned.
+
+## Example
+
+This example shows how to use the `.argmin()` method to find the index of the minimum value in a 2D tensor:
+
+```py
+import torch
+
+# Define a 2D tensor
+tensor = torch.tensor([[8, 3, 5],
+                       [2, 7, 4]])
+
+# Index of minimum in flattened tensor
+print(torch.argmin(tensor))
+
+# Index of minimum along each column (dim=0)
+print(torch.argmin(tensor, dim=0))
+
+# Index of minimum along each row (dim=1)
+print(torch.argmin(tensor, dim=1))
+```
+
+This example results in the following output:
+
+```shell
+tensor(3)
+tensor([1, 0, 1])
+tensor([1, 0])
+```
+
+In this example:
+
+- **Flattened tensor**: The tensor is treated as `[8, 3, 5, 2, 7, 4]`, and the minimum value `2` is at index `3`.
+- **Along columns (`dim=0`)**: The minimum values in each column are `2`, `3`, and `4`, found in rows `1`, `0`, and `1`.
+- **Along rows (`dim=1`)**: The minimum values in each row are `3` (at index `1`) and `2` (at index `0`).

content/pytorch/concepts/tensor-operations/terms/softmax/softmax.md

@@ -0,0 +1,97 @@
+---
+Title: '.softmax()'
+Description: 'Applies the Softmax function to an n-dimensional input Tensor, rescaling elements so they lie in the range [0, 1] and sum to 1.'
+Subjects:
+  - 'Computer Science'
+  - 'Machine Learning'
+Tags:
+  - 'Neural Networks'
+  - 'PyTorch'
+  - 'Tensor'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/machine-learning'
+---
+
+The **`.softmax()`** function applies the Softmax mathematical transformation to an input tensor. It is a critical operation in deep learning, particularly for multi-class classification tasks. Softmax converts a vector of raw scores (often called logits) into a probability distribution where each value represents the likelihood of a specific class.
+
+The Softmax function for an element $x_i$ in a vector $x$ is defined as:
+
+$$\text{Softmax}(x_{i}) = \frac{\exp(x_i)}{\sum_{j} \exp(x_j)}$$
+
+By exponentiating the inputs, the function ensures all outputs are non-negative. Dividing by the sum of these exponentials ensures that the resulting values sum to exactly 1.
+
+## Syntax
+
+```pseudo
+torch.softmax(input, dim, dtype=None)
+```
+
+**Parameters:**
+
+- `input`: The input tensor containing the raw scores (logits).
+- `dim`: A dimension along which Softmax will be computed. Every slice along the dim will sum to `1`.
+- `dtype` (Optional): The desired data type of the returned tensor.
+
+**Return value:**
+
+Returns a tensor of the same shape as `input`, with values scaled between 0 and 1.
+
+## Example 1: Basic Softmax on a 1D Tensor
+
+This example shows how to convert a simple 1D tensor of logits into probabilities:
+
+```py
+import torch
+
+# A 1D tensor of raw scores
+logits = torch.tensor([1.0, 2.0, 3.0])
+
+# Apply softmax along the only dimension (0)
+probabilities = torch.softmax(logits, dim=0)
+print("Logits:", logits)
+print("Probabilities:", probabilities)
+print("Sum of probabilities:", probabilities.sum().item())
+```
+
+Here is the output:
+
+```shell
+Logits: tensor([1., 2., 3.])
+Probabilities: tensor([0.0900, 0.2447, 0.6652])
+Sum of probabilities: 1.0
+```
+
+The function converts raw logits into probabilities where the highest input value (3.0) yields the highest probability (~0.66), and the sum of all probabilities equals `1.0`.
+
+## Example 2: Softmax on a 2D Tensor
+
+For batched inputs where rows represent samples and columns represent classes, Softmax is typically applied along the class dimension:
+
+```py
+import torch
+
+# A 2D tensor (2 samples, 3 classes)
+logits = torch.tensor([
+    [2.0, 1.0, 0.1],
+    [1.0, 3.0, 0.2]
+])
+
+# Apply softmax along the class dimension (dim=1)
+probs = torch.softmax(logits, dim=1)
+
+print("Probabilities:\n", probs)
+print("\nSum of each row:", probs.sum(dim=1))
+```
+
+Here is the output:
+
+```shell
+Probabilities:
+ tensor([[0.6590, 0.2424, 0.0986],
+        [0.1131, 0.8360, 0.0508]])
+
+Sum of each row: tensor([1.0000, 1.0000])
+```
+
+By specifying `dim=1`, the operation is applied independently to each row (sample), ensuring that the class probabilities for each individual sample sum to `1.0`.