AI courses

103 courses and guided projects taught by AI Learning Companions: lessons in their own voice, hands-on labs, projects they review, graded quizzes and a certificate when you finish. The first module of every course is free.

Generative AI

  • Generative AI Fundamentals: Understand how generative AI creates text and images, what it does well and badly, and how to check it and use it honestly. (Beginner, about 8 hours)
  • Prompt Engineering: From Basics to Advanced Techniques: Write prompts that get reliable results: clear instructions, examples, roles, structured output, reasoning, long documents, testing and reusable templates. (Beginner, about 9.5 hours)
  • Guided Project: Build a Chatbot with the Claude API in PyCharm: In about two hours, build a terminal chatbot in PyCharm with the Claude API: a personality set by a system prompt, a memory of the conversation and replies that stream in as they're written. (Guided project, Beginner, about 2 hours)
  • Prompting and LLM Application Design: Design LLM features that hold up in production: structured outputs, reasoning, retrieval, tools, guardrails and evaluation, built in Python on the Claude API. (Intermediate, about 20 hours)
  • Building RAG and Agentic Systems: Build retrieval-augmented and agentic AI systems that hold up: measured retrieval, hybrid search and re-ranking, tool-using agents with memory and plans, and multi-agent teams that check each other's work. (Advanced, about 22 hours)
  • Engineering with Foundation Models: Choose, understand, evaluate and steer foundation models like an engineer: scale and serving arithmetic, transformer internals, rigorous model and system evaluation, LLM judges in CI, and prompt optimisation. (Advanced, about 20 hours)
  • Fine-Tuning Open Language Models with LoRA: Decide when fine-tuning pays, prepare chat data properly, and fine-tune open models with LoRA and QLoRA, from the maths and a LoRA layer of your own to transformers, peft, evaluation and serving. (Advanced, about 19 hours)
  • Generative AI Design Patterns: Build robust GenAI applications from proven patterns: structured output, RAG, reasoning, agents with tools and hand-offs, guardrails and evaluation, each built, measured and its trade-offs known. (Advanced, about 29 hours)
  • Transformers and Large Language Models: Build attention and transformer blocks from scratch, understand how large language models are pretrained, aligned and scaled, and fine-tune, decode and evaluate them with Hugging Face. (Advanced, about 23 hours)

