E-learning : IA, LLM, MCP et Tenseurs

IA (Intelligence Artificielle)

L'IA permet aux machines d'effectuer des taches qui demandent habituellement une intelligence humaine, comme la classification et la prediction.

# Simple threshold classifier
loans = [1200, 3400, 900, 5100, 2200]
threshold = 2500
labels = ["high" if x >= threshold else "low" for x in loans]
print("Loans:", loans)
print("Risk labels:", labels)

Pas a pas

Define a rule and a threshold.
Compute one label per observation.
Compare output labels with your expected risk classes.
This is a deterministic classifier baseline before neural models.

Mathematique derriere

y = 1 if x >= t else 0

Sortie attendue: Risk labels: ['low', 'high', 'low', 'high', 'low']

LLM (Large Language Model)

Un LLM est un modele de langage entraine sur de grands volumes de texte pour generer, resumer et transformer du contenu.

# Tiny toy language model with bigram counts
text = "ai helps teams make better decisions with data"
words = text.split()
bigrams = {}
for i in range(len(words) - 1):
    pair = (words[i], words[i + 1])
    bigrams[pair] = bigrams.get(pair, 0) + 1
print("Bigrams:")
for pair, count in sorted(bigrams.items()):
    print(f"{pair}: {count}")

Pas a pas

Split text into tokens.
Count each adjacent token pair.
Use counts to estimate next-word likelihood.
This is the conceptual bridge to autoregressive LLM decoding.

Mathematique derriere

P(w_t|w_{t-1}) ~= count(w_{t-1}, w_t) / count(w_{t-1})

Sortie attendue: Bigrammes avec paires de tokens et comptes, ex: ('ai', 'helps'): 1

MCP (Model Context Protocol)

MCP standardise la facon dont les outils fournissent du contexte aux modeles, avec des integrations plus sures et previsibles.

# MCP-like context payload (tool + request + constraints)
context = {
    "user_intent": "summarize monthly sales",
    "tool": "sql_query",
    "constraints": ["read_only", "tenant_isolation"],
}
print("Context keys:", list(context.keys()))
print("Tool selected:", context["tool"])

Pas a pas

Collect user intent.
Attach tool and constraints metadata.
Pass context to model and execute deterministic tool call.
Observe that routing quality depends on context quality.

Mathematique derriere

Decision = argmax score(tool_i | context)

Sortie attendue: Context keys: ['user_intent', 'tool', 'constraints'] Tool selected: sql_query

Tenseurs

Un tenseur est une structure n-dimensionnelle pour representer les donnees en IA et deep learning (vecteurs, matrices, volumes).

# Tensor basics using nested lists (2D matrix)
matrix = [
    [1, 2, 3],
    [4, 5, 6],
]
rows = len(matrix)
cols = len(matrix[0])
col_sums = [sum(matrix[r][c] for r in range(rows)) for c in range(cols)]
print("Shape:", (rows, cols))
print("Column sums:", col_sums)

Pas a pas

Represent data as matrix X (rows, cols).
Compute summaries per axis.
Reuse same structure for transformations.
The same concept scales to 3D/4D tensors for batches and channels.

Mathematique derriere

X in R^(m x n), s_j = sum_i X_ij

Sortie attendue: Shape: (2, 3) Column sums: [5, 7, 9]

PyTorch (reseau neuronal minimal)

Exemple simple avec couches lineaires pour voir les tenseurs d'entree et de sortie.

# Minimal PyTorch forward pass
try:
    import torch
except Exception as e:
    print("PyTorch not available:", e)
else:
    torch.manual_seed(0)
    x = torch.randn(4, 3)
    model = torch.nn.Sequential(
        torch.nn.Linear(3, 4),
        torch.nn.ReLU(),
        torch.nn.Linear(4, 1),
    )
    y = model(x)
    print("Input shape:", tuple(x.shape))
    print("Output shape:", tuple(y.shape))
    print("First output:", float(y[0, 0]))

Pas a pas

Create input tensor x with shape [batch, features].
Apply linear layer, non-linearity, then output layer.
Inspect output shape and first prediction value.

Mathematique derriere

