Understanding AI: From… | Presentation #521

Creator prompt

The idea behind this presentation

# PART 1 — AI ## Presentation Goal Introduce beginner IT students to how modern AI systems work. By the end of this section, students should understand: * What AI and generative AI are * How LLMs generate responses * What tokens are * Training vs inference * Different types of AI models * What information an AI actually has access to * Context and context windows * Why hallucinations happen * How RAG gives AI external knowledge * How memory works in AI applications --- # Slide 1 — Part 1: Understanding AI ## Title **Understanding AI** ## Subtitle From prediction to context, knowledge, and memory ## Supporting text Before learning how to prompt AI, we first need to understand what is happening behind the chat box. ## Visual Direction Create a simple progression across the slide: **AI → LLM → Context → Knowledge → Memory** Keep this slide minimal and cinematic. --- # Slide 2 — What Is AI? ## Title **What is Artificial Intelligence?** ## Core Message AI is the broad idea of building machines that can perform tasks that normally require human intelligence. ## Content Examples include: * Understanding language * Recognizing images * Making predictions * Generating content * Solving problems * Making decisions ## Visual Show AI as the largest layer with nested categories: ```text Artificial Intelligence ↓ Machine Learning ↓ Deep Learning ↓ Generative AI ↓ Large Language Models ``` ## Key Takeaway **ChatGPT is AI, but AI is much bigger than ChatGPT.** --- # Slide 3 — Traditional Software vs AI ## Title **Traditional Software vs AI** ## Layout Use a two-column comparison. ### Traditional Software ```text Input ↓ Rules written by developer ↓ Output ``` Example: ```text IF age >= 18 THEN allow registration ``` Characteristics: * Explicit rules * Predictable * Deterministic * Developers define the logic ### AI / Machine Learning ```text Data ↓ Model learns patterns ↓ New Input ↓ Prediction / Generation ``` Characteristics: * Learns patterns from data * Handles ambiguity * Probabilistic * Can generalize to new inputs ## Key Takeaway **Traditional software follows rules. AI learns patterns.** --- # Slide 4 — From AI to Generative AI ## Title **Generative AI Changed the Interface** ## Content Traditional AI often answers questions such as: * Is this spam? * Is this image a cat? * How likely is this customer to leave? Generative AI can create something new: * Text * Images * Code * Audio * Video ## Visual ```text Traditional AI Input → Classification / Prediction Generative AI Input → Generate something new ``` ## Examples ```text Text → ChatGPT / Claude Images → Image generation models Code → Coding models Audio → Speech models Video → Video generation models ``` ## Key Takeaway **Generative AI doesn't just classify information — it creates.** --- # Slide 5 — What Is an LLM? ## Title **Large Language Models** ## Core Definition A Large Language Model is a model trained on enormous amounts of text and other data to learn patterns in language. ## Examples * GPT * Claude * Gemini * Llama * Qwen ## What can an LLM do? * Answer questions * Write text * Summarize * Translate * Generate code * Analyze information * Reason through problems ## Visual ```text Large amounts of data ↓ Training ↓ LLM ↓ Language capabilities ``` ## Key Takeaway **An LLM is the model behind many modern conversational AI systems.** --- # Slide 6 — AI Doesn't Read Words Like We Do ## Title **AI Sees Tokens** ## Core Message LLMs don't process text exactly as humans see sentences. Text is broken into smaller pieces called **tokens**. ## Example ```text "Artificial intelligence is powerful" ↓ ["Artificial", " intelligence", " is", " powerful"] ``` Clarify that real tokenization may split words differently. ## Why Tokens Matter Tokens determine: * How much information a model can process * Context window usage * Input/output length * Processing cost * Generation speed ## Visual Direction Show a sentence transforming into individual blocks. Each token should visually appear as a separate tile. ## Key Takeaway **Language enters an LLM as tokens, not as pages or paragraphs.** --- # Slide 7 — How Does an LLM Generate Text? ## Title **The Next-Token Prediction Machine** ## Core Message At its foundation, an LLM repeatedly predicts what token should come next. ## Example ```text "The capital of France is..." ↓ Paris 92% London 3% Berlin 1% Rome 0.5% ... ``` The model chooses a likely continuation: ```text "The capital of France is Paris." ``` But generation continues one token at a time: ```text Input ↓ Predict next token ↓ Add token to context ↓ Predict next token ↓ Repeat ``` ## Visual Create a looping diagram: **Context → Model → Next Token → Updated Context → Model** ## Key Takeaway **An LLM generates answers by repeatedly predicting what should come next.** --- # Slide 8 — Prediction Can Produce Intelligence ## Title **"Just Prediction" Can Become Surprisingly Powerful** ## Content During training, models encounter patterns involving: * Language * Programming * Mathematics * Arguments * Explanations * Stories * Science * Human reasoning To predict what comes next well, the model learns relationships between these patterns. This creates capabilities such as: ```text Prediction ↓ Language understanding ↓ Pattern recognition ↓ Reasoning-like behavior ↓ Generation ``` ## Important Note Avoid presenting the model as simply "copying sentences from the internet." The model learns statistical representations and relationships. ## Key Takeaway **Learning to predict language requires learning many patterns contained inside language.** --- # Slide 9 — Training vs Inference ## Title **Training vs Inference** ## Layout Two-column comparison. ### Training The model learns. ```text Huge datasets ↓ Training process ↓ Adjust billions of parameters ↓ Trained model ``` Characteristics: * Extremely expensive * Requires large computing infrastructure * Happens before we use the model * Creates the model's learned capabilities ### Inference The model is used. ```text Your input ↓ Trained model ↓ Generated response ``` Characteristics: * Happens when you use the AI * Uses the already-trained model * Generates answers from the current input/context ## Example ```text Training = studying for the exam Inference = answering the exam question ``` ## Key Takeaway **Training creates the model. Inference uses the model.** --- # Slide 10 — Models Are Not All the Same ## Title **Different Models, Different Capabilities** ## Content AI models can differ in: * Intelligence * Reasoning ability * Coding ability * Speed * Cost * Context window * Tool usage * Vision capability * Audio capability * Size ## Visual Use multiple model cards positioned along different dimensions. Example comparison dimensions: ```text Fast ←────────────→ Powerful Cheap ←───────────→ Expensive Small ←───────────→ Large ``` ## Additional Concept ```text Small models → cheaper → faster → easier to run locally Large models → stronger reasoning → more capable → usually more expensive ``` ## Key Takeaway **Choosing an AI model is an engineering tradeoff, not simply choosing "the smartest one."** --- # Slide 11 — Multimodal AI ## Title **AI Is No Longer Just Text** ## Definition Multimodal models can understand or generate multiple types of information. ## Visual ```text ┌── Text │ ├── Images │ INPUT ──────────────┼── Audio │ ├── Video │ └── Documents ↓ AI ↓ Response ``` ## Example A multimodal AI may receive: * A screenshot * A question * A PDF * An audio recording and reason across them together. ## Key Takeaway **Modern AI systems can work across multiple forms of information.** --- # Slide 12 — What Does an AI Actually Know? ## Title **Where Does an AI's Knowledge Come From?** ## Core Message When an AI answers a question, several different sources of information may be involved. ## Visual Create three large blocks: ### 1. Training Knowledge ```text Information and patterns learned during training ``` ### 2. Current Context ```text Information provided during this interaction ``` ### 3. External Information ```text Search Databases Documents APIs Tools ``` All three feed toward: ```text LLM ↓ Response ``` ## Important Distinction The AI does **not automatically know everything happening right now**. It may need external systems to retrieve current or private information. ## Key Takeaway **Training knowledge, current context, and external knowledge are different things.** --- # Slide 13 — Context ## Title **Context: What the Model Can See Right Now** ## Definition Context is the information available to the model while it generates its response. ## Visual ```text ┌─────────────────────────────────┐ │ CONTEXT │ │ │ │ System instructions │ │ Conversation history │ │ Current user request │ │ Uploaded documents │ │ Retrieved information │ │ Tool results │ │ │ └────────────────┬────────────────┘ ↓ LLM ↓ Response ``` ## Example ### Poor Context ```text User: "What should I learn next?" ``` The model knows very little. ### Better Context ```text I'm a second-year CS student. I know: - JavaScript - Basic React Goal: Become a backend developer. I haven't studied databases yet. What should I learn next? ``` ## Key Takeaway **The same model can give very different answers depending on the context it receives.** --- # Slide 14 — Context Changes the Answer ## Title **Same Model. Same Question. Different Context.** ## Layout Use three side-by-side examples. ### Person A ```text Context: Beginner CS student Question: "What should I learn next?" Answer: Programming fundamentals, Git, databases... ``` ### Person B ```text Context: Senior backend engineer Question: "What should I learn next?" Answer: Distributed systems, observability, architecture... ``` ### Person C ```text Context: Marketing professional Question: "What should I learn next?" Answer: Analytics, automation, AI workflows... ``` ## Main Statement # Context changes the meaning of a request. ## Key Takeaway **Good AI results depend not only on the model, but on what the model knows about the situation.** --- # Slide 15 — Context Window ## Title **AI Cannot See Infinite Information** ## Definition A **context window** is the maximum amount of information a model can work with at one time. ## Visual ```text ┌──────────────────────────────┐ │ CONTEXT WINDOW │ │ │ │ Instructions │ │ │ │ Conversation │ │ │ │ Documents │ │ │ │ Retrieved knowledge │ │ │ │ Current question │ │ │ │ Model's generated response │ │ │ └──────────────────────────────┘ LIMITED SIZE ``` ## Analogy Think of it as the model's **working desk**. You may own an entire library, but only a limited amount of information can be placed on the desk at once. ## Key Takeaway **The model can only reason over information available inside its current context.** --- # Slide 16 — More Context Is Not Always Better ## Title **Good Context ≠ Maximum Context** ## Content Three common problems: ### Too Little Context ```text "Fix the problem." ``` The model doesn't know what problem. ### Wrong Context ```text Incorrect or outdated information ↓ Incorrect reasoning ``` ### Too Much Irrelevant Context ```text 100 pages provided ↓ Only 2 pages matter ↓ Important information becomes harder to identify ``` ## Main Statement # Relevant context > More context ## Key Takeaway **The goal is to provide the right information at the right time.** --- # Slide 17 — Hallucinations ## Title **Why Does AI Sometimes Make Things Up?** ## Definition A hallucination occurs when an AI generates information that sounds plausible but is incorrect, unsupported, or invented. ## Visual ```text Question ↓ Model predicts a plausible continuation ↓ Insufficient / incorrect knowledge ↓ Confident-looking response ↓ Potential hallucination ``` ## Why It Happens LLMs are fundamentally optimized to generate likely continuations. They are not databases that guarantee factual truth. ## Examples An AI may: * Invent a source * Give an incorrect date * Create a nonexistent API * Misremember a fact * Fill missing information with a plausible guess ## Key Takeaway **Fluent does not automatically mean factual.** --- # Slide 18 — How Do We Reduce Hallucinations? ## Title **Ground the Model** ## Content Instead of asking the model to rely only on what it learned during training: Give it reliable information. ```text Question + Reliable source ↓ LLM ↓ Grounded response ``` Sources might include: * Company documentation * University notices * Product databases * Research papers * Current web information * Internal knowledge bases ## Transition This leads to an important technique: # Retrieval-Augmented Generation --- # Slide 19 — RAG ## Title **RAG — Retrieval-Augmented Generation** ## Definition RAG means retrieving relevant information from an external knowledge source and giving it to the model before it answers. ## Visual ```text USER QUESTION ↓ "Search first" ↓ ┌─────────────────────┐ │ Knowledge Base │ │ │ │ Documents │ │ Policies │ │ Articles │ │ Company knowledge │ └──────────┬──────────┘ ↓ Relevant information ↓ CONTEXT ↓ LLM ↓ ANSWER ``` ## Example Student asks: ```text "When is Semester 7 registration?" ``` The model may not know. RAG system: ```text Question ↓ Search university notices ↓ Find registration notice ↓ Give notice to LLM ↓ Generate answer ``` ## Key Takeaway **RAG lets an AI answer using knowledge it was not originally trained on.** --- # Slide 20 — Why RAG Matters ## Title **The Model Doesn't Need to Memorize Everything** ## Content Without RAG: ```text Knowledge must already exist inside the model's training ``` With RAG: ```text LLM + External knowledge = More useful AI application ``` ## RAG Can Provide * Current information * Private company knowledge * User documents * Product catalogs * Policies * Research * Domain-specific knowledge ## Main Statement # Retrieve first. Generate second. ## Key Takeaway **Modern AI applications often separate intelligence from knowledge.** --- # Slide 21 — Context vs Knowledge Base ## Title **Your Knowledge Base Is Not the Context** ## Core Concept Imagine a company has: ```text 100,000 documents ``` We should not send all 100,000 documents to the model. Instead: ```text 100,000 documents ↓ Search ↓ 3 relevant documents ↓ Context ↓ LLM ``` ## Visual ```text KNOWLEDGE BASE ████████████████████████████ ↓ retrieval RELEVANT INFORMATION ███ ↓ CONTEXT WINDOW ┌───────────────────┐ │ ███ │ │ User question │ └───────────────────┘ ``` ## Key Takeaway **Retrieval decides what knowledge deserves to enter the context.** --- # Slide 22 — Memory ## Title **What Does "Memory" Mean in AI?** ## Core Message Context and memory are related, but they are not the same thing. ## Comparison ### Context ```text Information available to the model RIGHT NOW ``` ### Memory ```text Information stored so it can be used LATER ``` ## Visual ```text Conversation ↓ Important information ↓ MEMORY ↓ Stored for later ↓ Future conversation ↓ Retrieve memory ↓ Add to context ↓ LLM ``` ## Key Takeaway **Memory stores information. Context is what the model currently sees.** --- # Slide 23 — How AI Memory Works ## Title **Memory Usually Lives Outside the Model** ## Core Message An application may store memories in systems such as: * SQL databases * NoSQL databases * Vector databases * User profiles * Files * Knowledge graphs ## Visual ```text ┌──────────────┐ │ MEMORY │ │ │ │ Preferences │ │ Past facts │ │ Goals │ │ History │ └──────┬───────┘ │ retrieve ↓ User ───────────────→ CONTEXT ↓ LLM ↓ Response ``` ## Example Conversation today: ```text User: "I'm learning backend development with NestJS." ``` Application stores: ```text User goal: Learn backend development Current technology: NestJS ``` Later: ```text User: "What should I learn next?" ``` Relevant memory is retrieved and added to context. ## Key Takeaway **For an LLM to use memory, the relevant memory usually has to come back into its context.** --- # Slide 24 — The Relationship So Far ## Title **Putting the Pieces Together** ## Visual Make this the main diagram of the section. ```text TRAINING │ ▼ ┌─────────┐ │ LLM │ └────┬────┘ │ receives CONTEXT │ ┌──────────┼──────────┐ │ │ │ ▼ ▼ ▼ User Input RAG Memory │ │ Knowledge Past info │ │ └─────┬─────┘ │ ▼ CONTEXT │ ▼ LLM │ ▼ RESPONSE ``` ## Final Message At this point we have four fundamentally different concepts: ### Model The intelligence engine. ### Context What the model sees right now. ### RAG How we retrieve external knowledge. ### Memory How useful information survives across interactions. ## Key Takeaway # Better AI isn't only about a better model. # It is also about giving the model the right information.

Understanding AI: From… | Presentation #521 | Presenton

Understanding AI: From Prediction to Context, Knowledge, and Memory

The idea behind this presentation

About this Understanding AI: From Prediction to Context, Knowledge, and Memory presentation example

Three things to review before creating your version

Story structure

Visual hierarchy

Design consistency

Turn inspiration into an original presentation