Obtenir des crédits de formation continue et des crédits universitaires grâce à la formation des éducateurs en IA

Obtenir des crédits de formation continue et des crédits universitaires grâce à une formation pour éducateurs en IA

Un certificat d'achèvement n'est pas un crédit. Cette seule distinction explique pourquoi tant d'éducateurs terminent une série de formations sur l'IA avec un dossier de PDF et ne peuvent toujours pas répondre à la seule question que leur district, leur conseil de certification ou leur registraire posera : à quoi cela correspond-il ?

L'équipe éducation de Google a publié un parcours pour les éducateurs qui souhaitent que leur formation à l'IA soit prise en compte pour la formation continue et les crédits universitaires, décrit sur le blog de Google à l'adresse https://blog.google/products-and-platforms/products/education/college-credit-ai-educator-series. Cet article traite cette page comme le point de départ faisant autorité, explique comment fonctionne généralement la conversion des crédits, puis présente un petit registre installé localement qui maintient votre dossier de preuves prêt pour un audit avant que vous n'en ayez besoin.

Ce que la source établit — et ce qu'elle n'établit pas

La source primaire vérifiée est la page du blog éducation de Google décrivant comment les éducateurs peuvent obtenir des crédits de formation continue et des crédits universitaires pour une formation d'éducateur en IA. C'est la portée des éléments de preuve disponibles ici.

Ce que la page n'établit pas — du moins pas sous une forme que cet article peut affirmer de manière responsable — comprend les totaux précis d'heures de crédit, les montants de frais de scolarité ou de frais, l'identité des institutions partenaires qui accordent les crédits, les règles d'acceptation État par État ou les dates limites d'inscription. Ce sont exactement les détails qui changent le plus souvent et qui varient le plus selon la juridiction. Lisez-les directement sur la page source et auprès de l'institution qui accorde les crédits avant de payer quoi que ce soit ou de promettre un chiffre à votre directeur.

La conséquence pratique : considérez la page Google comme la porte d'entrée, pas comme le contrat. Votre admissibilité, votre coût et le résultat sur votre relevé de notes sont régis par le fournisseur de crédits et par la politique de votre propre État ou district.

Trois monnaies, trois approbations différentes

« Crédit » n'est pas une chose unique. En pratique, les éducateurs rencontrent trois monnaies distinctes, et une même série de formations peut se convertir en certaines, toutes ou aucune d'entre elles selon le fournisseur.

Les unités de formation continue (CEU, Continuing Education Units) sont généralement attribuées par un fournisseur de formation ou une institution accréditée et servent à satisfaire aux exigences de renouvellement de licence ou d'échelon salarial. Elles sont généralement les plus faciles à obtenir et les moins transférables. De nombreux fournisseurs américains utilisent une convention d'environ dix heures de contact par CEU, mais cette convention n'est pas universelle, et ce n'est pas quelque chose que la page source garantit pour une série particulière. Confirmez la formule du fournisseur par écrit.

Les crédits de cycle supérieur (graduate credit) sont délivrés par une université, souvent par une faculté d'éducation, et exigent généralement à la fois les heures de formation et un livrable supplémentaire — un document de réflexion, un portfolio ou un projet appliqué en classe. Les crédits de cycle supérieur sont plus chers et plus transférables.

Les crédits de premier cycle (undergraduate credit) apparaissent moins souvent dans les contextes de développement professionnel, mais se retrouvent dans les parcours d'achèvement de diplôme et dans les demandes d'évaluation des acquis antérieurs, où un portfolio est évalué par rapport aux résultats d'apprentissage d'un cours plutôt que par rapport au temps de présence.

Cette répartition en trois catégories relève de la pratique générale, et non d'une affirmation tirée de la source. Sa valeur est diagnostique : lorsque quelqu'un vous dit qu'une formation « compte pour un crédit », votre question suivante devrait être quelle monnaie, délivrée par qui, et acceptée par quelle autorité.

Exigences

Avant d'installer quoi que ce soit, confirmez que vous pouvez satisfaire aux exigences de documentation. L'outillage ci-dessous est un registre ; il ne peut pas fabriquer des preuves que vous n'avez jamais recueillies.

