Applied Deep Learning & Prompt Engineering Program

Hands-on Python, deep neural networks and prompt engineering in code

Duration	60 contact hours over 8 weeks (2 months)
Weekly load	7.5 hours: two 3-hour live coding sessions and one 90-minute lab clinic
Format	Live, instructor-led, online (Zoom or Microsoft Teams)
Focus	Participants write the code themselves: from Python to deep neural networks and LLM applications
Lead trainer	Dr Fahad Rahman, PhD Computer Science (Université Paris Cité)
Version	September 2026

1. Program overview

The Applied Deep Learning & Prompt Engineering Program is a practical coding course. Over eight weeks participants go from Python and data handling, through machine learning, to building, training and deploying deep neural networks (DNNs) in PyTorch. They then learn prompt engineering in code: calling large language models (LLMs) from Python and building reliable LLM applications.

Participants write code in every session. Each week ends with a working coding deliverable, and the course closes with a capstone: an end-to-end DNN project with an LLM-powered feature, which each participant builds, publishes on GitHub and demonstrates live.

At a glance

Live sessions	16 sessions of 3 hours (48 hours)
Lab clinics	8 clinics of 90 minutes (12 hours)
Recommended cohort	12 to 20 participants
Level	Basic Python; no prior machine-learning experience needed
Prerequisites	Basic Python (variables, loops, functions) and school-level algebra
Language of code	Python 3
Outside sessions	About 3 hours a week finishing coding exercises

2. Learning objectives

On completing the program, participants will be able to:

Write clean Python to load, clean, explore and visualise data.
Build, evaluate and tune machine-learning models with scikit-learn.
Explain and code a neural network from scratch, including backpropagation.
Build and train deep neural networks in PyTorch.
Diagnose and fix overfitting, and tune a DNN systematically.
Apply CNNs, sequence models and pre-trained Transformers to real problems.
Use prompt engineering in Python: templates, few-shot prompts, structured output and tool calling.
Build and test a retrieval-augmented (RAG) LLM application.
Deploy a trained model and an LLM app behind an API with a simple web demo.

3. Target audience

The program is for professionals who want to build AI models themselves, not only use AI tools:

Software developers and engineers moving into AI
Data analysts and business-intelligence staff
IT, engineering and technical staff
Graduates and professionals preparing for machine-learning roles

Participants are expected to know basic Python. Week 1 is a fast refresher focused on the Python used in machine learning, so everyone starts week 2 at the same level.

4. Delivery approach and hours

Every session follows the same pattern: the trainer explains a concept and codes it live, then participants write their own version with the trainer checking and helping. The weekly lab clinic is for debugging, code review and extra practice.

Component	Hours	How it runs
Concepts and live coding demonstrations	28	1 h 45 min of each live session
Hands-on coding exercises	20	1 h 15 min of each live session
Lab clinics	12	90 minutes every week
Total contact hours	60	8 weeks × 7.5 hours

Proposed weekly schedule

Times are a proposal and can be adjusted to the client’s preference. A noon Eastern start allows both US coasts to attend live.

Day	Eastern (ET)	Central (CT)	Pacific (PT)
Tuesday: live session	12:00–3:00 p.m.	11:00 a.m.–2:00 p.m.	9:00 a.m.–12:00 p.m.
Thursday: live session	12:00–3:00 p.m.	11:00 a.m.–2:00 p.m.	9:00 a.m.–12:00 p.m.
Friday: lab clinic	12:00–1:30 p.m.	11:00 a.m.–12:30 p.m.	9:00–10:30 a.m.

All sessions are recorded for participants who miss a session.

5. Detailed curriculum

Sixteen live sessions in order, two per week, each week ending with a coding deliverable.

Week 1: Python for data and AI

Hours 1–7.5

S1 Python for machine learning: a fast refresher

Jupyter, Google Colab and virtual environments
Functions, classes and modules as used in ML code
NumPy arrays, vectorised operations and broadcasting

S2 Pandas and data visualisation

DataFrames: loading, filtering, grouping and joining
Cleaning real data and handling missing values
Exploring data with Matplotlib and Seaborn

Coding deliverable: A notebook that loads, cleans, explores and charts a real dataset

Week 2: Machine-learning foundations

Hours 8–15

S3 The machine-learning workflow in scikit-learn

Train, validation and test splits
Linear and logistic regression, coded end to end
Making and checking predictions

S4 Tree models, evaluation and tuning

Decision trees, random forests and XGBoost
Accuracy, precision, recall, F1 and ROC-AUC
Cross-validation, grid search and pipelines

Coding deliverable: A tuned classifier with a written evaluation of its results

Week 3: Neural networks from scratch

Hours 16–22.5

S5 The neuron and the forward pass

Perceptrons, weights and biases
Activation functions: sigmoid, tanh, ReLU
A forward pass written in NumPy

