Merge branch 'main' into feature/add-polyfill-doc

Author: DanielAsare-ux

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

@@ -0,0 +1,112 @@
+---
+Title: 'Gradient Descent'
+Description: 'Gradient Descent is an optimization algorithm that minimizes a cost function by iteratively adjusting parameters in the direction of its gradient.'
+Subjects:
+  - 'Machine Learning'
+  - 'Data Science'
+  - 'Computer Science'
+Tags:
+  - 'AI'
+  - 'Machine Learning'
+  - 'Neural Networks'
+  - 'Functions'
+CatalogContent:
+  - 'paths/data-science'
+  - 'paths/machine-learning'
+---
+
+**Gradient Descent** is an optimization algorithm commonly used in machine learning and neural networks to minimize a cost function. Its goal is to iteratively find the optimal parameters (weights) that minimize the error or loss.
+
+In neural networks, gradient descent computes the gradient (derivative) of the cost function with respect to each parameter. It then updates the parameters in the direction of the negative gradient, effectively reducing the cost with each step.
+
+## Types of Gradient Descent
+
+There are three main types of gradient descent:
+
+| Type                                  | Description                                                                                                                                                                     |
+| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Batch Gradient Descent**            | Uses the entire dataset to compute the gradient and update the weights. Typically slower but more accurate for large datasets.                                                  |
+| **Stochastic Gradient Descent (SGD)** | Uses a single sample to compute the gradient and update the weights. It is faster, but the updates are noisy and can cause fluctuations in the convergence path.                |
+| **Mini-batch Gradient Descent**       | A compromise between batch and stochastic gradient descent, using a small batch of samples to compute the gradient. It balances the speed and accuracy of the learning process. |
+
+## Gradient Descent Update Rule
+
+The basic update rule for gradient descent is:
+
+```pseudo
+theta = theta - learning_rate * gradient_of_cost_function
+```
+
+- `theta`: The parameter (weight) of the model that is being optimized.
+- `learning_rate`: A hyperparameter that controls the step size.
+- `gradient_of_cost_function`: The gradient (derivative) of the cost function with respect to the parameters, indicating the direction and magnitude of the change needed.
+
+## Syntax
+
+Here's a basic syntax for Gradient Descent in the context of machine learning, specifically for updating the model parameters (weights) in order to minimize the cost function:
+
+```pseudo
+# Initialize parameters (weights) and learning rate
+theta = initial_value  # Model Parameters (weights)
+learning_rate = value  # Learning rate (step size)
+iterations = number_of_iterations  # Number of iterations
+
+# Repeat until convergence
+for i in range(iterations):
+    # Calculate the gradient of the cost function
+    gradient = compute_gradient(X, y, theta) # Gradient calculation
+
+    # Update the parameters (weights)
+    theta = theta - learning_rate * gradient  # Update rule
+
+    # Optionally, compute and store the cost (for monitoring convergence)
+    cost = compute_cost(X, y, theta)
+    store(cost)
+```
+
+## Example
+
+In the following example, we implement simple gradient descent to minimize the cost function of a linear regression problem:
+
+```py
+import numpy as np
+
+# Sample data (X: inputs, y: actual outputs)
+X = np.array([1, 2, 3, 4, 5])
+y = np.array([1, 2, 1.3, 3.75, 2.25])
+
+# Parameters initialization
+theta = 0.0  # Initial weight
+learning_rate = 0.01  # Step size
+iterations = 1000  # Number of iterations
+
+# Cost function (Mean Squared Error)
+def compute_cost(X, y, theta):
+    m = len(y)
+    cost = (1/(2*m)) * np.sum((X*theta - y)**2) # The cost function for linear regression
+    return cost
+
+# Gradient Descent function
+def gradient_descent(X, y, theta, learning_rate, iterations):
+    m = len(y)
+    cost_history = []
+
+    for i in range(iterations):
+        gradient = (1/m) * np.sum(X * (X*theta - y))  # Derivative of cost function
+        theta = theta - learning_rate * gradient  # Update theta
+        cost_history.append(compute_cost(X, y, theta))  # Track cost
+    return theta, cost_history
+
+# Run Gradient Descent
+theta_optimal, cost_history = gradient_descent(X, y, theta, learning_rate, iterations)
+
+print(f"Optimal Theta: {theta_optimal}")
+```
+
+The output for the above code will be something like this:
+
+```shell
+Optimal Theta: 0.6390909090909086
+```
+
+> **Note**: The optimal `theta` value will be an approximation, as the gradient descent approach iteratively updates the weight to reduce the cost function.

content/plotly/concepts/graph-objects/terms/histogram2dContour/histogram2dContour.md

