https://github.com/sofiasawczenko/linear_algebra_using_python
The primary motivation behind establishing this repository was to disseminate knowledge about Linear Algebra through Python.
https://github.com/sofiasawczenko/linear_algebra_using_python
Last synced: 4 months ago
JSON representation
The primary motivation behind establishing this repository was to disseminate knowledge about Linear Algebra through Python.
- Host: GitHub
- URL: https://github.com/sofiasawczenko/linear_algebra_using_python
- Owner: sofiasawczenko
- Created: 2023-07-10T00:33:32.000Z (almost 3 years ago)
- Default Branch: main
- Last Pushed: 2024-12-18T11:32:12.000Z (over 1 year ago)
- Last Synced: 2025-09-02T04:26:24.670Z (10 months ago)
- Homepage:
- Size: 13.7 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Applied Linear Algebra in Data Analysis: A Practical Guide
The primary motivation behind establishing this repository was to disseminate knowledge about Linear Algebra through Python.
Linear algebra serves as the foundation of machine learning, providing a mathematical framework for various algorithms. For example, considering a machine learning model that classifies images of handwritten digits. Linear algebra allows us to represent each image as a matrix of pixel values, enabling manipulation of the data for processing and analysis.
Dimensionality reduction is another important aspect where linear algebra techniques shine. For instance, Principal Component Analysis (PCA) utilizes linear algebra to identify the most significant features in a high-dimensional dataset. By reducing the dimensionality while preserving the essential information, PCA enhances computational efficiency and helps avoid the curse of dimensionality.
Matrix operations play a vital role in machine learning algorithms. Suppose we have a dataset with multiple features and want to find the optimal weights for a linear regression model. By using linear algebra operations like matrix multiplication and solving systems of linear equations, we can efficiently calculate the weights that minimize the prediction errors.
Eigenvectors and eigenvalues are valuable concepts for understanding the underlying structure of data. For example, in the field of computer vision, eigenvectors and eigenvalues can be employed in techniques like Eigenfaces for face recognition. By analyzing the eigenvectors associated with the largest eigenvalues, relevant facial features can be extracted, enabling effective pattern detection and classification.
## 1. **Vectors**
Vectors represent data points, feature sets, or results in many data analysis tasks.
### Operations:
- **Vector Addition**: Combine two vectors element-wise.
```python
import numpy as np
v1 = np.array([1, 2, 3])
v2 = np.array([4, 5, 6])
result = v1 + v2 # [5, 7, 9]
print(result)
```
- **Dot Product:** Measure the similarity between two vectors.
```python
dot_product = np.dot(v1, v2) # 1*4 + 2*5 + 3*6 = 32
print(dot_product)
```
- **Norm (Magnitude):** Calculate the length of a vector.
```python
norm_v1 = np.linalg.norm(v1) # √(1^2 + 2^2 + 3^2) = √14
print(norm_v1)
```
### Application in Data Analysis:
- Feature Representation: Data points are often represented as vectors.
- Similarity Calculation: Dot product is commonly used in calculating the similarity between data points (e.g., cosine similarity).
## 2. Matrices
Matrices are used to store data and perform transformations. Each row typically represents a data point, and each column represents a feature.
### Operations:
- **Matrix Multiplication:** Multiply two matrices (e.g., dataset by weights in machine learning).
```python
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
product = np.dot(A, B) # Multiply matrices A and B
print(product)
```
- **Transpose:** Swap the rows and columns of a matrix.
```python
transpose_A = A.T # [[1, 3], [2, 4]]
print(transpose_A)
```
- **Inverse:** Solve systems of linear equations (if the matrix is invertible).
```python
A_inv = np.linalg.inv(A) # Compute the inverse of matrix A
print(A_inv)
```
### Application in Data Analysis:
- **Linear Regression:** Solve for model coefficients using matrix multiplication (normal equation).
```python
X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]]) # Feature matrix
y = np.dot(X, np.array([1, 2])) + 3 # Target variable
theta = np.linalg.inv(X.T @ X) @ X.T @ y # Normal equation solution
print(theta)
```
- **Data Transformation:** Matrices represent data transformations, like scaling or rotating data.
## 3. Eigenvalues and Eigenvectors
Eigenvalues and eigenvectors help identify the directions of maximum variance in datasets, especially in dimensionality reduction techniques.
### Operations:
- **Eigen Decomposition:** Compute eigenvalues and eigenvectors of a covariance matrix.
```python
covariance_matrix = np.cov(X.T) # Covariance matrix of features
eigenvalues, eigenvectors = np.linalg.eig(covariance_matrix)
print("Eigenvalues:", eigenvalues)
print("Eigenvectors:", eigenvectors)
```
- **Application in Data Analysis:**
Principal Component Analysis (PCA): Reducing the dimensionality of data while preserving as much variance as possible.
```python
from sklearn.decomposition import PCA
```
pca = PCA(n_components=2)
X_reduced = pca.fit_transform(X) # Reduce features to 2 components
print(X_reduced)
## 4. Singular Value Decomposition (SVD)
SVD is a matrix factorization technique commonly used in dimensionality reduction and recommendation systems.
### Operations:
SVD: Decompose a matrix into three components (U, Σ, V).
```python
U, S, Vt = np.linalg.svd(X, full_matrices=False) # Singular Value Decomposition
print("U:", U)
print("S:", S)
print("Vt:", Vt)
```
- **Application in Data Analysis:**
Latent Semantic Analysis (LSA): In text mining, SVD is used to reduce the dimensionality of term-document matrices.
```python
from sklearn.decomposition import TruncatedSVD
```
svd = TruncatedSVD(n_components=2)
reduced_matrix = svd.fit_transform(X) # Reduce the matrix using SVD
print(reduced_matrix)
## Conclusion
Linear algebra provides essential tools for manipulating, transforming, and analyzing data. From simple operations like matrix multiplication to complex methods like PCA and SVD, these concepts are widely applied in data analysis and machine learning. Understanding and using these operations enables efficient data manipulation, transformation, and feature extraction, which are central to the data science workflow.