AI Education

How Diffusion Models Work provides a technical and practical introduction to diffusion models, one of the fundamental generative AI architectures used for image generation. The course moves beyond using pre-trained models and APIs by developing a diffusion model from its underlying principles, including the forward diffusion process, noise prediction, iterative denoising, conditioning, and accelerated sampling.

The central idea is to learn how data can be progressively transformed into noise and how a neural network can learn to reverse this process. During training, noise is added to images at different timesteps and a neural network is trained to predict that noise. During generation, the process starts from random noise and repeatedly applies the trained model to progressively construct a new image.

A U-Net architecture provides the neural network used for noise prediction. The course demonstrates how timestep information and contextual information can be incorporated into the network, allowing the diffusion process to become conditional and therefore control what type of image is generated.

The course also examines the computational cost of iterative diffusion. Standard diffusion sampling may require many denoising steps, while Denoising Diffusion Implicit Models (DDIM) provide a more efficient sampling strategy that can substantially reduce the number of steps required to generate an image.

Overall, the course provides an understanding of diffusion models from the perspective of both their mathematical process and their implementation. By constructing and training the model rather than simply using an existing image-generation service, the course provides a technical foundation for understanding how contemporary diffusion-based generative image systems operate. (?deeplearning.ai)

Course topics

Intuition

The introductory section develops the intuition behind forward and reverse diffusion. Training images are progressively corrupted by adding Gaussian noise over a sequence of timesteps. The generative process reverses this concept: starting from random noise, a trained neural network progressively predicts and removes noise until a structured image emerges.

Sampling

Sampling demonstrates how a trained diffusion model generates new images. Starting from random noise, the model repeatedly predicts the noise present at each timestep and progressively denoises the sample. This iterative process transforms an initially random distribution into images following the distribution learned from the training data.

Neural Network

The course introduces a U-Net as the neural network architecture responsible for predicting noise. The network processes noisy images together with information about the current diffusion timestep, learning representations at multiple spatial resolutions and using them to estimate the noise that should be removed.

Training

The training section demonstrates how a diffusion model learns the reverse diffusion process. Clean training images are sampled at different timesteps, appropriate levels of noise are added, and the neural network learns to predict the introduced noise. By repeating this process across the dataset and diffusion timesteps, the network learns how to progressively recover image structure from noisy inputs.

Controlling

The diffusion model is extended with context or conditioning, allowing the generation process to be controlled. Contextual information is provided alongside the noisy image and timestep, enabling the network to generate images belonging to selected categories rather than producing entirely uncontrolled samples.

Speeding Up

The final technical section introduces DDIM sampling as a more efficient alternative to the standard diffusion sampling process. By reducing the number of denoising steps required during inference, DDIM can substantially accelerate image generation while maintaining useful output quality.

Topics and techniques

• Diffusion Models – generative modelling through progressive noise addition and removal.
• Forward and Reverse Diffusion – transforming images into noise and reconstructing data from noise.
• Noise Prediction – training neural networks to estimate the noise contained in an image.
• U-Net Architecture – multi-resolution neural network for diffusion-based image generation.
• Sampling – iteratively generating images from random noise.
• Conditioning – controlling generated output through contextual information.
• DDIM – accelerating the iterative sampling process.

Practical exercises

The practical exercises use Python and Jupyter notebooks to build and experiment with a diffusion model rather than relying on a pre-trained image-generation API. The labs progressively cover sampling, training, neural-network-based noise prediction, contextual conditioning, and accelerated generation. 

The implementation generates small 16×16 image sprites, providing a computationally manageable environment in which the complete diffusion process can be examined. The exercises train a U-Net to predict noise, use the resulting model to iteratively generate new images, introduce contextual information to control the generated content, and finally implement DDIM sampling to significantly reduce generation time. 

Together, the exercises provide an end-to-end implementation of the diffusion workflow—from adding noise to training data and training the noise-prediction network to generating controlled images from random noise and optimizing the sampling process.