Machine Learning

  • AI for Everyone: Understanding AI Without Code: Understand what AI is, how it learns from examples, where it helps and where it fails, and train your own image classifier in a browser, with no code at all. (Beginner, about 8.5 hours)
  • Foundations of Machine Learning (Vietnamese and English): Learn what machine learning is, then build, optimise and evaluate linear regression in Python and scikit-learn, taught in English with every key term also in Vietnamese. (Beginner, about 13 hours)
  • Machine Learning Foundations with Python: Prepare data, train regression and classification models with scikit-learn, evaluate them honestly and build a tuned pipeline end to end, all in PyCharm. (Beginner, about 11 hours)
  • NLP Foundations with Python and Corpora: Load corpora, clean and normalise raw text, tokenise it with regular expressions, and count, compare and model words in Python with NLTK. (Beginner, about 17 hours)
  • Guided Project: Build a Sentiment Analyser in PyCharm: Train a machine learning model that tells positive reviews from negative ones, measure how good it really is, and find where it goes wrong. (Guided project, Beginner, about 1.5 hours)
  • Applied Machine Learning with TensorFlow: Build end-to-end TensorFlow projects: tf.data pipelines and preprocessing layers, CNNs and transfer learning for images, TF-IDF and LSTM models for text, and models saved, exported and served. (Intermediate, about 17 hours)
  • Classical Classification and Clustering: Apply and tune logistic regression, k-NN, SVMs, decision trees and ensembles, then find structure in unlabelled data with k-means and PCA, all in scikit-learn. (Intermediate, about 16 hours)
  • Computer Vision with Convolutional Neural Networks: Understand convolutions from the arithmetic up, build CNNs from LeNet to ResNet in PyTorch, and train, transfer and evaluate them for classification, detection and segmentation. (Intermediate, about 17 hours)
  • Deep Learning with PyTorch: Build, train, debug and ship neural networks in PyTorch: tensors and autograd, nn.Module, DataLoaders and the training loop, regularisation, checkpoints and export. (Intermediate, about 15 hours)
  • Feature Engineering and Model Evaluation: Prepare real, messy data for machine learning, evaluate models reliably with cross-validation, tune them honestly, and wrap it all in leak-proof scikit-learn pipelines. (Intermediate, about 15 hours)
  • Introduction to Neural Networks and TensorFlow: Build neural networks from the single neuron up: code a perceptron and backpropagation in NumPy, then train and evaluate feed-forward networks with TensorFlow and Keras. (Intermediate, about 13 hours)
  • Machine Learning from Scratch: Build gradient descent, k-NN, k-means, Naive Bayes, linear and logistic regression and decision trees in NumPy, and prove each one matches scikit-learn. (Intermediate, about 26 hours)
  • Statistical NLP: Models, Parsing and Information Retrieval: Classify text with Naive Bayes and logistic regression, build word vectors from counts, tag with hidden Markov models, parse with probabilistic grammars, and rank documents with TF-IDF and BM25. (Intermediate, about 22 hours)
  • Text Representation: From Vectors to Context: Represent text as numbers, from one-hot vectors, bags of words and TF-IDF to word2vec, fastText and the contextual embeddings of transformers, and learn to visualise and question what they encode. (Intermediate, about 17 hours)
  • Recommender Systems: From Collaborative Filtering to Two-Tower Models: Build, evaluate and improve recommenders in Python: neighbourhood methods, matrix factorisation, implicit ALS and two-tower retrieval in PyTorch, with honest offline evaluation and cold-start strategies. (Advanced, about 15 hours)
  • Reinforcement Learning: From Bandits to Policy Gradients: Learn how agents learn from reward, from bandits and dynamic programming through Monte Carlo, TD learning, SARSA and Q-learning to deep Q-networks and policy gradients in PyTorch. (Advanced, about 16 hours)
  • Training Deep Neural Networks: Diagnose and fix what stops deep networks learning: vanishing and exploding gradients, slow or unstable optimisation, overfitting and badly scaled activations, in TensorFlow and Keras. (Advanced, about 14 hours)

AI Engineering

  • Foundations of AI System Design: Scope a machine learning system and design its data, features, models, deployment and monitoring, with a design document that catches data leakage before it ships. (Intermediate, about 21 hours)
  • MLOps Foundations: Experiments, Models and Reproducibility with MLflow: Track every experiment, package models with signatures, promote them with registry aliases and rebuild any training run, using MLflow on your own laptop. (Intermediate, about 16 hours)
  • Machine Learning Design Patterns: Solve the recurring problems of ML systems with proven patterns for representing data, framing problems, training, serving and reproducibility, and know what each one costs. (Intermediate, about 25 hours)
  • Vector Databases and Semantic Search: Build semantic search that's fast and measurably right: embeddings, exact and approximate indexes, compression, hybrid ranking, filtering and vector databases. (Intermediate, about 18 hours)
  • Deploying and Serving Machine Learning Models: Serve models fast and safely: validated APIs, ONNX, gRPC and micro-batching, lean containers, canary and shadow releases, and load tests that tell the truth. (Advanced, about 17 hours)
  • Efficient Inference: Quantisation, Distillation and Batching: Make language models faster, smaller and cheaper to serve: find where time and memory go, batch continuously, quantise weights and activations with the maths behind it, and distil, prune and speculate. (Advanced, about 18 hours)
  • Enterprise Data and ML Platforms: Architect data lakes, lakehouses, streaming pipelines, hybrid cloud deployments and governed MLOps for an enterprise, and build working miniatures of each on your laptop. (Advanced, about 26 hours)
  • LLMOps: Evaluating, Tracing and Monitoring LLM Applications: Run LLM features like production software: golden sets and judges, regression gates with replayed recordings, OpenTelemetry traces, cost and guardrail metrics, and A/B tests. (Advanced, about 17 hours)
  • Monitoring Models in Production: Drift, Data Quality and Alerts: Catch broken pipelines, measure drift with statistics you build yourself, track performance when labels arrive late, and design alerts and retraining policies people trust. (Advanced, about 17 hours)
  • Operationalising LLMs on Kubernetes: Deploy, scale, observe and upgrade open large language models on Kubernetes: inference servers, model storage, GPU scheduling, queue-based autoscaling and safe rollouts. (Advanced, about 24 hours)

