A structured learning journey covering machine learning and deep learning, from fundamental principles to advanced techniques and practical applications.
This repository is organized into four progressive levels. It combines mathematical foundations, algorithmic understanding, hands-on implementation, and experimentation to build the knowledge required to design, develop, and evaluate machine learning solutions.
- Understand the mathematical and statistical foundations of machine learning.
- Learn how to select, implement, optimize, and evaluate machine learning algorithms.
- Develop practical skills using Python and modern machine learning frameworks.
- Understand model performance, generalization, limitations, and trade-offs.
- Explore neural networks and progressively advance toward sophisticated deep learning architectures.
- Apply theoretical concepts through practical exercises, experiments, and projects.
The repository is organized into four levels:
01-ML-Foundations/
Establish a solid foundation in machine learning principles, essential algorithms, data preprocessing, feature engineering, model training, and evaluation.
02-ML-Advanced/
Explore advanced classical machine learning techniques, model optimization, ensemble methods, unsupervised learning, dimensionality reduction, and more complex modeling approaches.
03-DL-Foundations/
Learn the fundamentals of deep learning, including neural networks, backpropagation, activation functions, loss functions, optimization algorithms, and practical implementation using deep learning frameworks.
04-DL-Advanced/
Explore advanced deep learning architectures and techniques, including convolutional neural networks, sequence models, attention mechanisms, Transformers, transfer learning, and other specialized approaches.
Each level has its own README describing its learning objectives, core concepts, implementation exercises, practical projects, and recommended resources.
The repository primarily uses:
- Python for implementation and experimentation.
- NumPy for numerical computing and array operations.
- Pandas for data manipulation and analysis.
- Matplotlib for data visualization.
- Scikit-learn for classical machine learning algorithms and evaluation.
- PyTorch for deep learning and neural network implementation.
- Jupyter for interactive exploration and experimentation.
- uv for Python environment and dependency management.
- Visual Studio Code as the development environment.
Additional libraries and frameworks may be introduced when they support specific learning objectives.
MachineLearningMastery/
├── 01-ML-Foundations/
│ └── README.md
├── 02-ML-Advanced/
│ └── README.md
├── 03-DL-Foundations/
│ └── README.md
├── 04-DL-Advanced/
│ └── README.md
├── .gitignore
├── .python-version
├── pyproject.toml
├── uv.lock
└── README.md
Each level is organized independently, keeping the main README focused on the overall learning path while allowing individual topics, exercises, and projects to evolve.
- Machine Learning Specialization by Andrew Ng
- Scikit-learn User Guide
- NumPy Documentation
- Pandas Documentation
- Matplotlib Documentation
- PyTorch Tutorials
- uv Documentation
Additional books, research papers, courses, and implementation references will be included at the relevant learning levels.
The objective is not merely to learn how to use machine learning libraries. It is to understand the underlying principles, the assumptions behind different approaches, why particular algorithms work, and how to evaluate their performance and limitations.
The learning path follows four principles:
- Understand before implementing. Build conceptual and mathematical understanding before relying on library abstractions.
- Implement and experiment. Translate theory into working code and investigate how algorithms behave under different conditions.
- Evaluate critically. Analyze model quality, generalization, computational costs, and trade-offs.
- Progress systematically. Build on previous knowledge, moving from classical machine learning to advanced deep learning techniques.
Understand the theory. Implement the algorithms. Experiment with the models. Master the complexity.