Convolutional Neural Networks provides a technical and practical understanding of computer vision and Convolutional Neural Networks (CNNs). As the fourth course in the Deep Learning Specialization, it builds on the foundations of deep neural networks and focuses on architectures specifically designed to process images and other spatial data.

The course begins with the fundamental operations behind CNNs, including convolution, filters, padding, stride, and pooling. These techniques enable neural networks to identify local visual features such as edges and progressively combine them into increasingly complex representations. By sharing parameters across an image, convolutional networks can process visual information more efficiently than conventional fully connected networks.

The course then examines established and modern CNN architectures and the design principles behind them. Architectures including ResNet, Inception, MobileNet, and EfficientNet demonstrate different approaches to building deeper and more computationally efficient networks. Transfer learning and data augmentation demonstrate how existing models and training data can be used more effectively when developing new computer vision applications.

The course progresses from image classification to more advanced computer vision tasks, including object detection, localization, and semantic segmentation. Techniques and architectures such as YOLO and U-Net demonstrate how neural networks can identify not only what is present in an image, but also where objects are located and which regions belong to different semantic classes.

The final part explores specialized applications including face recognition and Neural Style Transfer. Face recognition introduces techniques for learning representations that measure similarities between faces, while Neural Style Transfer demonstrates how representations learned by CNNs can be used generatively to combine the content of one image with the visual style of another.

Overall, the course develops an understanding of how deep neural networks learn and represent visual information. It connects the fundamental mechanics of convolution with modern network architectures and practical applications in image classification, object detection, segmentation, face recognition, and generative image processing.

Course modules

Foundations of Convolutional Neural Networks

The first module introduces the fundamental building blocks of CNNs, including convolutional filters, edge detection, padding, stride, convolutions over volumes, and pooling layers. These components are progressively combined into complete convolutional networks for image classification. The module also explains why parameter sharing and sparse connections make convolution particularly effective for visual information.

Deep Convolutional Models: Case Studies

The second module examines influential CNN architectures and the engineering principles behind deeper and more efficient networks. ResNet and residual connections, 1×1 convolutions, Inception networks, MobileNet, and EfficientNet illustrate different architectural approaches. The module also introduces transfer learning and data augmentation, demonstrating how existing models and datasets can be leveraged when developing new computer vision systems.

Object Detection

The third module moves from image classification to identifying and locating multiple objects within an image. It introduces object localization, landmark detection, bounding boxes, Intersection over Union, Non-Max Suppression, and anchor boxes. The YOLO architecture demonstrates how these concepts can be combined into an efficient object-detection system, while U-Net extends the discussion toward semantic image segmentation.

Special Applications: Face Recognition & Neural Style Transfer

The final module explores two specialized applications of convolutional networks. Face recognition and verification use learned embeddings and similarity measures to determine identity, introducing concepts such as Siamese networks and triplet loss. Neural Style Transfer uses representations from different layers of a CNN to separate image content from visual style and generate new images that combine characteristics of both.

Topics and techniques

• Convolutional Neural Networks – convolutions, filters, padding, stride, and pooling.
• CNN architectures – ResNet, Inception, MobileNet, and EfficientNet.
• Transfer learning – adapting pre-trained networks to new computer vision tasks.
• Data augmentation – increasing training-data diversity and improving generalization.
• Object detection – localization, bounding boxes, anchor boxes, and YOLO.
• Image segmentation – semantic segmentation and U-Net.
• Face recognition – embeddings, similarity measures, and Siamese networks.
• Neural Style Transfer – using CNN representations for generative image transformation.

Practical exercises

The practical exercises use Python and TensorFlow to implement and apply convolutional neural networks. Initial assignments build convolution and pooling operations step by step before combining them into a complete CNN for image classification.

The exercises then progress to implementing Residual Networks and transfer learning, providing practical experience with modern CNN architectures and adapting existing networks to new datasets. Object-detection exercises implement YOLO, including bounding-box processing and Non-Max Suppression, while image segmentation is explored using U-Net.

The final assignments develop a face-recognition system based on learned embeddings and implement Neural Style Transfer to generate images combining the content of one image with the artistic style of another.

