Investir dans les talents mondiaux et la littératie en IA : un guide pratique

Investir dans les talents mondiaux et la littératie en IA : un guide pratique

La plupart des organisations qui stagnent sur l'IA ne stagnent pas à cause de la puissance de calcul. Elles stagnent parce que trop peu de personnes savent lire une fiche de modèle, juger si une réponse générée est ancrée, ou expliquer à un collègue pourquoi un système ne devrait pas être déployé. Combler cet écart est un problème de talents avant d'être un problème d'outillage, et c'est la raison pour laquelle le blog IA de Google documente le travail avec l'UIT sur la formation aux compétences en IA dans le cadre de Grow with Google, présenté explicitement comme un investissement dans les talents mondiaux et la littératie en IA.

Ce guide porte sur la moitié opérationnelle de cette idée. Le matériel source est une annonce d'entreprise, pas une spécification de programme, donc les sections ci-dessous séparent ce qui est vérifiable de ce qui est un choix de conception raisonnable. Les parties techniques — installation, configuration et scripts — sont des choses que vous pouvez exécuter aujourd'hui pour construire et mesurer un programme interne de littératie en IA.

Contexte vérifié, et ce qu'il ne vous dit pas

La source principale de cet article est le billet du blog IA de Google sur l'investissement dans les talents mondiaux et la littératie en IA, publié à l'adresse https://blog.google/company-news/outreach-and-initiatives/grow-with-google/itu-ai-skills-training et daté du 22 septembre 2026. Il décrit une initiative liée à Grow with Google et à la formation aux compétences en IA avec l'UIT.

C'est l'étendue de ce que cet article considère comme établi. Le billet est une annonce, pas un programme, donc il ne précise pas les tailles de cohortes, les taux d'achèvement, les régions prioritaires ou les compétences évaluées. Tout ce qui, ci-dessous, décrit des niveaux, des nombres d'heures ou des seuils de mesure est une proposition d'ingénierie de cet article, et non une affirmation sur la source. Considérez ces chiffres comme des valeurs par défaut de départ à remplacer par les vôtres.

La conséquence pratique : vous ne devriez pas tirer un programme d'un communiqué de presse. Vous devriez retenir l'intention — une littératie en IA large et transfrontalière — puis construire quelque chose de mesurable localement.

Prérequis

Avant d'écrire le moindre support de cours, confirmez que vous disposez de ce qui suit. La liste est délibérément modeste, car un programme de littératie en IA qui exige un cluster de GPU n'atteindra jamais les personnes qui en ont le plus besoin.

Personnes et processus

• Un responsable désigné pour le programme, avec l'autorité de modifier les exigences d'intégration.
• Au moins un facilitateur par région ou groupe linguistique capable d'animer des sessions pratiques.
• Un examen de confidentialité couvrant toute donnée d'apprenant que vous prévoyez de collecter.

Logiciels

• Python 3.10 ou plus récent.
• pip et la capacité de créer des environnements virtuels.
• Git, ou un autre système de contrôle de version, pour le programme lui-même.
• Facultatif : un environnement d'exécution de modèle local tel qu'Ollama, si vous voulez des exercices qui s'exécutent sans envoyer de données à une API externe.

Matériel

• Un ordinateur portable par apprenant avec au moins 8 Go de RAM pour les exercices Python.
• 16 Go de RAM si les apprenants doivent exécuter un petit modèle de langage local pendant les travaux pratiques.
• Aucun GPU requis. Tous les scripts de ce guide s'exécutent sur CPU.

Contraintes d'accès à résoudre en premier

• Les sites hors ligne ou à faible bande passante ont besoin de matériel pré-téléchargé.
• Les coûts de traduction sont réels ; prévoyez un budget pour une relecture par un locuteur natif, pas seulement pour la traduction automatique.
• Certaines régions ont des restrictions sur le transfert transfrontalier de données qui affectent la manière dont vous collectez les évaluations.

Installation étape par étape

L'objectif de cette section est un environnement de travail pour créer des fichiers de programme, exécuter un audit de couverture et générer des questions d'entraînement localement.

Tout d'abord, créez un environnement Python isolé afin que l'outillage du programme n'entre pas en conflit avec les paquets système.

python3 -m venv .venv

Activez-le. La commande diffère selon la plateforme.

source .venv/bin/activate   # macOS and Linux

.venv\Scripts\activate      # Windows PowerShell

Mettez à jour les outils de packaging avant d'installer quoi que ce soit d'autre ; les anciennes versions de pip échouent fréquemment sur les wheels binaires.

python -m pip install --upgrade pip wheel

Installez la chaîne d'outils du programme. Chaque paquet a un rôle : pandas pour l'audit de couverture, mkdocs-material pour le site destiné aux apprenants, fastapi et uvicorn pour une petite API de préparation, et requests pour dialoguer avec un modèle local.