Data Science

  • Data Analysis with Python and pandas: Load, clean, explore, combine and chart real-world data in Jupyter notebooks with pandas and matplotlib, and turn what you find into a clear, honest story. (Beginner, about 11 hours)
  • Data Storytelling and Dashboard Design: Turn analysis into a clear message for a real audience: choose and declutter charts, build a narrative that leads to a decision, and design honest, accessible KPI dashboards. (Beginner, about 13 hours)
  • Data Visualisation with Matplotlib, Seaborn and Plotly: Choose the right chart, build it precisely with Matplotlib, explore data with seaborn, share interactive charts with Plotly, and make every figure clear, accessible and ready to publish. (Beginner, about 12 hours)
  • Python Foundations for Data Science: Learn the Python data scientists use every day: the IPython shell, built-in data structures, functions and lambdas, Jupyter notebooks, and tidy scripts that cope with messy data. (Beginner, about 13 hours)
  • SQL for Data Analysis with DataGrip: Answer real business questions with SQL: filter, summarise, join and rank a shop's sales data in DataGrip, then export the results to share. (Beginner, about 10 hours)
  • Spreadsheet Data Analysis: Formulas, Pivot Tables and Charts: Clean, look up, summarise and chart data in Excel, Google Sheets or LibreOffice Calc, then build what-if models with validation, scenario tables and Goal Seek. (Beginner, about 14 hours)
  • Statistics for Data Science and AI: Describe data, reason with probability, and test ideas with confidence intervals, hypothesis tests, regression and A/B tests, in Python with pandas and SciPy. (Beginner, about 10 hours)
  • AI-Powered Business Intelligence Fundamentals: Add AI to business intelligence: judge data readiness, model data for BI, build KPIs and forecasts, let people ask questions in plain language, and find the drivers and anomalies behind the numbers. (Intermediate, about 17 hours)
  • Data Wrangling with pandas and NumPy: Turn messy, scattered data into clean, analysis-ready tables: vectorised NumPy, pandas' index and dtypes, missing data, validated merges, reshaping and group operations. (Intermediate, about 15 hours)
  • Foundations of Probability and Statistics: Build the probability that data science rests on: rules and counting, Bayes' theorem, discrete and continuous distributions, expectation and inference, derived, calculated and checked by simulation. (Intermediate, about 14 hours)
  • Interactive Data Apps with Streamlit: Turn Python analysis into interactive web apps: widgets, layouts, charts, caching, session state, forms and multipage navigation, tested with AppTest and ready to deploy. (Intermediate, about 16 hours)
  • Practical Statistics for Data Scientists: Apply statistics to real decisions: robust summaries, the bootstrap, A/B tests done properly, regression with diagnostics, and logistic models judged by the costs of their errors. (Intermediate, about 15 hours)
  • Product Analytics with SQL: Funnels, Cohorts and Retention: Turn raw product events into metrics a team can trust: active users, sessions, funnels, retention cohorts, attribution and experiment readouts, all in SQL. (Intermediate, about 14 hours)
  • Time Series Analysis and Forecasting: Analyse and forecast time series in Python: decomposition, stationarity, exponential smoothing, SARIMA and gradient boosting, tested with honest backtests and prediction intervals. (Intermediate, about 15 hours)