Together, the exercises demonstrate the progression from the fundamental mathematics and implementation of convolution to complete computer vision systems for classification, detection, segmentation, recognition, and generative image processing.

Neural Networks and Deep Learning provides a technical foundation for understanding how artificial neural networks are structured, trained, and applied to machine learning problems. As the first course in the Deep Learning Specialization, it introduces the fundamental concepts behind deep learning and develops them progressively from logistic regression to multi-layer deep neural networks.

The course begins by examining the development of deep learning and the technological factors that have enabled neural networks to become increasingly effective. It introduces supervised learning with neural networks and explains how increasing amounts of training data, computational performance, and larger network architectures have contributed to the development of modern AI.

A central part of the course focuses on the mathematical and computational foundations of neural networks. Logistic regression, cost functions, gradient descent, derivatives, and computation graphs are used to explain how a model learns from training data. These concepts provide the foundation for understanding forward propagation and backpropagation and how model parameters are progressively adjusted to minimize prediction errors.

The course then develops these principles into neural networks with hidden layers. It introduces activation functions, vectorization, forward propagation, backpropagation, and parameter initialization, demonstrating how these components interact during training. Vectorized implementations using Python and NumPy show how matrix operations can efficiently process many training examples simultaneously.

The final part extends these concepts to deep neural networks with multiple layers. It examines deep representations, the building blocks of deep networks, parameters and hyperparameters, and the implementation of forward and backward propagation across multiple layers.

Overall, the course provides a foundation for understanding neural networks beyond simply using existing machine learning frameworks. By implementing the underlying algorithms directly, it develops an understanding of how neural networks represent information, calculate predictions, measure errors, and learn through optimization.

Course modules

Introduction to Deep Learning

The first module introduces neural networks and supervised deep learning and examines the technological trends behind the rapid development of deep learning. It explains how neural networks can learn increasingly complex relationships from data and introduces examples of how different neural network architectures can be applied to practical AI problems.

Neural Networks Basics

The second module establishes the mathematical and computational foundations required to build neural networks. Binary classification and logistic regression are used to introduce cost functions, derivatives, gradient descent, and computation graphs. The module also introduces Python, NumPy, broadcasting, and vectorization, demonstrating how neural network calculations can be efficiently implemented as matrix operations.

Shallow Neural Networks

The third module extends logistic regression into a neural network containing a hidden layer. It introduces neural network representation, activation functions, forward propagation, gradient descent, and backpropagation. The module explains why non-linear activation functions are essential and how network parameters can be initialized and progressively updated during training.

Deep Neural Networks

The final module generalizes these principles into deep multi-layer neural networks. It introduces the structure of an L-layer network and develops reusable building blocks for forward and backward propagation. The module also examines why deeper networks can learn hierarchical representations and distinguishes between learned model parameters and externally configured hyperparameters.

Topics and techniques

• Neural networks and deep learning – fundamental concepts and architectures.
• Logistic regression – binary classification using a neural network approach.
• Cost functions and gradient descent – measuring errors and optimizing model parameters.
• Vectorization – efficient numerical implementation using Python and NumPy.
• Forward and backpropagation – calculating predictions, gradients, and parameter updates.
• Activation functions – introducing non-linearity into neural networks.
• Shallow neural networks – implementing networks with hidden layers.
• Deep neural networks – building and training multi-layer architectures.
• Parameters and hyperparameters – understanding the variables controlling learning and network architecture.

Practical exercises

The practical exercises use Python, NumPy, and Jupyter notebooks to implement neural networks progressively from their underlying mathematical components. Initial exercises introduce Python and NumPy operations before implementing logistic regression with a neural network mindset for binary classification.

The exercises then progress to building a neural network with one hidden layer, including forward propagation, activation functions, cost calculation, backpropagation, and gradient descent. A planar-data classification problem demonstrates how a neural network can learn non-linear decision boundaries that cannot be represented effectively by logistic regression alone.

In the final assignments, these components are generalized into reusable functions for constructing a deep L-layer neural network. The resulting network is then trained and applied to a computer vision classification problem.