pip install pandas scikit-learn jupyterlab mkdocs-material fastapi "uvicorn[standard]" python-dotenv requests

Ensuite, installez un environnement d'exécution de modèle local. Le script d'installation ci-dessous est la procédure d'installation officielle d'Ollama pour Linux ; les utilisateurs de macOS et Windows doivent utiliser l'installateur de plateforme du même projet.

curl -fsSL https://ollama.com/install.sh | sh

Téléchargez un petit modèle ajusté aux instructions. Les petits modèles sont le bon choix ici : ils s'exécutent sur les ordinateurs portables des apprenants, répondent rapidement et rendent leurs limites visibles, ce qui est en soi un moment pédagogique. Vérifiez la liste actuelle des modèles de l'environnement d'exécution avant de choisir un tag, car les noms disponibles changent avec le temps.

ollama pull llama3.2:3b

Confirmez que le modèle est présent et que le service local répond.

ollama list

Enfin, générez la structure du site de documentation qui hébergera le programme.

mkdocs new program-docs

Servez-le localement pour vérifier la chaîne d'outils de bout en bout. La liaison à toutes les interfaces permet aux facilitateurs du même réseau de le prévisualiser.

cd program-docs
mkdocs serve -a 0.0.0.0:8000

Configuration

Créez un fichier .env à la racine du projet. Garder les noms d'hôtes et les tags de modèle en dehors du code source signifie qu'une région sans accès Internet sortant peut pointer vers un serveur local sans modifier les scripts.

cat > .env <<'EOF'
OLLAMA_HOST=http://localhost:11434
LOCAL_MODEL=llama3.2:3b
DATA_DIR=./data
COHORT_ID=pilot-cohort-01
EOF

Créez le répertoire de données et un fichier d'inventaire des modules. Les colonnes ici définissent l'audit qui suit : chaque module a un niveau, une région, une durée en minutes et un prérequis facultatif.

mkdir -p data
cat > data/modules.csv <<'EOF'
module_id,title,tier,region,minutes,prereq
f01,What a model actually does,foundation,global,45,
f02,Reading a model card,foundation,global,60,f01
f03,Data protection basics,foundation,emea,50,
p01,Prompting for grounded answers,practitioner,global,90,f02
p02,Evaluating outputs,practitioner,global,90,p01
b01,Fine-tuning versus retrieval,builder,global,120,p02
EOF

Enregistrez les pages du programme dans mkdocs.yml afin que la navigation reflète la structure des niveaux plutôt que le système de fichiers.

site_name: Global AI Literacy Program
theme:
  name: material
nav:
  - Home: index.md
  - Foundation: foundation.md
  - Practitioner: practitioner.md
  - Builder: builder.md
  - Facilitation guide: facilitation.md

Exemples d'utilisation

Une fois l'environnement configuré, les trois exemples suivants couvrent les questions qu'un responsable de programme se pose réellement : le programme est-il complet, pouvons-nous générer du matériel d'entraînement sans envoyer de données nulle part, et à quoi ressemble la préparation régionale ?

Auditer la couverture du programme

Ce script lit l'inventaire des modules et signale les niveaux manquants, le temps de présence total par région et les modules qui supposent des connaissances qu'ils n'introduisent jamais.

# coverage_audit.py
import pandas as pd

modules = pd.read_csv("data/modules.csv")

required_tiers = {"foundation", "practitioner", "builder"}
missing_tiers = required_tiers - set(modules["tier"].unique())

minutes_by_region = (
    modules.groupby("region")["minutes"].sum().sort_values(ascending=False)
)

orphans = modules[
    modules["prereq"].isna() & (modules["tier"] != "foundation")
]

print("Missing tiers:", missing_tiers or "none")
print("\nSeat minutes by region:\n", minutes_by_region)
print("\nModules with unmet prerequisites:\n", orphans[["module_id", "title"]])

Exécutez-le après chaque modification du programme.

python coverage_audit.py

La vérification des orphans est la plus importante. Un module praticien sans prérequis est généralement le signe qu'un concept a été supposé plutôt qu'enseigné, ce qui est exactement le mode de défaillance qui rend les programmes de littératie en IA inaccessibles.

Générer des questions d'entraînement avec un modèle local

Ce script appelle l'environnement d'exécution local pour rédiger des questions à choix multiples. L'exécuter localement signifie que les données des apprenants et le contenu préliminaire ne quittent jamais la machine, ce qui simplifie l'examen dans les régions restreintes.

# generate_exercises.py
import json
import os

import requests
from dotenv import load_dotenv

load_dotenv()
HOST = os.getenv("OLLAMA_HOST", "http://localhost:11434")
MODEL = os.getenv("LOCAL_MODEL")

