Introduction to AI

Welcome to the Introduction to AI! This is the Fall 2026 edition of the course at the Department of Computer Science, University of Helsinki. The course is an intermediate level 5 credit course, organized by the Data Science MSc programme. We also welcome students in the Computer Science BSc programme as well as all other students as a part of your minor subject studies.

The calculated workload of a 5 credit course is 18 hours per week, so please be prepared to spend time and effort in learning. The course will require hard work. You have been warned.

Prerequisites: What you should know before starting

Prerequisites are good programming skills, and basic data structures and algorithms, and some university level mathematics.

Field	Required skills
Data Structures	stack, priority queue, tree traversal, heuristic search, A* algorithm; for example Data Structures and Algorithms (Tietorakenteet ja algoritmit)
Programming	good programming skills in python
Mathematics	elements of discrete mathematics and linear algebra (set operations, graphs, vectors), probability calculus – multivariate probability is helpful but not required; for example Probability calculus I (Todennäköisyyslaskenta I)

Learning objectives

Topic	Objectives (after the course, you ...)
Philosophy, problem solving as search, games	can express the basic philosophical problems related to AI (the difficulty in defining AI and consciousness, acting vs thinking, Turing test) can distinguish between realistic and unrealistic AI in science-fiction can describe the contrast between "Good Old Fashioned AI" (GOFAI) and modern AI approaches know the main-stream developments in the history of AI can explain the idea of artificial general intelligence (AGI) and distinguish it from narrow AI can formulate a problem as a graph and apply breadth-first and depth-first search can explain informed search and implement A* search can formulate a simple game (such as tic-tac-toe) as a game tree can explain and implement the minimax algorithm and depth-limited alpha-beta pruning can design a reasonable heuristic evaluation function in a game (e.g., chess)
Probabilistic inference	can express uncertain knowledge in a simple situation using a probabilistic model can apply the Bayes theorem to calculate posterior probabilities given evidence in a simple scenario can explain how naive Bayes classification uses conditional independence can estimate model parameters from data and classify new observations can describe important implementation details of probabilistic classifiers can represent a problem solving situation as a Bayesian network can apply an approximate (Monte Carlo) technique to perform inference in a Bayesian network
Classical Machine Learning	can distinguish between unsupervised and supervised machine learning scenarios can explain linear models for regression and classification can implement a nearest-neighbor classifier can compute information gain and use it to choose a decision-tree split can describe the idea of ensembles (bagging, random forests, boosting) can apply naive Bayes as a classical classifier (e.g. handwritten digits)
Neural Networks	can explain the perceptron and implement the perceptron algorithm for a simple binary classification problem can describe multilayer perceptrons and forward propagation can explain why neural networks use activation functions can describe backpropagation as the mechanism that provides gradients for optimization can explain word embeddings, attention, and self-attention at a conceptual level
Modern Architectures and Foundation-Model Applications	can explain the motivation for attention and the high-level idea of transformer encoders and decoders, BERT, and GPT can describe representative transformer applications beyond text can distinguish discriminative and generative models and explain latent representations, interpolation, sampling, and generation can explain how a simple dimension-reducing autoencoder learns a latent representation can describe the conceptual mechanism of GANs and a simple application can explain what foundation models are and how transfer learning is used to adapt pretrained models can describe representative text, image, and multimodal foundation-model applications
Agents	can explain what an agent is and the idea of bounded rationality can describe common agent architectures can describe learning agents and agentic frameworks can explain reinforcement learning and multi-agent systems at a conceptual level can discuss alignment at a conceptual level
Ethics and Trustworthy AI	can discuss accountability, fairness, privacy, and environmental impact of AI can explain the idea of explainable AI and the role of causal modelling can describe AI for science at a conceptual level can outline the purpose of the EU AI Act

Working methods

The course includes lectures (2 x 2h per week) and exercise sessions (2h per week). The exercise sessions are meant for discussing the problems after you have completed them by yourself.

The lectures are not compulsory but they are meant to be useful.

Exercise points are marked in the exercise sessions; see Grading below.

You must register in one of the exercise groups on the registration system. If all the groups are full, please register in the overflow group and contact the lecturer or the TAs for instructions.