S6 How networks learn

Loss functions and gradient descent
Backpropagation, coded by hand
Training loop, epochs and mini-batches

Coding deliverable: A two-layer neural network written in NumPy and trained on real data

Week 4: Deep neural networks in PyTorch

Hours 23–30

S7 PyTorch fundamentals

Tensors, autograd and GPU basics
nn.Module, datasets and data loaders
Writing a full training and evaluation loop

S8 Building deep neural networks (DNNs)

Stacking layers: depth, width and initialisation
Batch normalisation and dropout
Optimisers: SGD, momentum and Adam

Coding deliverable: A multi-layer DNN built in PyTorch for an image or tabular dataset

Week 5: Training DNNs well

Hours 31–37.5

S9 Getting a DNN to generalise

Diagnosing overfitting and underfitting
Regularisation, early stopping and data augmentation
Learning-rate schedules

S10 Tuning and managing experiments

Hyperparameter search
Tracking runs and comparing results
Saving, loading and reproducing models

Coding deliverable: A tuned DNN with a log of experiments showing what improved it

Week 6: Specialised deep architectures

Hours 38–45

S11 Convolutional neural networks (CNNs)

Convolutions, pooling and feature maps
Building a CNN for image classification
Transfer learning with pre-trained models (ResNet)

S12 Sequence models and Transformers

RNNs and LSTMs for sequences and text
Attention and the Transformer, explained in code
Using pre-trained models with Hugging Face

Coding deliverable: An image classifier built with transfer learning

Week 7: Prompt engineering in code

Hours 46–52.5

S13 Prompt engineering with LLM APIs

Calling large language models from Python (OpenAI and Anthropic SDKs)
System prompts, prompt templates, zero-shot and few-shot prompting
Step-by-step reasoning prompts, temperature and structured JSON output
Prompting AI coding assistants to write, explain and test code

S14 Building LLM applications

Tool (function) calling: letting the model use your Python functions
Retrieval-augmented generation (RAG) with embeddings and a vector store
Testing prompts automatically and comparing versions
Cost control, safety and defending against prompt injection

Coding deliverable: A Python LLM application: a RAG assistant with tested prompts and structured output

Week 8: Deployment and capstone

Hours 53–60

S15 Putting models into use

Exporting a trained DNN
Serving the DNN and the LLM app with FastAPI
A simple web demo with Streamlit

S16 Capstone demo day

Each participant presents a working project
Code review and feedback
Certificates awarded

Coding deliverable: Capstone: an end-to-end DNN project with an LLM-powered feature, code on GitHub and a live demo

Weekly lab clinic

Every week, 90 minutes of supervised coding: debugging help, code review of that week’s deliverable, and two streams: Core (step-by-step support on the week’s exercises) and Advanced (extra challenges for participants who finish early).

6. Capstone project

Each participant chooses a problem and dataset in week 5 (from their own work where possible) and builds the capstone through weeks 6 to 8. A capstone includes:

A cleaned dataset and a short description of the problem
A deep neural network built and trained in PyTorch
An LLM-powered feature using the prompt engineering methods of week 7 (for example, explaining predictions in plain English or answering questions about the data)
A comparison with a simpler baseline model, with evaluation metrics
The model and LLM feature served through an API with a Streamlit demo
Clean, documented code in a GitHub repository
A 10-minute live demonstration on demo day

7. Assessment and certification

Component	Weight
Weekly coding deliverables (weeks 1–7)	40%
Capstone project, code and demonstration	50%
Participation and code reviews	10%
Total	100%

A Certificate of Completion stating 60 contact hours is awarded to participants who:

Attend at least 48 of the 60 hours (80%)
Achieve an overall score of 70% or more
Submit a working capstone and present it on demo day

8. Tools, materials and requirements

Tools used

Python 3, Jupyter notebooks, Google Colab (free GPU), NumPy, Pandas, Matplotlib, scikit-learn, XGBoost, PyTorch, Hugging Face Transformers, the OpenAI and Anthropic Python SDKs, a vector store (Chroma), FastAPI, Streamlit and GitHub. All are free and open source except the LLM APIs, which charge by use.

Each participant receives

All session notebooks and starter code
Recordings of all 16 sessions
Exercise solutions after each deadline
Their own GitHub portfolio of weekly deliverables and the capstone

The client organization receives

A coding skills check at the start and at the end of the program
Attendance and progress reports at the mid-point and at the end
A summary of capstone projects

Participant requirements

A laptop (Windows, macOS or Linux) with a stable internet connection, camera and microphone
A free Google account (for Colab) and a free GitHub account
An API key for one LLM provider for weeks 7 and 8 (provided by the client, or pay-as-you-go; a small budget per participant covers the exercises)
Zoom or Microsoft Teams