By implementing the algorithms largely from first principles rather than relying on a high-level deep learning framework, the exercises provide practical insight into the internal mechanisms of neural network training.

Sequence Models provides a technical and practical understanding of neural network architectures designed to process sequential data, such as text, speech, audio, and time-dependent information. As the fifth and final course in the Deep Learning Specialization, it progresses from recurrent neural networks through word embeddings and attention mechanisms to the Transformer architecture, providing an important foundation for understanding modern Natural Language Processing and Large Language Models.

The course begins with Recurrent Neural Networks (RNNs) and how information can be propagated through sequences. It introduces forward propagation and backpropagation through time, together with challenges such as vanishing gradients. More advanced recurrent architectures, including Gated Recurrent Units (GRUs), Long Short-Term Memory networks (LSTMs), bidirectional RNNs, and deep RNNs, demonstrate how neural networks can retain and use information across longer sequences.

The course then applies sequence models to Natural Language Processing (NLP). Word representations and embeddings provide numerical representations of semantic relationships between words, with techniques such as Word2Vec and GloVe demonstrating how these representations can be learned and applied to language-processing tasks.

The course progresses to sequence-to-sequence models and attention mechanisms, enabling models to selectively focus on relevant parts of an input sequence when generating an output. These concepts are applied to neural machine translation and speech recognition and establish the foundation for moving from recurrent processing toward attention-based architectures.

The final module introduces the Transformer architecture, including self-attention and multi-head attention. Transformers replace recurrent processing with attention mechanisms that can model relationships across an entire sequence and enable greater parallelization during training. These principles form an important technical foundation for contemporary Large Language Models and Generative AI.

Overall, the course demonstrates the evolution of sequence modelling from RNNs and LSTMs through attention mechanisms to Transformers. It combines the theoretical foundations of sequential neural networks with practical implementations for language modelling, NLP, machine translation, speech processing, and Transformer-based applications.

Course modules

Recurrent Neural Networks

The first module introduces neural networks specifically designed for sequential information. It covers RNN architectures, backpropagation through time, language modelling, and sequence generation, together with the problem of vanishing gradients. More advanced architectures including GRUs, LSTMs, bidirectional RNNs, and deep RNNs demonstrate different approaches for maintaining and processing information over longer sequences.

Natural Language Processing & Word Embeddings

The second module focuses on representing language numerically so that neural networks can process semantic relationships between words. It introduces word embeddings, embedding matrices, Word2Vec, negative sampling, and GloVe. The module also explores sentiment classification and examines how undesirable biases encoded in learned word representations can be identified and reduced.

Sequence Models & Attention Mechanism

The third module develops sequence-to-sequence architectures for applications such as machine translation and speech recognition. It introduces beam search and the BLEU score for generating and evaluating sequences before moving to the attention mechanism, which allows a neural network to dynamically determine which parts of an input sequence are most relevant when producing each part of an output. Speech recognition and trigger-word detection extend these techniques to audio data.

Transformer Network

The final module introduces the Transformer architecture and the transition from recurrent to attention-based sequence processing. It develops the concepts of self-attention and multi-head attention and combines them into a complete Transformer network. Practical applications demonstrate how Transformers can be used for tasks such as Named Entity Recognition and Question Answering, providing a direct connection to the architectures underlying contemporary LLMs.

Topics and techniques

• Recurrent Neural Networks (RNNs) – modelling and generating sequential information.
• GRUs and LSTMs – maintaining information across longer sequences.
• Word Embeddings – Word2Vec, GloVe, semantic representations, and debiasing.
• Sequence-to-Sequence Models – transforming input sequences into output sequences.
• Attention Mechanisms – dynamically focusing on relevant parts of an input.
• Natural Language Processing – language modelling, sentiment analysis, translation, and NER.
• Transformer Networks – self-attention and multi-head attention.
• Speech and audio processing – speech recognition and trigger-word detection.

Practical exercises

The practical exercises use Python, TensorFlow, and Jupyter notebooks to progressively implement sequence models. Initial assignments build an RNN from first principles, followed by character-level language modelling to generate dinosaur names and an LSTM-based jazz improvisation model.