Data Engineering

  • Data Engineering Foundations: Batch and Streaming Pipelines: Build reliable data pipelines in Python and DuckDB: file formats, idempotent and incremental loads, partitioned Parquet, quality checks and a first stream. (Beginner, about 15 hours)
  • Analytics Engineering with dbt and DuckDB: Turn raw data into tested, documented models with dbt Core and DuckDB: sources, staging, marts, tests, snapshots, incremental models and CI. (Intermediate, about 16 hours)
  • Big Data Processing with Apache Spark: Process large datasets with PySpark DataFrames and Spark SQL, and make jobs fast: partitions, shuffles, joins, windows, caching, Parquet, the Spark UI and tuning. (Intermediate, about 14 hours)
  • Data Quality, Testing and Data Contracts: Measure data quality, test data in pipelines with pandera, agree data contracts between producers and consumers, and catch and handle bad data before it does harm. (Intermediate, about 16 hours)
  • Data Warehousing and Dimensional Modelling: Design star schemas the Kimball way, keep history with slowly changing dimensions, and build and load a working warehouse in DuckDB with SQL you run. (Intermediate, about 18 hours)
  • Orchestrating Data Pipelines with Apache Airflow: Write, schedule, test and operate Airflow 2 pipelines in Python, with TaskFlow, data intervals, backfills, sensors and retries, and know what changes in Airflow 3. (Intermediate, about 15 hours)
  • Real-Time Data Streaming with Apache Kafka: Run Kafka 4 in KRaft mode, write reliable Python producers and consumers, use transactions and schemas, and build windowed stream processing that copes with late data. (Advanced, about 18 hours)

Software Development

  • Git and GitHub Workflows for Teams: Use Git with confidence on a team: clean commits, branches and merges, pull requests and reviews on GitHub, releases, and a way back from any mistake. (Beginner, about 12 hours)
  • Go Programming with GoLand: Learn Go in GoLand, JetBrains' IDE for Go: types, slices, maps and structs, interfaces and errors, goroutines and channels, tests and a small web service. (Beginner, about 13 hours)
  • Introduction to AI-Assisted Development: Build software faster with AI coding assistants without losing control: prompt for code, test and review everything it writes, catch hallucinations and security flaws, and ship a working prototype. (Beginner, about 19 hours)
  • Java Programming with IntelliJ IDEA: Write, test and debug object-oriented Java in IntelliJ IDEA, from your first Maven project to a tested command-line application. (Beginner, about 11 hours)
  • Modern Web Development with JavaScript and TypeScript in WebStorm: Build interactive web pages and a small Node.js back end with JavaScript and TypeScript, then test and debug them in WebStorm. (Beginner, about 12 hours)
  • Python Programming with PyCharm: Write, run, debug and test real Python programs in a professional IDE, from your first script to a tested, version-controlled project. (Beginner, about 11 hours)
  • Introduction to FastAPI and Modern Web Services: Build typed, validated, self-documenting web APIs in Python with FastAPI and Pydantic, from your first endpoint to a tested CRUD service with dependencies and interactive docs. (Intermediate, about 15 hours)
  • Kotlin Programming with IntelliJ IDEA: Write concise, null-safe Kotlin in IntelliJ IDEA: functions and lambdas, data and sealed classes, collections, coroutines, tests, and code that works hand in hand with Java. (Intermediate, about 11 hours)
  • Rust Programming with RustRover: Write fast, memory-safe Rust in RustRover: ownership and borrowing, enums and pattern matching, traits and generics, iterators, tests and a command-line tool. (Intermediate, about 14 hours)
  • Teach Programming in the IDE: Create Courses with the JetBrains Academy Plugin: Build interactive programming courses that learners take inside PyCharm or IntelliJ IDEA, with tasks checked by tests and feedback that helps them learn. (Intermediate, about 12 hours)
  • Guided Project: Test-Driven Development with JUnit 5 in IntelliJ IDEA: Build a shopping basket with an offer and a discount code test-first, in short red-green-refactor cycles, with JUnit 5 and IntelliJ IDEA. (Guided project, Intermediate, about 2 hours)
  • Advanced FastAPI and Production Deployment: Make FastAPI services production-ready: OAuth2 and JWT authentication with hashed passwords, SQLAlchemy and Alembic, background work, thorough tests, and Docker images served by Uvicorn workers behind Nginx. (Advanced, about 18 hours)
  • Concurrency and Asynchronous Programming in Python: Make Python do many things at once, correctly: threads, processes and asyncio, and the measurements that tell you which to use. (Advanced, about 13 hours)