@@ -0,0 +1,64 @@
+---
+Title: '.Histogram2dContour()'
+Description: 'Creates 2D histograms with contours for visualizing density distributions in data.'
+Subjects:
+  - 'Data Science'
+  - 'Data Visualization'
+Tags:
+  - 'Data'
+  - 'Data Structures'
+  - 'Plotly'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+The **`.Histogram2dContour()`** method in Plotly's `graph_objects` module creates a 2D histogram with contour lines to visualize the joint distribution of two variables. It uses a grid where color intensity represents the count or aggregated values within each cell, while the contour lines indicate regions of equal density. This method helps visualize relationships and density in bivariate data, helping to uncover patterns and trends.
+
+## Syntax
+
+```pseudo
+plotly.graph_objects.Histogram2dContour(x=None, y=None, nbinsx=None, nbinsy=None, colorscale=None, contours=None, ...)
+```
+
+- `x`: Input data for the x-axis.
+- `y`: Input data for the y-axis.
+- `nbinsx` (Optional): The number of bins (intervals) used to divide the x-axis range. If not specified (`None`), Plotly automatically calculates an appropriate number of bins based on the data.
+- `nbinsy` (Optional): The number of bins (intervals) used to divide the y-axis range on the data.
+- `colorscale` (Optional): Defines the color scale for heatmap.
+- `contours` (Optional): Configuration for contour lines (e.g., `levels`, `start`, `end`, `size`).
+
+> **Note**: To personalize the scatter plot on polar axes, there are more possible options than those mentioned above, as indicated by the ellipsis in the syntax (...).
+
+## Example
+
+The following example showcases the use of the `.Histogram2dContour()`:
+
+```py
+import plotly.graph_objects as go
+
+# Sample data
+x = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
+y = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
+
+# Create the histogram with contours
+fig = go.Figure(
+  go.Histogram2dContour(
+    x=x,
+    y=y,
+    nbinsx=5,
+    nbinsy=5,
+    colorscale='Viridis',
+    contours=dict(start=0, end=4, size=1)
+  )
+)
+
+# Show the figure
+fig.show()
+```
+
+The example demonstrates how to use `.Histogram2dContour()` to create a two-dimensional histogram that includes contour lines which are used to visualize the joint distribution between two variables.
+
+The above code generates the following output:
+
+![Histogram2dContour in Plotly](https://raw.githubusercontent.com/Codecademy/docs/main/media/histogram2dcontour-example.png)

content/python/concepts/sql-connectors/terms/pyodbc/pyodbc.md

@@ -0,0 +1,108 @@
+---
+Title: 'pyodbc'
+Description: 'pyodbc is a library in Python that provides a bridge between Python applications and ODBC-compliant databases, allowing efficient database operations.'
+Subjects:
+  - 'Data Science'
+  - 'Web Development'
+  - 'Developer Tools'
+Tags:
+  - 'Database'
+  - 'SQL'
+  - 'Python'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+**`pyodbc`** is a Python library that enables Python programs to interact with databases through **ODBC (Open Database Connectivity)**, a standard API for accessing database management systems (DBMS). It provides a powerful and efficient way to execute SQL queries, retrieve results, and perform other database operations.
+
+## Installation
+
+To install `pyodbc`, `pip` can be used:
+
+```bash
+pip install pyodbc
+```
+
+## Syntax
+
+A basic connection to an ODBC database and query execution with `pyodbc` follows this structure:
+
+```pseudo
+import pyodbc
+
+# Connect to the database
+connection = pyodbc.connect("Driver={Driver_Name};"
+                            "Server=server_name;"
+                            "Database=database_name;"
+                            "UID=user_id;"
+                            "PWD=password;")
+
+# Create a cursor object
+cursor = connection.cursor()
+
+# Execute a query
+cursor.execute("SQL QUERY")
+
+# Fetch results
+rows = cursor.fetchall()
+
+# Process results
+for row in rows:
+  print(row)
+
+# Close the connection
+connection.close()
+```
+
+## Key Parameters
+
+- `Driver`: Specifies the ODBC driver to use for the connection.
+- `Server`: The database server's address or name.
+- `Database`: The name of the database to connect to.
+- `UID` and `PWD`: The username and password for authentication. They are case-sensitive in most databases.
+
+> **Note**: Connection string formats depend on the database type. Refer to [connectionstrings.com](https://www.connectionstrings.com/) for specific examples.
+
+## Example
+
+The following example demonstrates connecting to a Microsoft SQL Server, querying a table, and printing the results:
+
+```py
+import pyodbc
+
+# Define connection string
+connection_string = ("Driver={ODBC Driver 17 for SQL Server};"
+                     "Server=localhost;"
+                     "Database=TestDB;"
+                     "UID=sa;"
+                     "PWD=your_password;")
+
+try:
+  # Establish connection
+  conn = pyodbc.connect(connection_string)
+  cursor = conn.cursor()
+
+  # Execute a SQL query
+  cursor.execute("SELECT * FROM Employees")
+
+  # Fetch and print results
+  for row in cursor:
+    print(row)
+
+except pyodbc.Error as ex:
+  print("An error occurred:", ex)
+
+finally:
+  # Close the connection
+  if 'conn' in locals():
+    conn.close()
+```
+
+## Use Cases
+
+Here are some use cases for `pyodbc`:
+
+- Connecting to a variety of databases (e.g., SQL Server, MySQL, PostgreSQL) via ODBC
+- Executing dynamic SQL queries
+- Efficiently handling large datasets