Exercises with word vectors explore semantic relationships and bias and apply learned representations in an Emojify application. The attention module develops a Neural Machine Translation system and a trigger-word detection system, demonstrating how sequence models can process both text and audio.

The final programming assignment constructs a Transformer architecture with TensorFlow, including self-attention and multi-head attention. Additional labs apply Transformer models to preprocessing, Named Entity Recognition, and Question Answering.

Together, the exercises provide a practical progression from implementing recurrent networks and word representations to attention mechanisms and Transformer architectures, illustrating the evolution of the neural network techniques that underpin modern language AI.

Structuring Machine Learning Projects focuses on the strategy and decision-making required to develop successful machine learning systems. As the third course in the Deep Learning Specialization, it shifts the focus from implementing neural networks to understanding how an ML project should be structured, evaluated, diagnosed, and progressively improved. The course draws on Andrew Ng’s experience developing and deploying machine learning products and is particularly oriented toward the decisions faced by technical leaders and AI development teams.

A central theme is determining what to improve and in which order. Machine learning development often provides many possible directions—collecting more data, changing the model, modifying the training process, or improving data quality. The course introduces systematic approaches for identifying which actions are most likely to improve performance rather than relying on trial and error.

The course introduces orthogonalization as a way of separating different aspects of an ML system so that they can be optimized independently. It also examines the selection of evaluation metrics, including the distinction between optimizing and satisficing metrics, and how training, development, and test sets should be constructed to ensure that improvements are measured against the actual objectives of the system.

A major part of the course focuses on bias and variance analysis. Human-level performance is used as a reference for estimating avoidable bias and determining whether development should focus primarily on improving training performance or reducing variance. This establishes a structured diagnostic process for deciding where development effort should be directed.

The course then extends these principles to real-world situations where training and production data may come from different distributions. Techniques for error analysis and identifying data mismatch help distinguish problems caused by the model from those caused by differences in the available datasets. The course also emphasizes building an initial system quickly and then using systematic error analysis to guide subsequent iterations.

The final part introduces transfer learning, multi-task learning, and end-to-end deep learning as alternative strategies for structuring machine learning solutions. These approaches demonstrate how knowledge can be reused between tasks, how several related objectives can be learned simultaneously, and when a single neural network can replace a more traditional multi-stage processing pipeline.

Overall, the course provides a methodology for moving from experimental machine learning models toward well-structured ML projects. It complements the more algorithmic courses in the specialization by focusing on ML strategy, evaluation, prioritization, and technical decision-making—skills required to guide the iterative development of production-oriented AI systems.

Topics and techniques

• ML Strategy – systematically prioritizing development efforts.
• Evaluation metrics – optimizing and satisficing metrics for measuring performance.
• Train/Dev/Test strategy – selecting appropriate datasets and distributions.
• Bias and variance analysis – diagnosing model performance and avoidable bias.
• Error analysis – identifying and prioritizing the causes of model errors.
• Data mismatch – handling differences between training and real-world data.
• Transfer learning – reusing learned representations for related tasks.
• Multi-task learning – training models to solve several related tasks simultaneously.
• End-to-end learning – replacing multi-stage pipelines with integrated learning systems. 

Practical exercises

Unlike the other courses in the Deep Learning Specialization, the practical work focuses primarily on strategic decision-making rather than programming assignments. Two case studies simulate decisions that arise when leading real-world machine learning projects.

Multi AI Agent Systems with crewAI provides a practical introduction to designing and implementing multi-agent AI systems, where several specialized AI agents collaborate to complete complex, multi-step tasks. Developed by DeepLearning.AI in collaboration with crewAI and taught by crewAI founder João Moura, the course demonstrates how agent-based architectures can extend the capabilities of a single Large Language Model by distributing responsibilities across agents with different roles, goals, tools, and expertise.

The course introduces the fundamental building blocks of an AI agent and how these can be implemented using the crewAI framework. Each agent can be assigned a specific role, goal, and backstory that influence how it approaches its tasks. Complex processes can then be decomposed into well-defined tasks and assigned to specialized agents, creating a structured workflow rather than relying on a single LLM prompt to perform the entire process.