• Un module de formation terminé. La série de formations pour éducateurs en IA référencée par la page source, ou un programme équivalent que vous avez déjà terminé.
• Documentation du fournisseur. Un certificat d'achèvement, plus un programme ou un ordre du jour qui indique explicitement les heures de contact. Un ordre du jour sans heures est la raison la plus fréquente de rejet d'une soumission.
• Une déclaration d'accréditation ou d'approbation. Un document montrant que le fournisseur est autorisé à délivrer le type de crédit que vous demandez.
• Un artefact de pratique. Un plan de cours, une refonte d'unité ou une évaluation en classe qui montre que vous avez appliqué la formation. Les évaluateurs de crédits de cycle supérieur le demandent presque à chaque fois.
• Les règles institutionnelles. La politique de développement professionnel de votre district, les exigences de renouvellement de votre licence d'État, et — si vous visez un crédit universitaire — le format de demande du registraire ou du bureau d'évaluation des acquis antérieurs.
• Les exigences techniques locales. Python 3.10 ou plus récent, pip, Git et environ 50 Mo d'espace disque. Windows, macOS ou Linux fonctionnent.

Installation étape par étape

L'objectif est un répertoire unique qui contient vos enregistrements, les valide et génère un résumé prêt à être soumis. Suivez les étapes dans l'ordre.

Tout d'abord, confirmez que votre version de Python est suffisamment récente pour la syntaxe d'indication de type utilisée ci-dessous.

python3 --version

Créez le répertoire du projet et ses sous-répertoires en une seule commande, afin que les enregistrements, les modèles et la sortie générée restent séparés.

mkdir -p ai-credit-ledger/{records,templates,output} && cd ai-credit-ledger

Initialisez un dépôt Git afin que chaque modification de votre registre soit versionnée et horodatée — utile si un évaluateur remet en question le moment où un enregistrement a été ajouté.

git init && git branch -M main

Créez un environnement virtuel pour isoler les deux dépendances que vous êtes sur le point d'installer.

python3 -m venv .venv

Sous macOS ou Linux, activez l'environnement avec le script shell qu'il vient de créer.

source .venv/bin/activate

Sous Windows PowerShell, la commande d'activation équivalente est un chemin différent.

py -3 -m venv .venv; .\.venv\Scripts\Activate.ps1

Mettez à jour pip avant d'installer quoi que ce soit, ce qui évite les erreurs de résolution sur les anciennes versions d'amorçage.

python -m pip install --upgrade pip

Installez les deux bibliothèques utilisées par le registre : PyYAML n'est pas requis, mais Jinja2 génère le résumé HTML et rich produit une sortie terminal lisible pour les échecs de validation.

pip install jinja2 rich

Figez les versions résolues afin que votre configuration soit reproductible si vous la déplacez vers un ordinateur portable de district.

pip freeze > requirements.txt

Maintenant, créez le script de registre lui-même.

touch ledger.py

Ouvrez ledger.py et collez ce qui suit. Il définit une structure d'enregistrement, valide chaque entrée par rapport à une liste de contrôle de documentation et génère un résumé.

#!/usr/bin/env python3
"""Track AI educator training hours and assemble a credit-ready evidence packet."""

from __future__ import annotations

import argparse
import csv
import sys
from dataclasses import dataclass, field
from datetime import date
from pathlib import Path

from jinja2 import Environment, FileSystemLoader
from rich.console import Console

ROOT = Path(__file__).resolve().parent
LOG_PATH = ROOT / "records" / "training-log.csv"
TEMPLATE_DIR = ROOT / "templates"
OUTPUT_PATH = ROOT / "output" / "credit-summary.html"

# Confirm your provider's convention before relying on this divisor.
CONTACT_HOURS_PER_CEU = 10.0
REQUIRED_DOCS = ("certificate", "syllabus", "agenda", "accreditation")

console = Console()


@dataclass
class Entry:
    completed_on: date
    title: str
    provider: str
    hours: float
    credit_type: str
    docs: list[str] = field(default_factory=list)

    @property
    def missing_docs(self) -> list[str]:
        return [d for d in REQUIRED_DOCS if d not in self.docs]

    @property
    def ceu(self) -> float:
        return self.hours / CONTACT_HOURS_PER_CEU if self.credit_type == "ceu" else 0.0