In case you have an unexpected constraint and can't make it to your own exercise session, the following options are (prioritized): (a) ask for permission to go to another group; or (b) submit your solutions by email before your own group session AND explain the unexpected situation (NB: being busy at work is not a valid excuse). You can only use the option b two (2) times during the course to gain points.

Course schedule

Each week's exercises are due at your exercise session in the following week.

Week	Topic	Lectures	Exercises due at this week's session
1	Philosophy, problem solving as search, games	We 28/10, Fr 30/10	No exercise deadlines
2	Probabilistic inference	We 4/11, Fr 6/11	Week 1 exercises
3	Bayesian Networks and Classical Machine Learning	We 11/11, Fr 13/11	Week 2 exercises
4	Neural Networks	We 18/11, Fr 20/11	Week 3 exercises
5	Modern Architectures and Foundation-Model Applications	We 25/11, Fr 27/11	Week 4 exercises
6	Agents	We 2/12, Fr 4/12	Week 5 exercises
7	Ethics and Trustworthy AI	We 9/12, Fr 11/12	Week 6 exercises (no new exercises in Week 7). Kaggle competition closes at the last lecture (Fr 11/12).

Course material

There is no course textbook. The course material consists of this material and lecture slides. The lecture slides and other useful information will be posted on the Moodle Page , under section Lecture Slides.

But please continue reading this page first.

Support

Questions and answers are most easily discussed on Discussion Forum , QandA in the moodle of the course. The lecturer and the TAs will do their best to answer questions but other students are also encouraged to engage in the discussion – often the best explanation is provided by a fellow student rather than a professor!

Please maintain a positive and supporting attitude in all discussions. Absolutely no bullying or other inappropriate behavior towards other students. There are no stupid questions, and making a mistake is often an excellent opportunity to learn – also for others.

Grading

Grading on a scale 1–5. Grading depends on the completed exercises (about 33% of the grade) and the course exam (about 67% of the grade). You get full exercise points for completing 80% of the exercises. The minimum requirement to pass is 50% of both the exercise and the exam points.

Your exercise points will be available in the first two separate examinations after the course exam. Please note at registration of separate exams you need to choose the type (tapa) of exam if you are doing a course exam requiring exercises or if you are completing the course only through the separate exam. In the first case, the grade is composed by the exercises and exam (on the above 33%/67% scheme) in the second case only the exam grade.

Exam instructions (on campus vs remote, open book vs closed book, etc.) are subject to change due to various circumstances. Please check the instructions on the course webpage and Moodle before the exam. Important: Please remember to sign up to separate exams at least 10 days before the exam.

Tools for the exercises

You work on the exercises on your own computer (or in a browser tool when the exercise says so), then discuss them in the exercise sessions. Points are marked there; see Grading above.

What you need

Install the following before the programming exercises. A normal student laptop is enough; you do not need a dedicated GPU.

• Python 3: Required for the programming exercises. Check your version with python3 --version (or python --version on Windows). Use Python 3.10 or newer if possible. Download from python.org if you do not already have it.
• Visual Studio Code (recommended): A free editor that works well with Python. Install it from code.visualstudio.com, then add the official Python extension. You may use another editor if you prefer.
• Terminal / command line: Many exercises use short commands (pip, git, running scripts). On macOS and Linux, use Terminal. On Windows, use PowerShell, Command Prompt, or the terminal built into VS Code.
• pip and virtual environments: Install packages with pip. For exercises that need extra libraries (for example PyTorch or Transformers), create a fresh virtual environment so course packages do not mix with other projects:

  python3 -m venv .venv
  source .venv/bin/activate          # macOS / Linux
  # .venv\Scripts\activate           # Windows
  python -m pip install <packages>

• Git: Needed when an exercise asks you to clone a repository. Install from git-scm.com if git --version does not work in your terminal.

Quick check

After installing Python and VS Code, open a terminal and confirm that these work:

python3 --version
python3 -m pip --version
git --version

If any of these fail, fix the installation before the first programming exercise. Ask on the Moodle discussion forum or in an exercise session if you get stuck.