A central part of the course is understanding how agents become more capable through tools and memory. Agents can use pre-built or custom tools to access external capabilities such as web search and other information sources. Memory allows agents to maintain short-term, long-term, and shared information, providing additional context for decisions and collaboration. Guardrails are introduced as a mechanism for controlling agent behaviour and reducing problems such as errors, hallucinations, and infinite execution loops.

The course then extends individual agents into collaborative multi-agent systems. Agents can perform tasks sequentially, in parallel, or through hierarchical structures, allowing different agents to contribute their specialized capabilities to a shared objective. Delegation and cooperation enable one agent’s output to become input or context for another, creating workflows that resemble teams of people performing different roles within a business process.

Overall, the course provides a practical foundation for understanding multi-agent systems as an evolution of LLM-based applications. It demonstrates how role specialization, task decomposition, tools, memory, guardrails, and collaboration can be combined to automate workflows that require multiple stages of research, analysis, decision-making, and content generation.

Topics and techniques

• AI Agents – defining specialized roles, goals, and behaviours.
• crewAI – building and orchestrating teams of LLM-based agents.
• Tasks and delegation – decomposing complex processes into agent responsibilities.
• Tools – extending agents with external information and capabilities.
• Memory – short-term, long-term, and shared context between agents.
• Guardrails – controlling errors, hallucinations, and unwanted execution behaviour.
• Multi-Agent Collaboration – coordinating specialized agents within shared workflows.
• Sequential, parallel, and hierarchical processes – alternative patterns for organizing agent execution.

Practical exercises

The practical exercises use Python and crewAI to build multi-agent systems around realistic business processes. The first application creates a team of agents that collaborates to research, write, and edit a technical article, establishing the basic concepts of agents, tasks, roles, and collaboration. 

The exercises then progress through a customer support system, a customer outreach campaign using external tools, and an event-planning workflow. More advanced examples use cooperating agents for financial analysis and build a crew that analyzes job requirements, adapts a résumé, and prepares a candidate for an interview. Together, the exercises demonstrate six different business processes and show how multi-agent architectures can distribute complex work among specialized AI agents. 

Improving Deep Neural Networks: Hyperparameter Tuning, Regularization and Optimization develops a deeper understanding of how neural networks can be systematically improved after their basic architecture has been established. As the second course in the Deep Learning Specialization, it focuses on the practical techniques required to make deep neural networks train more reliably, generalize better to new data, and converge more efficiently.

The course introduces a systematic approach to developing deep learning systems, including how training, development, and test sets should be structured and how bias and variance can be analyzed to diagnose model performance. It explores techniques for reducing overfitting, improving training stability, and identifying problems in the implementation of neural networks.

A central part of the course focuses on optimization. Starting with gradient descent, it introduces more efficient algorithms including mini-batch gradient descent, Momentum, RMSprop, and Adam. These methods demonstrate how the training process itself can be optimized to achieve faster and more reliable convergence.

The course also examines how hyperparameters such as learning rate, mini-batch size, and network configuration can be systematically tuned. Batch Normalization is introduced as a technique for stabilizing and accelerating training, while TensorFlow demonstrates how these concepts can be applied using a modern deep learning framework.

Overall, the course extends the fundamental understanding of neural networks into the practical discipline of training and optimizing them. It provides methods for diagnosing model performance, controlling overfitting, improving convergence, selecting hyperparameters, and establishing a systematic workflow for developing more effective deep learning models.

Course modules

Practical Aspects of Deep Learning

This module focuses on diagnosing and improving the performance of neural networks. It covers the use of training, development, and test sets, bias and variance analysis, and techniques for reducing overfitting. L2 regularization, dropout, input normalization, weight initialization, vanishing and exploding gradients, and gradient checking provide a practical toolkit for making deep networks more stable and reliable.

Optimization Algorithms

