IBM AI Engineering

Neural networks learn their own features. You build networks in Keras, see how forward and backward passes work, and learn the choices of layers, activations, losses and optimizers that decide whether training works.

• Neurons, layers and activation functions
• Forward pass, loss and backpropagation
• Building and compiling models in Keras
• Optimizers and learning rates
• Overfitting, dropout and early stopping
• Reading training curves

You build A Keras network for a tabular problem, with its training curves explained.

Images and sequences need architectures made for them. You build convolutional and recurrent networks and autoencoders, work with TensorFlow’s lower-level tools, and learn how to debug a network that will not learn.

• Convolutional networks for images
• Recurrent networks and sequences
• Autoencoders and learned representations
• TensorFlow tensors and custom training steps
• Saving, loading and serving models
• Debugging a network that will not learn

You build A convolutional model and a sequence model, each trained and evaluated.

PyTorch is where much current research and engineering happens. You learn tensors, automatic differentiation and the training loop, then build and train networks the way modern codebases do.

• Tensors and automatic differentiation
• Modules, layers and parameters
• Datasets and data loaders
• Writing the training and evaluation loop
• Convolutional networks in PyTorch
• Using a GPU and saving checkpoints

You build A PyTorch image classifier written with an explicit training loop.

Apply what you know to one real vision problem. You build a convolutional network and a vision transformer, compare them in Keras and PyTorch, and judge which suits the data.

• Preparing and augmenting an image dataset
• A convolutional baseline
• Vision transformers in outline
• Transfer learning from a pretrained model
• Comparing results across frameworks
• Error analysis on misclassified images

You build An image classification project comparing two architectures across two frameworks.

Language models start with text turned into numbers. You study tokenization, embeddings and the data pipelines that feed training, and how generative models differ in structure from earlier ones.

• Generative models and where LLMs fit
• Tokenization methods
• Embeddings and positional information
• Building datasets and data loaders for text
• Cleaning and filtering text data
• Batching and padding sequences

You build A tokenized text dataset with a loader ready for language-model training.

Language tasks run from sentiment to translation. You trace word embeddings, sequence-to-sequence models and attention, then use pretrained foundation models on classification, extraction and generation.

• Word embeddings and what they capture
• Sequence-to-sequence models
• The attention mechanism
• Text classification and named entity recognition
• Translation and summarization
• Using pretrained models for language tasks

You build A pretrained model applied to two language tasks, with results compared to a baseline.

The transformer is the architecture behind GPT and BERT. You build self-attention and multi-head attention, assemble blocks, and learn why decoder-only and encoder-only models suit different jobs.

• Self-attention step by step
• Multi-head attention and masking
• Transformer blocks and normalization
• Decoder models and the GPT approach
• Encoder models and the BERT approach
• Training a small language model

You build A small transformer language model written and trained in PyTorch.

Few teams train from scratch. You load pretrained transformers through Hugging Face, fine-tune them on your own task, use parameter-efficient methods to keep cost down, and evaluate before you trust the result.

• Working with the Hugging Face ecosystem
• Supervised fine-tuning for a task
• Low-rank adaptation and parameter-efficient methods
• Preparing training data
• Evaluating a fine-tuned model
• Comparing prompting with fine-tuning

You build A pretrained transformer fine-tuned for one task with a before-and-after evaluation.

Instruction following and good behavior come from further training. You study instruction tuning, reward models, reinforcement learning from human feedback and direct preference optimization, and when each is worth its cost.

• Instruction tuning
• Preference data and how it is collected
• Reward models
• Reinforcement learning from human feedback
• Direct preference optimization
• Memory and compute limits when tuning large models

You build A preference-tuned small model with a written comparison to its starting point.

Fine-tuning does not keep a model current with your documents. You add retrieval, then let a model use tools through LangChain agents, and learn where each approach fits.

• Retrieval-augmented generation architecture
• Document loaders, splitters and embeddings
• Retrievers and prompts in LangChain
• Agents and tool use
• Retrieval or fine-tuning: choosing
• Evaluating answers against sources

You build A LangChain agent that uses retrieval and one tool to answer a question.

Finish with a complete application. You build a vector database over a document set, wire up a retriever, a model and a Gradio interface, and test how well it answers.

• Choosing and preparing the document set
• Indexing in a vector database
• Configuring the retriever and model
• Building the Gradio interface
• Testing answer quality and fixing weak spots

You build A deployed question-answering application over a real document collection.