Evolution of AI

"""Inference with a tiny language model

Large language models generate text one token at a time: they look at the
text so far, estimate a probability for every possible next token, pick one,
and repeat. This example builds a toy "bigram" model (it only looks at the
previous word) so you can see that loop with nothing hidden.

Illustrative: real LLMs use Transformers with billions of parameters and
look at thousands of previous tokens, but the generation loop is the same.
"""
import random
from collections import Counter, defaultdict

corpus = """
an agent uses tools to act . the agent uses memory to plan .
an agent uses search to find facts . an agent plans actions .
an agent reasons about goals . the agent plans the next step .
a model predicts the next word . a model learns patterns from data .
the agent observes feedback . the agent perceives its environment .
"""

# 1) "Training": count which word follows which.
words = corpus.split()
next_counts = defaultdict(Counter)
for prev, nxt in zip(words, words[1:]):
    next_counts[prev][nxt] += 1


def next_word_probs(prev: str) -> dict:
    """Turn raw counts into probabilities for the next word."""
    counts = next_counts[prev]
    total = sum(counts.values())
    return {w: c / total for w, c in counts.most_common()}


# 2) Inference: the autoregressive generation loop.
def generate(prompt: str, max_words: int = 10, temperature: float = 1.0, seed: int = 7) -> str:
    rng = random.Random(seed)
    out = prompt.split()
    for _ in range(max_words):
        probs = next_word_probs(out[-1])
        if not probs:
            break
        if temperature == 0:                      # greedy decoding
            word = max(probs, key=probs.get)
        else:                                     # sampling with temperature
            weights = [p ** (1 / temperature) for p in probs.values()]
            word = rng.choices(list(probs), weights=weights)[0]
        out.append(word)
        if word == ".":
            break
    return " ".join(out)


print("Next-word probabilities after 'agent':")
for w, p in next_word_probs("agent").items():
    print(f"  {w:<10} {p:.2f}")

print("\nGreedy (temperature 0) always picks the most likely word:")
print("  ", generate("the agent", temperature=0))

print("\nSampling (temperature 1.5) gives different text for different random seeds:")
for seed in range(1, 5):
    print("  ", generate("the agent", temperature=1.5, seed=seed))

"""Real model inference: text generation and image understanding

This example downloads two small open models from the Hugging Face Hub:
  1. distilgpt2 for text generation (a small GPT-2 style language model)
  2. CLIP for zero-shot image classification (matches an image to text labels)

CLIP is a vision-language model: it maps images and text into the same
embedding space, which is one of the building blocks of multimodal AI.

Run it in Google Colab (free) or locally after installing the packages.
The first run downloads several hundred MB of model weights.
"""
# %%
# In Colab, install the packages first (remove the leading "!" in a terminal):
# !pip -q install transformers torch pillow requests

# %%
from transformers import pipeline

# 1) Text generation with a small causal language model.
generator = pipeline("text-generation", model="distilgpt2")
result = generator("An AI agent is a system that", max_new_tokens=25, do_sample=False)
print(result[0]["generated_text"])

# %%
# 2) Multimodal: zero-shot image classification with CLIP.
classifier = pipeline("zero-shot-image-classification", model="openai/clip-vit-base-patch32")
image_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
labels = ["a photo of a cat", "a photo of a dog", "a photo of a car", "a diagram"]
for item in classifier(image_url, candidate_labels=labels):
    print(f"{item['label']:<20} {item['score']:.3f}")