def load(path: Path) -> list[Entry]:
    if not path.exists():
        console.print(f"[red]Missing ledger file:[/red] {path}")
        sys.exit(2)
    entries: list[Entry] = []
    with path.open(newline="", encoding="utf-8") as handle:
        for row in csv.DictReader(handle):
            entries.append(
                Entry(
                    completed_on=date.fromisoformat(row["completed_on"].strip()),
                    title=row["title"].strip(),
                    provider=row["provider"].strip(),
                    hours=float(row["hours"]),
                    credit_type=row["credit_type"].strip().lower(),
                    docs=[d.strip().lower() for d in row["docs"].split("|") if d.strip()],
                )
            )
    return entries


def validate(entries: list[Entry]) -> int:
    failures = 0
    seen: set[tuple[str, str]] = set()
    for entry in entries:
        problems = []
        if entry.hours <= 0:
            problems.append("hours must be positive")
        if entry.missing_docs:
            problems.append(f"missing documents: {', '.join(entry.missing_docs)}")
        key = (entry.title.lower(), entry.provider.lower())
        if key in seen:
            problems.append("duplicate title/provider pair")
        seen.add(key)
        if problems:
            failures += 1
            console.print(f"[yellow]{entry.title}[/yellow] -> {'; '.join(problems)}")
        else:
            console.print(f"[green]OK[/green] {entry.title}")
    return failures


def report(entries: list[Entry], output: Path) -> None:
    env = Environment(loader=FileSystemLoader(TEMPLATE_DIR), autoescape=True)
    template = env.get_template("summary.html.j2")
    total_hours = sum(e.hours for e in entries)
    total_ceu = sum(e.ceu for e in entries)
    output.parent.mkdir(parents=True, exist_ok=True)
    output.write_text(
        template.render(
            entries=entries,
            total_hours=total_hours,
            total_ceu=total_ceu,
            complete=all(not e.missing_docs for e in entries),
        ),
        encoding="utf-8",
    )
    console.print(f"[green]Wrote[/green] {output}")


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("command", choices=("validate", "report"))
    args = parser.parse_args()

    entries = load(LOG_PATH)
    if args.command == "validate":
        failures = validate(entries)
        return 1 if failures else 0
    report(entries, OUTPUT_PATH)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Enregistrez le fichier, puis créez le registre avec sa ligne d'en-tête.

printf 'completed_on,title,provider,hours,credit_type,docs\n' > records/training-log.csv

Créez le modèle HTML que la commande report génère.

touch templates/summary.html.j2

Collez ce modèle dans le nouveau fichier. Il affiche un indicateur d'exhaustivité, puis un tableau de chaque entrée avec son équivalent en CEU.

<!doctype html>
<html lang="en">
<head><meta charset="utf-8"><title>AI Training Credit Summary</title></head>
<body>
  <h1>AI Educator Training — Credit Summary</h1>
  <p>Total contact hours: <strong>{{ total_hours }}</strong> ·
     Estimated CEUs: <strong>{{ "%.2f"|format(total_ceu) }}</strong></p>
  <p>Documentation complete for all entries: <strong>{{ complete }}</strong></p>
  <table border="1" cellpadding="6">
    <tr><th>Date</th><th>Title</th><th>Provider</th><th>Hours</th>
        <th>Type</th><th>Documents</th></tr>
    {% for e in entries %}
    <tr>
      <td>{{ e.completed_on }}</td><td>{{ e.title }}</td><td>{{ e.provider }}</td>
      <td>{{ e.hours }}</td><td>{{ e.credit_type }}</td>
      <td>{{ e.docs|join(", ") }}{% if e.missing_docs %} — MISSING: {{ e.missing_docs|join(", ") }}{% endif %}</td>
    </tr>
    {% endfor %}
  </table>
</body>
</html>

Exemples d'utilisation

Ajoutez un enregistrement de formation terminée. La colonne docs utilise des libellés séparés par des barres verticales correspondant aux quatre types de documents requis.

