# AI For Beginners Learning Objectives: A Complete Lesson-by-Lesson Guide

> Discover the AI For Beginners learning objectives for each lesson. Explore symbolic AI, perceptrons, CNNs, transformers, reinforcement learning, and AI ethics with this comprehensive guide.

- Repository: [Microsoft/AI-For-Beginners](https://github.com/microsoft/AI-For-Beginners)
- Tags: getting-started
- Published: 2026-08-19

---

**TLDR:** Every lesson in the `microsoft/AI-For-Beginners` repository defines concrete learning objectives in its [`README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/README.md), ranging from symbolic AI and perceptrons to convolutional networks, transformers, reinforcement learning, and AI ethics.

The open-source `microsoft/AI-For-Beginners` curriculum structures artificial intelligence into a progressive series of lessons, each anchored by measurable outcomes stated directly in the source markdown files. Reviewing the AI For Beginners learning objectives before you start ensures you know exactly which concepts—such as knowledge representation, back-propagation, or multi-modal retrieval—you will master in each module.

## Core AI Foundations

### Lesson 1: Introduction to AI

According to [`lessons/1-Intro/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/1-Intro/README.md), learners completing this module will be able to:

- Define **artificial intelligence** and differentiate *weak* vs. *strong* AI.
- Explain the **top-down** (symbolic) and **bottom-up** (neural) approaches.
- Summarize key milestones in AI history and the **Turing Test**.
- Identify AI-enabled tasks in everyday life.

The lesson also provides [`lessons/1-Intro/assignment.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/1-Intro/assignment.md) for self-assessment. A simple rule-based demonstration of weak AI is shown below:

```python
def turing_test_responder(user_input: str) -> str:
    # Very simple rule-based chatbot (weak AI)

    if "hello" in user_input.lower():
        return "Hi there! I'm a simple AI."
    return "I don't understand that yet."

```

### Lesson 2: Symbolic AI

As documented in [`lessons/2-Symbolic/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/2-Symbolic/README.md), this lesson covers classical knowledge-based methods. By the end, you should be able to:

- Describe **knowledge representation** (data → information → knowledge → wisdom).
- Use **semantic networks**, **frames**, **triplets**, and **logic** to model knowledge.
- Build simple **expert-system** rules and perform forward/backward inference.
- Understand ontologies, the Semantic Web, and tools such as **RDF/OWL**.

The accompanying notebook `lessons/2-Symbolic/Animals.ipynb` lets you experiment with symbolic structures interactively. A minimal forward-inference engine looks like this:

```python
rules = [
    ("fever", "infection"),
    ("cough", "respiratory_issue")
]

def infer(symptoms):
    for s, diagnosis in rules:
        if s in symptoms:
            return diagnosis
    return "unknown"

```

## Neural Networks and Deep Learning

### Lesson 3: Neural Networks

The objectives in [`lessons/3-NeuralNetworks/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/README.md) focus on the mathematical and practical foundations of neural computation. Learners will be able to:

- Explain the **perceptron** model and its limitations.
- Construct a **multilayer perceptron** (MLP) and train it with **back-propagation**.
- Compare common activation functions (**sigmoid**, **ReLU**, **tanh**).
- Evaluate model performance (accuracy, loss) and avoid over-fitting.

You can practice these concepts in `lessons/3-NeuralNetworks/Perceptron.ipynb`. A minimal TensorFlow implementation of a single-layer perceptron is:

```python
import tensorflow as tf
import numpy as np

X = np.array([[0,0],[0,1],[1,0],[1,1]], dtype=float)
y = np.array([[0],[0],[0],[1]], dtype=float)      # AND gate

model = tf.keras.Sequential([
    tf.keras.layers.Dense(1, activation='sigmoid')
])
model.compile(optimizer='sgd', loss='binary_crossentropy')
model.fit(X, y, epochs=200, verbose=0)

print(model.predict(X).round())

```

## Applied AI: Vision and Language

### Lesson 4: Computer Vision

[`lessons/4-ComputerVision/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/README.md) targets visual understanding pipelines. Objectives include the ability to:

- Load and preprocess images with **OpenCV** / **TensorFlow**.
- Implement classic CV pipelines (edge detection, filtering, histogram equalisation).
- Build and train **Convolutional Neural Networks** for image classification.
- Explore **object detection** (YOLO/SSD) and **image segmentation** (U-Net).

The source includes [`lessons/4-ComputerVision/07-ConvNets/pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/pytorchcv.py) for PyTorch-based CNN experiments. A simple training loop for MNIST is shown below:

```python
import torch, torchvision
from torch import nn, optim
from torchvision import datasets, transforms

transform = transforms.Compose([transforms.ToTensor()])
train = datasets.MNIST(root='data', train=True, download=True, transform=transform)
loader = torch.utils.data.DataLoader(train, batch_size=64, shuffle=True)

class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = nn.Conv2d(1, 32, 3, 1)
        self.fc   = nn.Linear(5408, 10)

    def forward(self, x):
        x = torch.relu(self.conv(x))
        x = x.view(x.size(0), -1)
        return self.fc(x)

model = SimpleCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

for epoch in range(1):
    for img, label in loader:
        optimizer.zero_grad()
        output = model(img)
        loss = criterion(output, label)
        loss.backward()
        optimizer.step()

```

### Lesson 5: Natural Language Processing

Per [`lessons/5-NLP/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/README.md), the NLP module teaches text processing from bag-of-words to transformers. Learners will be able to:

- Tokenise, lemmatise, and vectorise text (**Bag-of-Words**, **TF-IDF**).
- Use pre-trained word embeddings (**Word2Vec**, **GloVe**).
- Build simple **RNN/LSTM** models for text classification.
- Apply **transformers** (BERT, GPT-2) for downstream tasks.

The notebook `lessons/5-NLP/01-TextClassification.ipynb` demonstrates these techniques in practice. A scikit-learn baseline for text classification is:

```python
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline

data = fetch_20newsgroups(subset='train')
pipe = make_pipeline(TfidfVectorizer(max_features=2000), LogisticRegression())
pipe.fit(data.data, data.target)
print(pipe.predict(["SpaceX launches another rocket"]))  # → newsgroup index

```

## Specialized and Emerging Topics

### Lesson 6: Deep Reinforcement Learning

The [`lessons/6-Other/22-DeepRL/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/22-DeepRL/README.md) file outlines RL fundamentals. By the end of this lesson, you should be able to:

- Define reinforcement-learning terminology (**agents**, **environments**, **rewards**).
- Implement a **Q-learning** algorithm for discrete tasks.
- Train a **Deep Q-Network** (DQN) on OpenAI-Gym environments.
- Analyse exploration vs. exploitation strategies.

A minimal Q-learning loop for a grid-world task appears in the associated lab materials ([`lessons/6-Other/22-DeepRL/lab/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/22-DeepRL/lab/README.md)):