Computer Science

Networking

Cybersecurity

  • Introduction to Cybersecurity: Understand what cybersecurity protects, recognise common threats, and put the essential defences in place on your own accounts, devices and home network. (Beginner, about 9 hours)
  • Incident Response Fundamentals: Prepare for, investigate, contain and learn from security incidents, using the Linux command line to build timelines and preserve evidence you can prove is unchanged. (Intermediate, about 9.5 hours)
  • Securing LLM Applications: Protect your own LLM features: threat-model them with the OWASP Top 10, contain prompt injection in layers, handle output and tools safely, keep data private, and prove it with an automated test suite. (Intermediate, about 22 hours)
  • Security Operations: Monitoring, Detection and Alert Triage: Work like a security operations centre analyst: read the logs that matter, write and test detection rules in Python, look at traffic in Wireshark, and triage alerts into clear findings. (Intermediate, about 10 hours)
  • Guided Project: Harden a Linux Server: Turn a fresh Ubuntu Server virtual machine into a hardened one: automatic security updates, a sudo user, key-only SSH, a default-deny firewall and fail2ban. (Guided project, Intermediate, about 2.5 hours)

Cloud & DevOps

  • Cloud Computing Fundamentals: Understand how the cloud works, from service models and regions to compute, storage, networking, access and cost, with AWS, Azure and Google Cloud side by side and labs that need no account. (Beginner, about 15 hours)
  • Linux Command Line Essentials: Work confidently in a Linux terminal: move around the file system, manage files, permissions, software and processes, analyse text with pipes, write shell scripts and work on remote machines over SSH. (Beginner, about 9 hours)
  • Python Scripting and Linux for DevOps: Automate Linux servers with Python: scripts that manage files and run commands safely, command-line tools built with argparse and click, packages installed by script, and jobs scheduled with cron and systemd. (Beginner, about 16 hours)
  • CI/CD and Automated Testing: Build pipelines that test every change and release it safely: pytest suites with fixtures and coverage, GitHub Actions and Jenkins pipelines, quality gates, and deployment strategies that make releases routine. (Intermediate, about 17 hours)
  • Infrastructure as Code with Terraform: Describe infrastructure in code, and plan, apply, test and share it safely with Terraform: providers, variables, modules, remote state with locking, workspaces, CI pipelines, drift and import. (Intermediate, about 18 hours)
  • Observability with Prometheus, Grafana and OpenTelemetry: Instrument services with metrics, logs and traces, query them with PromQL, alert on SLO burn rates you can test, and investigate problems with Grafana dashboards and distributed traces. (Intermediate, about 18 hours)
  • Site Reliability Engineering: SLOs, Error Budgets and Incidents: Run services by the numbers: SLIs, SLOs and error budgets, burn-rate alerts, toil and on-call, incident response and postmortems, capacity, safe releases and chaos experiments. (Intermediate, about 18 hours)
  • Containerisation and Orchestration with Docker and Kubernetes: Package Python services as lean, secure container images, run multi-container apps with Docker Compose, and deploy, scale and troubleshoot them on Kubernetes. (Advanced, about 19 hours)

AI for Business

  • AI Strategy for Business Leaders: Decide where AI will pay off in your organisation, prove it with a well-designed pilot, and adopt it with the right data, governance and people in place. (Beginner, about 9.5 hours)
  • AI for Small Business and Entrepreneurs: Use a chat assistant and a spreadsheet to market your business, answer customers, forecast stock and keep your books in order, at little or no cost and with the risks under control. (Beginner, about 10 hours)
  • Generative AI at Work: Save Hours Every Week: Use a chat assistant to write, summarise, research, plan and work in spreadsheets faster, while checking its work and keeping your organisation's data safe. (Beginner, about 9 hours)

Responsible AI

AI in Industry

  • AI in Education: Teaching and Learning with AI: Use a chat assistant to plan lessons, make materials, give feedback and tutor, while redesigning assessment, protecting learners' privacy and teaching students to use AI well. (Beginner, about 10 hours)

Professional Certificates and Specializations