Understand it in plain language

Artificial intelligence is a broad field of methods for tasks such as prediction, search, perception, language, and planning. Machine learning is one approach within AI: patterns are fitted from examples. Some AI systems instead use explicitly written rules or search procedures. AI does not automatically mean a chatbot, a neural network, or human-like understanding.

How the AI approach works

Think of AI as the study and engineering of systems that perceive information, reason about possibilities, learn from experience, or select actions toward a goal. An intelligent agent receives observations and acts in an environment. Its success depends on a defined objective and the constraints of that environment. A delivery robot, a chess program, and a text assistant therefore need different abilities and different tests.

There are several ways to build those abilities. Symbolic AI represents facts and rules explicitly: a knowledge base can infer that a device needs service from known symptoms. Search and planning explore possible states and action sequences: a route planner compares paths rather than learning every route from examples. Probabilistic reasoning represents uncertainty, updating beliefs as evidence arrives. Machine learning fits useful patterns from data; deep learning is a family of ML methods that learns representations through multiple neural layers.

These approaches overlap. A robot may use a neural network to detect obstacles, probability to estimate its position, search to plan a route, and hard constraints to prevent unsafe movement. Calling the whole system “AI” tells us less than identifying what each component does. Ask which parts learn, which reason over explicit knowledge, and which enforce requirements.

Begin an AI project with a measurable task, not a model name. Define the input, desired output, available evidence, cost of mistakes, and fallback. Compare against a simple baseline. If a fixed calculation reliably solves the task, adding a model may create unnecessary uncertainty.

Four approaches, different strengths

For probabilistic reasoning, suppose a fault occurs in 1% of devices. A sensor flags 90% of faulty devices but also flags 5% of healthy ones. Out of 1,000 devices we expect about 9 true alerts and 49.5 false alerts. An alert therefore implies roughly 9/58.5 ≈ 15.4% fault probability under these assumptions, not 90%. Prior prevalence matters when interpreting evidence.

Break the idea into steps

1. Define the task: what input arrives and what useful output is needed?
2. Choose a simple baseline before a complex model. A fixed rule may already solve the problem.
3. Evaluate on new examples and decide what to do when the system is wrong.

Worked example: connect the method to the task

Imagine a college help desk. “Which courses require Java?” can be answered from explicit prerequisite facts. “How can I finish these prerequisites in two semesters?” is a planning problem with constraints. “Which support category does this message belong to?” could use supervised ML. “Explain the prerequisite policy in friendly Tamil” could use a language model with retrieved policy text.

The same user interface can hide four different mechanisms. Evaluate factual correctness for prerequisites, feasibility for the plan, classification quality for routing, and source-supported explanations for the answer. A fluent paragraph alone does not establish that all four work.

Algorithm experiment: predict, change, explain

This uniform-cost search compares routes with nonnegative costs. It is an AI search method, not machine learning. Change an edge cost and explain why the chosen route changes.

from heapq import heappush, heappop

# Uniform-cost search: known routes, no training data.
roads = {"A": [("B", 2), ("C", 5)],
         "B": [("C", 1), ("D", 7)],
         "C": [("D", 2)], "D": []}
frontier = [(0, "A", ["A"])]
visited = set()
while frontier:
    cost, place, path = heappop(frontier)
    if place in visited:
        continue
    visited.add(place)
    if place == "D":
        print("route:", " -> ".join(path))
        print("cost:", cost)
        break
    for next_place, step_cost in roads[place]:
        heappush(frontier, (cost + step_cost, next_place,
                            path + [next_place]))

route: A -> B -> C -> D
cost: 5

Change one thing. Run it again.

Run this small, self-contained experiment in standard Python. No package installation or paid API is required. Change the suggested variable and explain the effect on the method before applying it to real data.

Let the editor finish loading, load this example, then press Run.

The free editor uses OneCompiler, an external service. Code you run is sent there. Do not enter passwords, API keys, or private student data. If an example is sent before the editor is ready, wait and load it again.

Apply the idea: check your reasoning

Before you move on

• Explain the main idea without repeating the technical label.
• Identify the approach, its assumptions, and the evidence needed to trust the result.
• Complete the challenge, then compare your reasoning with the answer.

Sources & a deeper next step

The refresh uses primary papers and official documentation. These optional links are in English; you can understand this lesson without reading them first. Product versions and availability can change.

• UC Berkeley CS 188: AI foundations ↗
• Hugging Face: LLM course ↗
• PyTorch: learn the basics ↗