```python
import numpy as np

Q = np.zeros((5,5,4))                 # 5×5 grid, 4 actions

lr, gamma, eps = 0.1, 0.9, 0.2

def step(state, action):
    # returns next_state, reward, done

    ...

for _ in range(1000):
    s = (0,0)
    while True:
        if np.random.rand() < eps:
            a = np.random.choice(4)
        else:
            a = np.argmax(Q[s])
        ns, r, done = step(s, a)
        Q[s][a] += lr * (r + gamma * np.max(Q[ns]) - Q[s][a])
        s = ns
        if done: break

```

### Genetic Algorithms

According to [`lessons/6-Other/21-GeneticAlgorithms/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/21-GeneticAlgorithms/README.md), this sub-module teaches evolutionary computation. Objectives include the ability to:

- Explain the concepts of **population**, **chromosome**, **fitness**, **crossover**, and **mutation**.
- Write a simple GA to optimise a mathematical function.
- Observe convergence behaviour and parameter tuning.

### Multi-Agent Systems

As stated in [`lessons/6-Other/23-MultiagentSystems/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/23-MultiagentSystems/README.md), learners will be able to:

- Model interactions among multiple autonomous agents.
- Design simple coordination protocols (e.g., voting, negotiation).
- Simulate a multi-agent environment (e.g., predator-prey).

