Merge branch 'main' into add-cpp-end-term

Author: dejongbaba

content/pandas/concepts/groupby/terms/size/size.md

@@ -0,0 +1,116 @@
+---
+Title: 'size()'
+Description: 'Returns a Series containing the size (row count) of each group.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Data Structures'
+  - 'Pandas'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+The **`size()`** method in pandas returns the number of rows or elements in each group created by the `groupby()` [function](https://www.codecademy.com/resources/docs/pandas/built-in-functions). It provides a quick way to determine group sizes without applying an aggregation function.
+
+## Syntax
+
+```pseudo
+DataFrameGroupBy.size()
+```
+
+**Parameters:**
+
+The `size()` method doesn't take any parameters.
+
+**Return value:**
+
+The `size()` method returns a Series containing the size (row count) of each group created by `groupby()`.
+
+## Example 1: Counting Rows by Group
+
+In this example, a [DataFrame](https://www.codecademy.com/resources/docs/pandas/dataframe) of employees is grouped by their department, and `size()` counts how many employees belong to each department:
+
+```py
+import pandas as pd
+
+data = {
+    'Department': ['HR', 'IT', 'HR', 'Finance', 'IT', 'Finance'],
+    'Employee': ['John', 'Sara', 'Mike', 'Anna', 'Tom', 'Chris']
+}
+df = pd.DataFrame(data)
+
+group_sizes = df.groupby('Department').size()
+print(group_sizes)
+```
+
+The output of this code is:
+
+```shell
+Department
+Finance    2
+HR         2
+IT         2
+dtype: int64
+```
+
+## Example 2: Using Multiple Grouping Columns
+
+In this example, `size()` counts the number of members in each combination of team and shift within a dataset:
+
+```py
+import pandas as pd
+
+data = {
+    'Team': ['A', 'A', 'B', 'B', 'B', 'C'],
+    'Shift': ['Day', 'Night', 'Day', 'Night', 'Day', 'Day'],
+    'Name': ['John', 'Sara', 'Mike', 'Anna', 'Tom', 'Chris']
+}
+df = pd.DataFrame(data)
+
+group_sizes = df.groupby(['Team', 'Shift']).size()
+print(group_sizes)
+```
+
+The output of this code is:
+
+```shell
+Team  Shift
+A     Day      1
+      Night    1
+B     Day      2
+      Night    1
+C     Day      1
+dtype: int64
+```
+
+## Codebyte Example: Counting Transactions Per Product
+
+In this example, `size()` is used to count how many sales transactions occurred for each product in a store dataset:
+
+```codebyte/python
+import pandas as pd
+
+sales = pd.DataFrame({
+  'Product': ['Apple', 'Banana', 'Apple', 'Orange', 'Banana', 'Banana', 'Apple'],
+  'Customer': ['A', 'B', 'C', 'A', 'D', 'E', 'F']
+})
+
+counts = sales.groupby('Product').size()
+print(counts)
+```
+
+## Frequently Asked Questions
+
+### 1. What is the pandas `groupby().size()` method?
+
+`groupby().size()` returns the number of rows in each group created by `groupby()`.
+
+### 2. What is the purpose of `groupby()` in pandas?
+
+`groupby()` splits data into groups based on selected column values to enable aggregation and summarization.
+
+### 3. What does `NaN` stand for in pandas?
+
+`NaN` stands for Not a Number and indicates missing or undefined data.

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

@@ -0,0 +1,78 @@
+---
+Title: '.log2()'
+Description: 'Computes the base-2 logarithm of each element in the input tensor and returns a new tensor with the results.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Elements'
+  - 'Methods'
+  - 'PyTorch'
+  - 'Tensors'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+The **`.log2()`** method in PyTorch returns a new [tensor](https://www.codecademy.com/resources/docs/pytorch/tensors) by computing the logarithm base 2 of each element in the input tensor. This operation is useful in numerous data-science and machine-learning workflows where values are interpreted on a log scale (e.g., information theory, binary magnitude comparisons).
+
+## Syntax
+
+```pseudo
+torch.log2(input, *, out=None) → Tensor
+```
+
+**Parameters:**
+
+- `input` (Tensor): The tensor whose elements are to be transformed by base-2 logarithm.
+- `out` (Tensor, optional): A tensor to store the output; must have the same shape as input if provided.
+
+**Return value:**
+
+Returns a new tensor of the same shape as `input` where each element is `log₂(input[i])`.
+
+## Example 1: Basic Usage of `.log2()`
+
+In this example, the base-2 logarithm is computed for a tensor containing powers of 2:
+
+```py
+import torch
+
+# Define a tensor
+input_tensor = torch.tensor([2.0, 4.0, 8.0, 16.0, 32.0])
+
+# Compute base-2 logarithm
+output_tensor = torch.log2(input_tensor)
+
+print(output_tensor)
+```
+
+The output of this code is:
+
+```shell
+tensor([1., 2., 3., 4., 5.])
+```
+
+## Example 2: Applying `.log2()` on Random Values
+
+In this example, a tensor with random positive values is transformed using base-2 logarithm to analyze data on a log scale:
+
+```py
+import torch
+
+# Generate a tensor of random positive values
+data = torch.rand(5) * 10 + 1
+
+# Apply log2 transformation
+log_tensor = torch.log2(data)
+
+print(data)
+print(log_tensor)
+```
+
+The output of this code is:
+
+```shell
+tensor([10.5500,  9.2777, 10.9371,  1.3551,  5.2609])
+tensor([3.3992, 3.2138, 3.4512, 0.4384, 2.3953])
+```

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

@@ -0,0 +1,81 @@
+---
+Title: '.logaddexp()'
+Description: 'Computes the element-wise logarithm of the sum of exponentials of two input tensors.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Elements'
+  - 'Methods'
+  - 'PyTorch'
+  - 'Tensors'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+The **`.logaddexp()`** function in PyTorch computes the element-wise logarithm of the sum of exponentials of two input [tensors](https://www.codecademy.com/resources/docs/pytorch/tensors). If the tensors are `x` and `y`, the mathematical formula will be:
+
+$$\log(\exp(x) + \exp(y))$$
+
+This operation is particularly useful for combining log-space values (such as log-probabilities) in a numerically stable way.
+
+## Syntax
+
+```pseudo
+torch.logaddexp(input, other, *, out=None) → Tensor
+```
+
+**Parameters:**
+
+- `input` (Tensor): The first input tensor.
+- `other` (Tensor): The second input tensor, broadcastable to the shape of `input`.
+- `out` (Tensor, optional): A tensor to store the output; must have the same shape as the broadcasted result if provided.
+
+**Return value:**
+
+Returns a new tensor of the same shape as the broadcasted `input` and `other`, where each element is:
+
+$$\log\left(\exp(\text{input}[i]) + \exp(\text{other}[i])\right)$$
+
+## Example 1: Combining Log-Probabilities
+
+In this example, two tensors representing log-probabilities are combined using `.logaddexp()`:
+
+```py
+import torch
+
+x = torch.tensor([ -0.5,  -1.2,  -3.0 ])
+y = torch.tensor([ -0.2,  -0.8,  -4.5 ])
+
+result = torch.logaddexp(x, y)
+print(result)
+```
+
+The output of this code is:
+
+```shell
+tensor([ 0.3544, -0.2870, -2.7986])
+```
+
+## Example 2: Broadcasting Two Tensors of Different Shapes
+
+In this example, a tensor and a scalar are combined with broadcasting using `.logaddexp()`:
+
+```py
+import torch
+
+x = torch.tensor([[ 1.0, 2.0 ,3.0],
+                  [ 4.0, 5.0 ,6.0]])
+y = torch.tensor( 2.0 )
+
+result = torch.logaddexp(x, y)
+print(result)
+```
+
+The output of this code is:
+
+```shell
+tensor([[2.3133, 2.6931, 3.3133],
+        [4.1269, 5.0486, 6.0181]])
+```