y = W2 * ReLU(W1 * x + b1) + b2

Sortie attendue: Input shape: (4, 3) Output shape: (4, 1) First output: valeur numerique

TensorFlow (Keras minimal)

Exemple Sequential simple pour comprendre l'inference par lot.

# Minimal TensorFlow/Keras forward pass
try:
    import tensorflow as tf
except Exception as e:
    print("TensorFlow not available:", e)
else:
    tf.random.set_seed(0)
    x = tf.random.normal((4, 3))
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(4, activation="relu"),
        tf.keras.layers.Dense(1),
    ])
    y = model(x)
    print("Input shape:", x.shape)
    print("Output shape:", y.shape)
    print("First output:", float(y[0, 0]))

Pas a pas

Build a Sequential model with Dense layers.
Feed batch tensor and run forward inference.
Read tensor shape and sample output.

Mathematique derriere

Dense(x) = activation(x * W + b)

Sortie attendue: Input shape: (4, 3) Output shape: (4, 1) First output: valeur numerique

Mini LLM pedagogique

Modele de langage tres petit (bigrammes) pour enseigner tokens, logits et probabilites.

# Tiny LLM teaching model (char-level bigram logits)
try:
    import torch
except Exception as e:
    print("PyTorch not available:", e)
else:
    text = "hello llm"
    vocab = sorted(set(text))
    stoi = {c: i for i, c in enumerate(vocab)}
    itos = {i: c for c, i in stoi.items()}

    ids = torch.tensor([stoi[c] for c in text], dtype=torch.long)
    model = torch.nn.Embedding(len(vocab), len(vocab))
    logits = model(ids)
    probs = torch.softmax(logits[-1], dim=-1)

    top_p, top_i = torch.topk(probs, k=min(3, len(vocab)))
    print("Vocab:", vocab)
    print("Last input token:", repr(itos[int(ids[-1])]))
    print("Top next-token probabilities:")
    for p, i in zip(top_p, top_i):
        print(itos[int(i)], round(float(p), 4))

Pas a pas

Build a character vocabulary and token IDs.
Use embedding table as learnable logits producer.
Apply softmax and read top-k next-token probabilities.

Mathematique derriere

p(next) = softmax(logits_last_token)

Sortie attendue: Vocab: [...] Last input token: ... Top next-token probabilities: 3 lignes token-probabilite

RAG (Retrieval-Augmented Generation)

Le RAG combine recherche de contexte + generation pour des reponses plus fiables et auditables.

# Tiny RAG demo (keyword overlap retrieval + prompt assembly)
docs = [
    "LGPD requires lawful basis, consent management, and data subject rights.",
    "Dedicated AI servers provide tenant isolation and private GPU workloads.",
    "RAG improves answer grounding by injecting retrieved context into prompts.",
]
query = "How to run AI servers with LGPD compliance?"

q_terms = set(w.strip('.,!?').lower() for w in query.split())
scored = []
for d in docs:
    d_terms = set(w.strip('.,!?').lower() for w in d.split())
    score = len(q_terms & d_terms)
    scored.append((score, d))

scored.sort(reverse=True, key=lambda x: x[0])
top_doc = scored[0][1]
prompt = f"Question: {query}\nContext: {top_doc}\nAnswer:"

print("Query:", query)
print("Top document:", top_doc)
print("Prompt preview:", prompt[:120] + "...")

Pas a pas

1) Indexez une petite base de connaissance (documents).
2) Recuperez le meilleur contexte pour la question.
3) Construisez le prompt final avec question + contexte recupere.

Mathematique derriere

argmax_d sim(query, doc_d) -> prompt = [query + top_doc]

Sortie attendue: Query: ... Top document: ... Prompt preview: ...

Beyond data

E-learning : IA, LLM, MCP et Tenseurs

Requirements for full ML examples

IA (Intelligence Artificielle)

LLM (Large Language Model)

MCP (Model Context Protocol)

Tenseurs

PyTorch (reseau neuronal minimal)

TensorFlow (Keras minimal)

Mini LLM pedagogique

RAG (Retrieval-Augmented Generation)

Services IA dedies