echo '2026-01-15,AI Educator Series Module 1,Example Provider,6,ceu,certificate|syllabus|agenda' >> records/training-log.csv

Exécutez la validation. Le processus se termine avec le statut 1 lorsqu'une entrée échoue, ce qui le rend utilisable dans un script de pré-soumission.

python ledger.py validate

Générez le résumé HTML à partir des mêmes enregistrements.

python ledger.py report

Ouvrez le fichier généré dans un navigateur. Sous macOS, la commande est open ; sous Linux, utilisez xdg-open ; sous Windows, utilisez start.

open output/credit-summary.html

Une exécution réaliste fait immédiatement apparaître la lacune. L'enregistrement ci-dessus ne contient pas la déclaration d'accréditation du fournisseur, donc la validation affiche cette entrée en jaune et nomme le document manquant. C'est là tout l'intérêt : vous trouvez le trou dans votre dossier pendant que vous pouvez encore envoyer un courriel au fournisseur, et non après la date limite du registraire.

Pour un crédit de cycle supérieur, associez la sortie du registre à un court texte narratif. Les évaluateurs veulent un énoncé clair de ce que vous avez appris, de ce que vous avez changé dans votre classe et de la manière dont le changement a été évalué. Limitez-le à une page et joignez l'artefact. Le résumé HTML est l'index ; le texte narratif est l'argument.

Une documentation qui résiste à l'examen

Trois habitudes distinguent les dossiers approuvés des dossiers rejetés.

Nommez les fichiers avec la date et la revendication qu'ils soutiennent — 2026-01-15_certificate_ai-educator-module-1.pdf — plutôt que IMG_4471.pdf. Les évaluateurs traitent des dizaines de soumissions.

Faites correspondre les heures à une source. Si le programme indique six heures de contact et que votre registre indique six, l'examen est trivial. S'ils sont en désaccord, vous avez créé un litige que vous perdrez probablement.

Maintenez la déclaration d'accréditation à jour. Les fournisseurs changent ou perdent parfois leur autorisation de délivrer un type de crédit donné. Une déclaration de l'année de votre inscription peut ne pas être acceptée pour une soumission déposée plus tard, et il vaut la peine de la confirmer directement auprès du fournisseur.

Modes d'échec courants

Le problème le plus fréquent est de considérer un certificat d'achèvement comme suffisant. Il documente la présence, pas les heures de contact, et il indique rarement le type de crédit.

Le deuxième est de présumer la transférabilité. Les CEU approuvées dans un État ou par un district ne sont pas automatiquement acceptées ailleurs, et rien dans la page source ne prime sur les règles locales.

Le troisième est le calendrier rétroactif. De nombreux parcours de crédit exigent que vous demandiez le crédit dans une fenêtre définie après avoir terminé la formation. Si vous terminez une série et déposez les documents un an plus tard, vous pouvez être hors délai.

Questions ouvertes et limites

Cet article ne peut pas vous dire combien coûte le parcours Google, combien de crédits il rapporte, quelle institution les délivre, ou si votre État les accepte. Ces faits relèvent du fournisseur et de votre autorité de certification, et ils changent. Le registre décrit ici organise les réponses que vous obtiendrez, quelles qu'elles soient ; il ne les remplace pas.

La documentation ne garantit pas non plus l'approbation. Les décisions en matière de crédits sont discrétionnaires, prises par un registraire, un conseil d'État ou un comité de district appliquant des critères que vous ne voyez peut-être pas. Des preuves solides augmentent vos chances. Elles ne suppriment pas le décideur.

Conclusion

La distance entre terminer une formation pour éducateurs en IA et détenir un crédit est un problème de documentation, et les problèmes de documentation peuvent être résolus à l'avance. Commencez par la page éducation de Google pour le parcours lui-même, confirmez le type de crédit et le fournisseur auprès de l'institution émettrice, et recueillez les quatre documents — certificat, programme ou ordre du jour, déclaration d'accréditation et artefact — au fur et à mesure plutôt qu'après coup. Ensuite, tenez un registre local comme celui ci-dessus afin que, lorsque la fenêtre de soumission s'ouvre, vous exportiez un rapport au lieu de reconstituer un semestre.