This module explores techniques for making neural network training faster and more efficient. It progresses from mini-batch gradient descent to exponentially weighted averages, Momentum, RMSprop, and the Adam optimization algorithm. Learning-rate decay and convergence behaviour are also examined, providing an understanding of how optimization choices influence the efficiency and performance of model training.

Hyperparameter Tuning, Batch Normalization and Programming Frameworks

The final module examines how hyperparameters can be systematically selected and adjusted to improve model performance. It introduces Batch Normalization for stabilizing activations and accelerating training, together with Softmax regression for multi-class classification. The module concludes by introducing deep learning frameworks and using TensorFlow to implement and train neural networks.

Topics and techniques

• Bias and variance analysis – diagnosing underfitting and overfitting.
• Regularization – L2 regularization and dropout for improving generalization.
• Initialization and gradient checking – improving stability and validating backpropagation.
• Optimization algorithms – mini-batch gradient descent, Momentum, RMSprop, and Adam.
• Hyperparameter tuning – systematically selecting learning rates and other parameters.
• Batch Normalization – stabilizing and accelerating neural network training.
• TensorFlow – implementing and training neural networks using a deep learning framework.

Practical exercises

The practical exercises use Python notebooks to apply the optimization techniques directly to neural networks. Initial assignments experiment with different weight initialization methods, implement L2 and dropout regularization, and use gradient checking to verify the correctness of a neural network implementation.

Further exercises implement optimization techniques including mini-batch gradient descent, Momentum, and Adam, demonstrating how different algorithms influence convergence. The final programming assignment introduces TensorFlow, using the framework to construct and train a neural network.

Together, the exercises demonstrate how choices in initialization, regularization, optimization, and hyperparameter configuration directly influence model training, generalization, and performance.

ChatGPT Prompt Engineering for Developers introduces the principles and practical techniques for using Large Language Models through prompting and API-based application development. Developed by DeepLearning.AI in collaboration with OpenAI and taught by Isa Fulford and Andrew Ng, the course focuses on how carefully structured prompts can transform general-purpose LLMs into effective components for solving specific tasks and building AI-powered applications. 

A central part of the course is understanding how instructions, context, examples, and output formats influence an LLM’s response. Two fundamental principles are introduced: writing clear and specific instructions and giving the model time to think. These principles are developed through techniques such as delimiters, structured output formats, checking whether conditions are satisfied, few-shot prompting, specifying intermediate reasoning steps, and asking the model to work through a problem before producing its final response.

The course also introduces an iterative approach to prompt development. Rather than attempting to create a perfect prompt initially, prompts are progressively refined by examining the model’s output, identifying shortcomings, modifying instructions or context, and evaluating the resulting response. This establishes prompt engineering as an iterative development process comparable to other forms of software design and testing.

The techniques are then applied to several common LLM application patterns. Summarizing demonstrates how large amounts of text can be condensed according to specific requirements. Inferring uses LLMs for tasks such as sentiment analysis, classification, topic identification, and information extraction. Transforming covers translation, rewriting, formatting, and spelling and grammar correction, while Expanding demonstrates how shorter inputs can be developed into more complete generated content. 

The final part of the course combines these techniques in the development of a conversational chatbot. This demonstrates the transition from individual prompts toward an application in which a sequence of messages and responses forms a persistent conversational context. Overall, the course provides a practical foundation for understanding prompt engineering as both an interaction technique and an important component of LLM application development.

Topics and techniques

• Prompt engineering principles – clear instructions, context, delimiters, and structured outputs.
• Few-shot prompting – providing examples to establish expected behaviour and output.
• Iterative prompt development – testing, evaluating, and progressively refining prompts.
• Summarizing – condensing and extracting relevant information from text.
• Inferring – sentiment analysis, classification, topic identification, and information extraction.
• Transforming – translation, rewriting, formatting, and language correction.
• Expanding – generating more extensive content from shorter inputs.
• Chatbots and conversational context – managing sequences of messages within an LLM application.
• OpenAI API – integrating prompts and LLM responses into Python applications. 

Practical exercises