The assignment file [`lessons/6-Other/23-MultiagentSystems/assignment.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/23-MultiagentSystems/assignment.md) provides exercises to test these skills.

## Ethics and Future Directions

### Lesson 7: AI Ethics

[`lessons/7-Ethics/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/7-Ethics/README.md) shifts focus to responsible AI development. Learners will be able to:

- Identify ethical concerns (**bias**, **privacy**, **accountability**).
- Apply the **AI Ethics** framework (fairness, transparency, robustness).
- Discuss real-world case studies (facial recognition, autonomous weapons).

You can explore these topics further in [`lessons/7-Ethics/assignment.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/7-Ethics/assignment.md). A simple programmatic check for dataset bias is:

```python
import pandas as pd

df = pd.read_csv('loan_data.csv')
fairness = df.groupby('gender')['approved'].mean()
print(fairness)   # compare approval rates between genders

```

### X-Extras: Multi-Modal AI

The [`lessons/X-Extras/X1-MultiModal/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/X-Extras/X1-MultiModal/README.md) lesson covers cross-modal systems. Objectives include the ability to:

- Combine vision and language modalities in a single model.
- Build a simple **image-captioning** pipeline using a pre-trained encoder-decoder.
- Evaluate cross-modal retrieval performance.

The lab directory [`lessons/X-Extras/X1-MultiModal/lab/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/X-Extras/X1-MultiModal/lab/README.md) supports hands-on practice. Below is a minimal example using Hugging Face Transformers:

```python
from transformers import VisionEncoderDecoderModel, ViTImageProcessor, AutoTokenizer
from PIL import Image

model = VisionEncoderDecoderModel.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
processor = ViTImageProcessor.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
tokenizer = AutoTokenizer.from_pretrained("nlpconnect/vit-gpt2-image-captioning")

image = Image.open('sample.jpg')
pixel_values = processor(images=image, return_tensors="pt").pixel_values
output_ids = model.generate(pixel_values, max_length=16, num_beams=4)
print(tokenizer.decode(output_ids[0], skip_special_tokens=True))

```

## Summary

- Each lesson in `microsoft/AI-For-Beginners` declares specific, measurable **learning objectives** inside its [`README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/README.md).
- The curriculum moves sequentially from **symbolic AI** and **perceptrons** to **CNNs**, **RNNs**, **transformers**, and **reinforcement learning**.
- Specialized modules cover **genetic algorithms**, **multi-agent systems**, **AI ethics**, and **multi-modal** architectures.
- Most lessons pair theory with executable notebooks and lab assignments, such as `Perceptron.ipynb`, [`pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/pytorchcv.py), and `01-TextClassification.ipynb`, so you can implement what you learn immediately.

## Frequently Asked Questions

### Where are the learning objectives for each lesson documented?

Every lesson’s learning objectives are recorded in the lesson-level [`README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/README.md) files—for example, [`lessons/3-NeuralNetworks/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/3-NeuralNetworks/README.md), [`lessons/5-NLP/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/5-NLP/README.md), and [`lessons/7-Ethics/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/7-Ethics/README.md).

### Does every AI For Beginners lesson include hands-on code?

Yes. As implemented in `microsoft/AI-For-Beginners`, lessons supply runnable notebooks and scripts. Notable files include `lessons/3-NeuralNetworks/Perceptron.ipynb`, [`lessons/4-ComputerVision/07-ConvNets/pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/pytorchcv.py), and `lessons/5-NLP/01-TextClassification.ipynb`.

### Which machine-learning frameworks does the curriculum use?

The repository uses **TensorFlow** and **PyTorch** for neural networks, **scikit-learn** for classical NLP baselines, **OpenCV** for computer vision preprocessing, and **Hugging Face Transformers** for modern NLP and multi-modal tasks.

### Are there assignments to verify you have met the learning objectives?

Yes. Many lessons contain an [`assignment.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/assignment.md) or a [`lab/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lab/README.md) for assessment. Examples include [`lessons/6-Other/22-DeepRL/lab/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/22-DeepRL/lab/README.md), [`lessons/6-Other/21-GeneticAlgorithms/lab/README.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/6-Other/21-GeneticAlgorithms/lab/README.md), and [`lessons/7-Ethics/assignment.md`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/7-Ethics/assignment.md).