Build Working AI Systems Using Python, from Data to LLMs
A hands-on introduction to machine learning, neural networks, and LLM APIs for technical professionals ready to apply AI practically.
This course takes you from Python data fundamentals through classical machine learning, deep learning, natural language processing, and real API calls to large language models. By the end, you'll have trained classifiers and regression models, clustered unlabeled data, classified images and text, and shipped a complete end-to-end AI project. Every concept is paired with a lab you run yourself using the same tools professionals use.
Have a coupon code? Redeem it here
What you'll gain
You'll train, evaluate, and tune real machine learning models using scikit-learn — including classifiers, regression models, and clustering algorithms — on actual datasets, not toy examples.
The course connects foundational Python tools like NumPy and pandas to neural networks, computer vision, NLP, and LLM APIs, so you can see how each layer builds on the last.
You'll practice prompt engineering and write Python scripts that send requests to a live LLM API, giving you hands-on experience with the tools driving modern AI applications.
Who this course is for
You're comfortable writing Python but have had limited exposure to machine learning libraries or applied AI workflows. This course gives you practical experience with the full ML pipeline — from data preparation through model evaluation — using industry-standard tools.
You write production code but haven't worked with NumPy, pandas, or scikit-learn in a structured way. You'll gain the data handling skills and modeling fundamentals needed to contribute to AI-adjacent projects on your team.
You work with data regularly but use tools like Excel or SQL rather than Python-based ML libraries. This course will give you the vocabulary and hands-on skills to build and interpret your own predictive models.
What you'll learn
The course opens by grounding you in how AI systems actually work and setting up a functional Python environment with the core libraries. From there, modules on NumPy, pandas, and data preparation give you the foundation every ML workflow depends on. The middle section moves through supervised learning — classification and regression — then unsupervised methods, neural networks, and deep learning basics, each module building on the one before it. The course closes with natural language processing, large language models, prompt engineering, and a final project where you design and build a complete AI solution from scratch.
Module 1
Introduction to Artificial Intelligence
3 lessons
▾
Module 2
Python Foundations for AI
3 lessons
▾
Module 3
Understanding Data for AI
3 lessons
▾
Module 4
Machine Learning Fundamentals
3 lessons
▾
Module 5
Classification with scikit-learn
3 lessons
▾
Module 6
Regression and Model Evaluation
3 lessons
▾
Module 7
Unsupervised Learning
3 lessons
▾
Module 8
Introduction to Neural Networks
3 lessons
▾
Module 9
Deep Learning and Computer Vision Basics
3 lessons
▾
Module 10
Natural Language Processing Basics
3 lessons
▾
Module 11
Large Language Models and Prompt Engineering
3 lessons
▾
Module 12
AI Ethics, Limitations, and Final Project
3 lessons
▾
Learn by doing
Each module is paired with one or more hands-on labs you run in your own Python environment using tools including NumPy, pandas, scikit-learn, Matplotlib, and live LLM APIs. Labs are structured around real tasks — cleaning messy CSVs, tuning hyperparameters with GridSearchCV, reducing dimensions with PCA, and calling an LLM from a Python script — so the skills transfer directly to real work.
- Verify Python and the core AI libraries (NumPy, pandas, scikit-learn, Matplotlib) are installed and importable
- Write and run a first Python script that prints library versions and a simple NumPy array
- Load a built-in scikit-learn dataset with pandas and inspect its shape, columns, and summary statistics
- Use Matplotlib to create a simple plot visualizing one feature of the dataset
- Create, index, and reshape NumPy arrays to prepare numeric data for analysis
- Use vectorized operations to compute summary statistics without explicit loops
- Load a CSV dataset, then identify and handle missing or malformed values
- Use pandas grouping and aggregation to answer a question about the dataset, then visualize the result with Matplotlib
- Split a dataset into training and test sets using scikit-learn's train_test_split
- Scale numeric features and encode a categorical column so the dataset is model-ready
- Analyze a dataset for class imbalance or skewed feature distributions using pandas and Matplotlib
- Document how the imbalance could affect a trained model's predictions
- Train a simple scikit-learn classifier on a prepared dataset and generate predictions
- Evaluate the model's accuracy on a held-out test set
- Generate a confusion matrix and classification report for a trained model
- Use cross-validation to assess how consistent the model's performance is across folds
- Train and compare a Decision Tree and a K-Nearest Neighbors classifier on the same dataset
- Determine which classifier performs better and explain why using evaluation metrics
- Use scikit-learn's GridSearchCV to tune hyperparameters for a classifier
- Compare the tuned model's performance against the untuned baseline
- Train a linear regression model to predict a continuous target variable
- Evaluate the model using RMSE and R-squared, and plot predicted vs actual values
- Apply polynomial features or regularization to improve an underperforming regression model
- Compare the improved model's evaluation metrics against the original baseline
- Apply K-Means clustering to an unlabeled dataset and visualize the resulting clusters
- Use the elbow method to choose an appropriate number of clusters
- Apply PCA to reduce a high-dimensional dataset to two components
- Visualize the reduced dataset and describe what variance is preserved
- Implement a minimal single-layer neural network in plain Python and NumPy that performs forward propagation
- Manually compute and print the network's output for a small set of sample inputs
- Train an MLPClassifier on a classification dataset and plot its training loss curve
- Compare the neural network's accuracy against a simpler model from Module 5
- Load a small image dataset as NumPy arrays and visualize sample images with Matplotlib
- Apply basic preprocessing (grayscale conversion, normalization) to prepare images for a model
- Train a simple classifier (e.g. MLPClassifier or KNN) on a small image dataset such as digits
- Evaluate classification accuracy and visualize several correct and incorrect predictions
- Tokenize and clean a small text dataset, then convert it into a TF-IDF feature matrix
- Identify the most significant terms in the dataset using the TF-IDF scores
- Train a text classifier on labeled text data (e.g. movie or product reviews) using TF-IDF features
- Evaluate the classifier's accuracy and test it on new example sentences
- Write and compare zero-shot vs few-shot prompts for the same task, documenting how the output changes
- Refine a prompt through at least three iterations to improve output quality and consistency
- Write a Python script that sends a prompt to an LLM API and prints the response
- Extend the script to hold a short multi-turn conversation by passing prior messages back in as context
- Design and build an end-to-end AI project of your choosing (classification, regression, clustering, or text-based) using the tools and workflow learned in this course
- Evaluate your model's performance and document its limitations and potential improvements
Destin Learning
Destin Learning creates practical, project-driven courses for developers, IT professionals, and tech enthusiasts who want to build real skills — not just pass a certification exam.
Every course is built around hands-on labs, working code, and real-world tools. Our students learn by doing: writing programs, configuring systems, and solving problems in environments that mirror what they'll encounter on the job.
Our courses cover systems programming, Linux administration, cloud infrastructure, AI and machine learning, and foundational computer science — all taught with the same philosophy: understand it deeply, build it yourself, and know why it works.
Destin Learning · destinlearning.com
Start Building AI Systems Today
Contact us for pricing and enroll at your own pace with full access to all 12 modules and 23 hands-on labs.
Have a coupon code? Redeem it here