Linear Algebra for Deep Learning

# Scalars in Python
import numpy as np

temperature = 25.5
learning_rate = 0.01
num_epochs = 100

print(f"Temperature: {temperature}")
print(f"Learning rate: {learning_rate}")
print(f"Number of epochs: {num_epochs}")

# Scalars are 0-dimensional arrays in NumPy
scalar_array = np.array(42)
print(f"Scalar as NumPy array: {scalar_array}")
print(f"Shape: {scalar_array.shape}")  # Output: ()
print(f"Dimensions: {scalar_array.ndim}")  # Output: 0

import numpy as np

# Creating matrices
A = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])
print(f"Matrix A:\n{A}")
print(f"Shape: {A.shape}")  # Output: (3, 3)
print(f"Dimensions: {A.ndim}")  # Output: 2

# Accessing elements
print(f"Element A[0,0]: {A[0,0]}")  # Upper left
print(f"Element A[2,2]: {A[2,2]}")  # Bottom right
print(f"Element A[1,2]: {A[1,2]}")  # Row 2, Column 3

# Accessing rows and columns
print(f"First row A[0,:]: {A[0,:]}")
print(f"Second column A[:,1]: {A[:,1]}")

# Matrix properties
m, n = A.shape
print(f"Number of rows (m): {m}")
print(f"Number of columns (n): {n}")

# Different sized matrix
B = np.array([[1, 2],
              [3, 4],
              [5, 6]])
print(f"Matrix B (3x2):\n{B}")
print(f"B shape: {B.shape}")

# Random matrix
C = np.random.randn(2, 4)  # 2x4 matrix with random values
print(f"Random matrix C:\n{C}")
print(f"C shape: {C.shape}")

import numpy as np

# Matrix transpose
A = np.array([[1, 2, 3],
              [4, 5, 6]])
print(f"Original matrix A:\n{A}")
print(f"A shape: {A.shape}")  # (2, 3)

# Transpose using .T attribute
A_T = A.T
print(f"Transpose A.T:\n{A_T}")
print(f"A.T shape: {A_T.shape}")  # (3, 2)

# Transpose using transpose() method
A_transpose = A.transpose()
print(f"Using transpose() method:\n{A_transpose}")

# Vector transpose
x = np.array([1, 2, 3])  # 1D array
print(f"Vector x: {x}")
print(f"x shape: {x.shape}")  # (3,)

# To get proper row/column vector behavior, use 2D arrays
x_col = x.reshape(-1, 1)  # Column vector
x_row = x.reshape(1, -1)  # Row vector

print(f"Column vector:\n{x_col}")
print(f"Column shape: {x_col.shape}")  # (3, 1)

print(f"Row vector:\n{x_row}")
print(f"Row shape: {x_row.shape}")  # (1, 3)

# Transpose of column vector gives row vector
x_col_T = x_col.T
print(f"Transpose of column vector:\n{x_col_T}")
print(f"Shape: {x_col_T.shape}")  # (1, 3)

# Scalar transpose (scalars are unchanged)
scalar = np.array(42)
print(f"Scalar: {scalar}")
print(f"Scalar transpose: {scalar.T}")  # Same value

import numpy as np

# Vector for norm examples
x = np.array([3, 4, 5])
print(f"Vector x: {x}")

# L2 norm (Euclidean norm)
l2_norm = np.linalg.norm(x)  # Default is L2
l2_norm_manual = np.sqrt(np.sum(x**2))
print(f"L2 norm: {l2_norm}")
print(f"L2 norm (manual): {l2_norm_manual}")

# L1 norm
l1_norm = np.linalg.norm(x, ord=1)
l1_norm_manual = np.sum(np.abs(x))
print(f"L1 norm: {l1_norm}")
print(f"L1 norm (manual): {l1_norm_manual}")

# L-infinity norm (max norm)
linf_norm = np.linalg.norm(x, ord=np.inf)
linf_norm_manual = np.max(np.abs(x))
print(f"L-infinity norm: {linf_norm}")
print(f"L-infinity norm (manual): {linf_norm_manual}")

# Squared L2 norm
squared_l2 = np.dot(x, x)  # x^T x
print(f"Squared L2 norm: {squared_l2}")

# Unit vector (normalized)
x_unit = x / np.linalg.norm(x)
print(f"Unit vector: {x_unit}")
print(f"Unit vector norm: {np.linalg.norm(x_unit)}")

# Matrix norms
A = np.array([[1, 2],
              [3, 4]])

# Frobenius norm
frobenius_norm = np.linalg.norm(A, 'fro')
frobenius_manual = np.sqrt(np.sum(A**2))
print(f"Frobenius norm: {frobenius_norm}")
print(f"Frobenius norm (manual): {frobenius_manual}")

# Different p-norms
for p in [1, 2, 3, np.inf]:
    norm_p = np.linalg.norm(x, ord=p)
    print(f"L{p} norm: {norm_p}")

# Relationship between dot product and norms
y = np.array([1, 2, 3])
dot_product = np.dot(x, y)
norms_product = np.linalg.norm(x) * np.linalg.norm(y)
cos_theta = dot_product / norms_product
print(f"Cosine of angle between x and y: {cos_theta}")

# Distance between vectors
distance = np.linalg.norm(x - y)
print(f"Euclidean distance between x and y: {distance}")