AI for Developers, Science and Data Analytics

Lesson 1 — Machine learning and Bayesian statistics

We learn how computers can predict and make decisions without pre-defined instructions. We explore the simple but powerful naive Bayes classifier, which lets us classify data with remarkable accuracy.

Lesson 2 — Decision trees and parameter optimisation

We enter the world of decision trees, which help us make smart decisions based on data. We learn how to optimise model parameters to achieve the best results.

Lesson 3 — Multilayer perceptron and deep learning

We dive into advanced deep-learning techniques and multilayer perceptrons. We discover how neural networks can solve complex problems and bring revolutionary innovations.

Lesson 4 — Image recognition with convolutional networks

Convolutional neural networks apply an image filter to another image. Using a sequential convolutional network model we explain the essence of graphical filters. As an example we build an application that recognises which objects are in a picture.

Lesson 5 — Data augmentation and advanced image recognition

We improve our image-recognition skills with data-augmentation techniques. We learn how to build models that can identify and classify objects in images with high accuracy.

Lesson 6 — Generative networks for images

We look at generative architectures and discover how to create new, realistic images with generative adversarial networks (GANs). We learn to create art, design and photorealistic images that have never existed before.

Lesson 7 — Time-series prediction with recurrent networks

Recurrent neural networks are a neural-network model with memory. Using a long short-term memory (LSTM) recurrent network we explain the essence of natural-language processing. As an example we build a spam-detection application.

Lesson 8 — Natural language processing

We learn how to create a chatbot, an automatic translator or analyse sentiment on social networks.

Lesson 9 — Unsupervised learning

We discover the secrets of unsupervised learning, where models find structures and patterns in data on their own.

Lesson 10 — Deploying and monitoring models

We gain practical skills for deploying machine-learning models to the real world. We learn how to monitor their performance and ensure they work correctly.

Lesson 1 — Introduction and theory

We explain the difference between classic language models and the agentic approach. We go through the architecture of an agent, the principle of the decision loop (perception → reasoning → action) and the concepts of planning and tool use. We show the main use cases – from research assistants to system automation.

Lesson 2 — Vector databases

You understand why classic databases are not enough for working with the meaning of text and how vector databases enable semantic search. You learn to create embeddings, index them and perform similarity search. You try tools such as Chroma, Weaviate or FAISS and their integration into AI agentic systems.

Lesson 3 — Running and fine-tuning models

You learn to run open language models on your own infrastructure – from choosing a model on Hugging Face through quantisation and an inference server (Ollama, vLLM) to tracking latency, throughput and GPU costs. You try fine-tuning a smaller model on your own data using LoRA/QLoRA techniques, learn to evaluate the result and decide when fine-tuning pays off compared with prompting or RAG.

Lesson 4 — Operating agentic systems

We show what deploying an agent to production involves: running in Docker, managing API keys, limits and costs, logging and tracing individual agent steps (LangSmith, OpenTelemetry) and evaluating the quality of its outputs. We also focus on security – protection against prompt injection, limiting tool permissions and human approval of critical actions. The result is an agent that runs reliably, is monitored and communicates safely with surrounding systems via REST APIs and databases.

Lesson 5 — LangChain

You explore how to compose agent logic with LangChain – from simple chains through working with prompts, memory and structured outputs to connecting tools and a retriever over a vector database. You build your first agent that calls tools and answers based on your own data.

Lesson 6 — LangGraph

With LangGraph you create state machines where each node represents an agent step and the edges control its decisions. You learn to design multi-phase flows with cycles, branching and human-in-the-loop approval, persist state between runs and orchestrate several specialised agents (programmer, reviewer, planner) that cooperate on complex problems.

Lesson 7 — Practical demo

In the final project you create your own agent that has memory, uses tools, communicates with its surroundings via tools and APIs, and can make decisions or delegate tasks to other agents. You try debugging, logging and evaluating agent behaviour in a real scenario.

Lesson 1 — How to ask the right way

You learn how to formulate prompts according to the type of model and task. You try the differences between querying language models (ChatGPT, Claude) and generative models (DALL·E, Stable Diffusion). We focus on techniques such as few-shot prompting, persona setup, the ReAct pattern and chain-of-thought prompting.

Lesson 2 — Connecting to AI via SDKs and APIs

We show how to integrate artificial intelligence into your own applications using SDKs and APIs. You learn to work with tools such as the OpenAI API, Hugging Face Transformers, Replicate or the Stability SDK. The lesson is practical, focused on Python code and real-world use cases.