The practical exercises are implemented in Python and Jupyter notebooks using the OpenAI API. Each section applies the concepts directly through code examples, allowing prompts to be modified and their effects on model responses to be evaluated. Exercises cover summarizing product reviews, extracting sentiment and topics, translating and correcting text, transforming information between formats, and generating customized content. 

The final exercise develops a chatbot for taking customer orders, combining system and user messages with conversational context to demonstrate how prompting techniques can be incorporated into an interactive application. Together, the exercises establish a practical workflow for designing, testing, and refining prompts as reusable components of LLM-based software systems.

MCP: Build Rich-Context AI Apps with Anthropic explores the Model Context Protocol (MCP) and how it can be used to connect Large Language Models and AI applications to external tools, data, and contextual resources. Developed in collaboration between DeepLearning.AI and Anthropic and taught by Elie Schoppik, the course introduces MCP as an open protocol for creating standardized integrations between AI applications and external systems. 

A central challenge when developing LLM applications is providing models with access to information and capabilities outside their training data and immediate prompt context. Traditionally, these integrations have required custom implementations for individual applications, APIs, databases, and data sources. MCP addresses this problem by defining a common interface through which AI applications can discover and access tools, resources, and prompt templates provided by external systems.

The course introduces the client-server architecture of MCP. An AI application hosts one or more MCP clients, while MCP servers expose capabilities that the application can access. Servers can operate locally as subprocesses or remotely as independent services. This separation provides a reusable architecture where the same MCP server can potentially provide capabilities to different AI applications without requiring application-specific integrations.

An important distinction is made between MCP’s three principal capabilities. Tools allow an AI application to perform actions by invoking functions; Resources provide contextual information and data; and Prompts provide reusable prompt templates and interaction patterns. Together, these mechanisms enable an LLM application to dynamically combine model reasoning with external information and software functionality.

The course progresses from understanding MCP architecture to implementing complete MCP-enabled applications. It demonstrates how an existing chatbot can be transformed into an MCP-compatible application, how MCP servers and clients are created, how multiple servers can be connected to the same application, and how servers can be deployed remotely. The course also demonstrates integration with existing MCP reference servers and applications such as Claude Desktop. 

Overall, the course provides a practical understanding of MCP as an integration layer for modern AI systems. Rather than embedding every external capability directly into an application, MCP introduces a standardized architecture where models, applications, tools, and information sources can be connected as reusable components. This provides an important foundation for building richer LLM applications and increasingly capable agentic AI systems.

Topics and techniques

• Model Context Protocol (MCP) – standardized integration between AI applications and external systems.
• MCP architecture – understanding hosts, clients, servers, and their communication.
• Tools, Resources, and Prompts – exposing actions, contextual data, and reusable prompt templates.
• MCP Servers – building local and remote servers with FastMCP.
• MCP Clients – enabling AI applications to discover and interact with MCP servers.
• MCP Inspector – testing and debugging MCP servers.
• Reference Servers – connecting applications to reusable filesystem and web-content services.
• Claude Desktop integration – configuring an existing AI application to use MCP servers.
• Remote MCP Servers – deploying MCP capabilities beyond the local environment. 

Practical exercises

The practical exercises use Python to progressively transform a conventional LLM chatbot into an MCP-compatible AI application. The initial chatbot implements custom tools for searching and retrieving academic papers. These capabilities are then moved into an MCP server, exposing them through a standardized interface rather than application-specific tool implementations.

The exercises continue by building an MCP client that dynamically connects the chatbot to the server and by integrating additional reference servers for filesystem operations and retrieving web content. Further exercises add MCP Resources and Prompts, configure the developed server for use with Claude Desktop, and finally deploy an MCP server remotely. Together, the exercises demonstrate the complete path from a custom LLM integration to a modular architecture in which AI applications can access multiple independent MCP servers and their tools, resources, and prompts

erence servers for filesystem operations and retrieving web content. Further exercises add MCP Resources and Prompts, configure the developed server for use with Claude Desktop, and finally deploy an MCP server remotely. Together, the exercises demonstrate the complete path from a custom LLM integration to a modular architecture in which AI applications can access multiple independent MCP servers and their tools, resources, and prompts.