PROMPT = """You are drafting practice items for a workplace AI literacy course.
Write 3 short multiple-choice questions about: {topic}.
Return JSON only, as a list of objects with keys:
question, options (list of 4 strings), answer_index (0-3)."""

def make_items(topic: str) -> list[dict]:
    payload = {
        "model": MODEL,
        "prompt": PROMPT.format(topic=topic),
        "stream": False,
        "format": "json",
    }
    response = requests.post(f"{HOST}/api/generate", json=payload, timeout=180)
    response.raise_for_status()
    return json.loads(response.json()["response"])

if __name__ == "__main__":
    items = make_items("what a large language model does and does not know")
    for item in items:
        print("-", item["question"])

Exécutez-le, puis examinez manuellement chaque question avant qu'elle n'atteigne un apprenant. Les questions générées sont des brouillons, pas des évaluations.

python generate_exercises.py

Exposer la préparation régionale via une API

Ce service renvoie le temps de présence par région par rapport à une base illustrative. Le seuil de 240 minutes est un espace réservé choisi pour la démonstration ; remplacez-le par ce que votre programme décide être le minimum.

# api.py
import pandas as pd
from fastapi import FastAPI

app = FastAPI(title="AI Literacy Readiness API")
BASELINE_MINUTES = 240  # illustrative placeholder

@app.get("/readiness/{region}")
def readiness(region: str):
    modules = pd.read_csv("data/modules.csv")
    subset = modules[modules["region"].str.lower() == region.lower()]
    minutes = int(subset["minutes"].sum())
    return {
        "region": region,
        "modules": len(subset),
        "seat_minutes": minutes,
        "meets_baseline": minutes >= BASELINE_MINUTES,
    }

Démarrez le serveur.

uvicorn api:app --reload --port 8000

Interrogez-le depuis un autre terminal.

curl http://localhost:8000/readiness/global

Une réponse affichant meets_baseline: false pour une région est utile précisément parce qu'elle est inconfortable : elle transforme un engagement vague envers les talents mondiaux en un écart spécifique et contestable.

Mesurer l'impact sans indicateurs de vanité

Les comptages d'achèvement sont faciles à collecter et faciles à manipuler. Trois indicateurs sont plus informatifs.

Intégrité des prérequis. La part des modules dont les prérequis sont réellement couverts par un contenu antérieur. Le script d'audit vous donne cela directement.

Preuves de transfert. Si les apprenants appliquent un concept dans leur propre travail dans une fenêtre fixe après le module. Cela nécessite la contribution des managers, c'est pourquoi le programme a besoin d'un responsable ayant l'autorité organisationnelle.

Qualité de l'escalade. Si les apprenants peuvent identifier quand s'arrêter et demander une révision. Une cohorte qui signale les sorties incertaines est plus précieuse qu'une cohorte qui ne le fait jamais.

Note d'interprétation : ces indicateurs sont proposés ici, et non tirés de la source. Le niveau de détail de la source est celui d'une annonce ; la conception de la mesure est de votre responsabilité.

Garde-fous pratiques pour un déploiement mondial

Localisez les exemples, pas seulement le texte. Un exercice de fiche de modèle utilisant un jeu de données d'embauche européen atterrira différemment dans une région dont le droit du travail est différent.

Supposez une connectivité intermittente. L'environnement d'exécution de modèle local existe exactement pour cette raison ; faites du mode hors ligne la norme pour les travaux pratiques plutôt qu'un repli.

Publiez les limites. Chaque module doit indiquer ce que l'outil ne peut pas faire. Cela réduit le risque que la formation à la littératie devienne une formation à l'adoption sans esprit critique.

Gardez les données des apprenants au minimum. Les résultats d'évaluation sont des données personnelles dans de nombreuses juridictions ; collectez ce que vous pouvez défendre.

Conclusion

L'affirmation vérifiable derrière ce sujet est étroite : une organisation a publiquement présenté les talents mondiaux et la littératie en IA comme un investissement, lié à Grow with Google et à la formation aux compétences en IA de l'UIT. Tout ce qui est opérationnel découle de la prise au sérieux de ce cadrage à plus petite échelle.

Un programme viable ressemble à ceci. Définissez des niveaux, rédigez des modules avec des prérequis explicites, exécutez l'audit de couverture jusqu'à ce que plus rien ne soit orphelin, générez du matériel d'entraînement localement pour que l'examen reste peu coûteux et que les données restent en place, et exposez la préparation comme un nombre que vous devez défendre. Rien de tout cela ne nécessite un gros budget. Cela nécessite de décider que le goulot d'étranglement, ce sont les personnes, et de traiter leurs compétences comme une infrastructure qui vaut la peine d'être mesurée.

Commencez par la liste des requirements, exécutez la séquence d'installation et auditez le programme que vous avez déjà. Les lacunes que vous trouvez dans la première heure sont celles qui valent la peine d'être corrigées en premier.