Professor: gerar exercices

#Por que preparar os exercícios com um modelo local

As diretrizes de uso da IA na educação publicadas pelo ministério em junho de 2025, conforme resumidas pelos órgãos regionais de educação, permitem o uso para preparação de aulas, avaliação e correção, com duas obrigações para o professor: verificar sistematicamente o conteúdo produzido pela IA e ser transparente sobre seu uso. Elas proíbem expressamente o uso de dados pessoais ou confidenciais em ferramentas de IA voltadas ao público em geral e recomendam priorizar soluções livres. Um modelo local atende a esses três pontos: nada sai do computador, não é necessário se cadastrar e os modelos open-weight são soluções livres no sentido comum do termo.

É preciso fazer uma ressalva sobre um argumento frequentemente apresentado: preparar um exercício de matemática com um serviço voltado ao público em geral continua sendo permitido desde que nenhum dado pessoal seja inserido. A vantagem de executar o modelo localmente está em outros aspectos. Isso permite trabalhar com documentos que contêm nomes, como provas de alunos ou comentários avaliativos, sem expor os alunos. Funciona sem conexão. E oferece um comportamento estável: uma instrução salva, um modelo que não muda de um mês para o outro.

Alunos e trabalhos escolares

Nunca inserir nomes, trabalhos de alunos identificáveis ou avaliações em um serviço online. Localmente, o risco de transferência desaparece, mas a regra de minimização continua sendo um bom hábito.

Custo

Sem assinatura. Você já tem o hardware necessário se seu computador recente tiver 16 GB de memória; caso contrário, um modelo pequeno é suficiente para exercícios simples.

Offline

Útil na sala dos professores ou em uma instituição de ensino cuja rede filtra os serviços de IA.

Estabilidade

Uma instrução salva em um modelo personalizado gera fichas homogêneas de uma semana para outra.

#Pilha mínima

Você pode escolher entre dois softwares para servir o modelo: Ollama, pela linha de comando, ou LM Studio, com uma interface gráfica mais acessível se o terminal incomoda você. Quanto ao modelo, o Qwen 3.5 com 9 bilhões de parâmetros pesa 6,6 GB na biblioteca Ollama e anuncia 256.000 tokens de contexto: cabe em uma placa de 8 GB ou na memória de um computador recente. O Mistral Small 24B pesa 14 GB e exige mais memória. Um modelo maior não garante exatidão; a sua revisão é que garante isso.

Para não precisar digitar sua instrução novamente, crie um modelo personalizado com um arquivo Modelfile: a instrução SYSTEM nele define a mensagem de sistema aplicada a cada conversa. O arquivo abaixo fixa o papel, o nível e o estilo de suas fichas.

FROM qwen3.5:9b
PARAMETER temperature 0.4
PARAMETER num_ctx 8192
SYSTEM """Tu aides un professeur de collège à préparer des exercices conformes aux programmes
français du cycle 4. Vocabulaire adapté à l'âge des élèves. Tu ne donnes que des
corrigés dont tu es sûr ; sinon tu écris : à vérifier. Tu n'inventes jamais de citation,
de date ou de source."""

ollama create prof-exos -f Modelfile
ollama run prof-exos

#Gerar questionários de múltipla escolha utilizáveis, não apenas legíveis

Um questionário de múltipla escolha solicitado em texto livre é difícil de reutilizar: é preciso digitá-lo novamente na ferramenta usada pela turma. É melhor solicitar um formato estruturado, que o código valida depois. O Ollama pode restringir a resposta a um esquema JSON: de acordo com sua documentação, esse esquema é passado no campo format. O modelo redige as perguntas; o script verifica se há quatro opções distintas e uma única resposta correta, depois grava um arquivo que pode ser importado.

import json, requests, re

SCHEMA = {'type': 'object', 'properties': {'questions': {'type': 'array', 'items': {
  'type': 'object', 'properties': {
    'enonce': {'type': 'string'},
    'choix': {'type': 'array', 'items': {'type': 'string'}},
    'bonne_reponse': {'type': 'integer'},
    'explication': {'type': 'string'}},
  'required': ['enonce', 'choix', 'bonne_reponse', 'explication']}}},
  'required': ['questions']}

def generer(sujet, niveau, n=10, modele='prof-exos'):
    consigne = (f'Rédige {n} questions à choix multiple sur : {sujet}. Niveau : {niveau}. '
      'Quatre choix par question, dont un seul correct ; bonne_reponse est l\'indice (0 à 3). '
      'Les mauvais choix doivent être plausibles. Une phrase d\'explication. '
      'Réponds par un JSON conforme à : ' + json.dumps(SCHEMA))
    r = requests.post('http://localhost:11434/api/chat', json={
        'model': modele, 'stream': False, 'format': SCHEMA,
        'messages': [{'role': 'user', 'content': consigne}]})
    return json.loads(r.json()['message']['content'])['questions']

def valides(questions):
    ok, rejets, vus = [], [], set()
    for q in questions:
        c = q.get('choix', [])
        if (len(c) != 4 or len({x.strip().lower() for x in c}) != 4
                or q.get('bonne_reponse') not in (0, 1, 2, 3) or q['enonce'].strip().lower() in vus):
            rejets.append(q); continue
        vus.add(q['enonce'].strip().lower()); ok.append(q)
    return ok, rejets

def esc(s):
    return re.sub(r'([~=#{}:])', r'\\\1', s)

def vers_gift(questions):
    blocs = []
    for i, q in enumerate(questions, 1):
        lignes = [('=' if j == q['bonne_reponse'] else '~') + esc(c) for j, c in enumerate(q['choix'])]
        blocs.append(f"::Q{i}::{esc(q['enonce'])} {{\n" + '\n'.join(lignes) + '\n}\n')
    return '\n'.join(blocs)

O formato GIFT, usado pelo Moodle, é um arquivo de texto simples que pode ser importado para um banco de questões. Se sua instituição utiliza outra ferramenta, adapte a última função: o princípio continua sendo gerar um arquivo a partir dos dados controlados, e não copiar e colar o texto do modelo. O que o script não verifica é a veracidade das questões: daí a seção sobre verificação.

#Ancorar cada pergunta em um trecho do seu curso

O método mais seguro para evitar fatos inventados consiste em exigir, para cada pergunta, o trecho do curso que a justifica. Você cola seu texto, adiciona ao esquema um campo passage e o script verifica se esse trecho existe palavra por palavra no texto fornecido. Uma pergunta cujo trecho não é encontrado é descartada: ou o modelo inventou, ou parafraseou sem fonte. Essa verificação não prova que a pergunta é boa, mas garante que ela está fundamentada no seu curso e não na memória aproximada do modelo.

def normaliser(t):
    return ' '.join(t.split()).lower()

def ancrees(questions, cours):
    base = normaliser(cours)
    bonnes, douteuses = [], []
    for q in questions:
        (bonnes if normaliser(q.get('passage', '')) in base else douteuses).append(q)
    return bonnes, douteuses

O esquema e a instrução se complementam, portanto: adicione passage às propriedades e aos campos obrigatórios e escreva na instrução « copie palavra por palavra o trecho do texto que justifica a resposta correta ». As perguntas sobre fatos ausentes do curso, por exemplo, datas nunca mencionadas, não passarão pelo filtro, o que é exatamente o objetivo.

#Exercícios de matemática: Python calcula, o modelo cuida da apresentação

Um modelo com 9 bilhões de parâmetros erra operações simples, especialmente com números decimais e reagrupamento de algarismos. Para exercícios de cálculo, é melhor inverter os papéis: o código sorteia os números, calcula o resultado exato e gera a resolução; o modelo serve para redigir enunciados de problemas com esses números, o que ele faz bem. Assim, as respostas das suas fichas de exercícios nunca dependem da aritmética dele.

import random
from decimal import Decimal

def fr(d):
    return str(d.normalize() if d == d.to_integral() else d).replace('.', ',')

def exercices_decimaux(n=8, graine=None):
    hasard = random.Random(graine)
    sortie = []
    for i in range(n):
        nb = 2 if i < 2 else hasard.choice([3, 3, 4])
        vals = [Decimal(hasard.randint(10, 9999)) / hasard.choice([10, 100]) for _ in range(nb)]
        signes = ['+'] + [hasard.choice(['+', '-']) for _ in vals[1:]]
        total = sum(v if s == '+' else -v for v, s in zip(vals, signes))
        if total < 0:
            continue
        enonce = ' '.join((s + ' ' if k else '') + fr(v) for k, (v, s) in enumerate(zip(vals, signes)))
        sortie.append((enonce, fr(total)))
    return sortie

for e, r in exercices_decimaux(graine=42):
    print(e, '=', r)

A semente fixa permite regenerar exatamente a mesma ficha, por exemplo, para produzir a versão corrigida no dia seguinte. O mesmo princípio se aplica às conversões de unidades, aos percentuais, às equações do primeiro grau, a tudo o que envolve cálculo: o código gera e verifica, o modelo formata. Para línguas, no entanto, o modelo está no seu domínio: ele produz frases a completar, diálogos com lacunas e instruções, que precisam ser revisadas.

Prépare pour des élèves de 5e (niveau A2 du CECRL) une fiche sur le present simple
et le present continuous : 5 phrases à conjuguer, 3 phrases à transformer, un court
dialogue à trous. Vocabulaire courant uniquement. Donne le corrigé à la fin, séparé
par une ligne « CORRIGÉ », et signale entre crochets toute phrase où les deux temps
sont possibles.

#Gabaritos: pedir, depois conferir com outras fontes

Peça a resolução em uma segunda mensagem para que o modelo mantenha o enunciado no contexto, especificando o que você espera: a resposta final, o raciocínio em etapas, a regra aplicada e o erro típico a evitar. A resolução é a parte mais arriscada da ficha: um aluno aprende a resposta errada com confiança. Duas práticas reduzem o risco.

Calcular em vez de pedir ao modelo que calcule

Quando a resposta puder ser calculada, obtenha-a pelo código, não pelo modelo.

Gerar duas vezes e comparar

Nos exercícios de raciocínio, peça a solução duas vezes, com instruções ligeiramente diferentes. Se as respostas finais divergirem, o exercício deve ser revisado à mão.

Pedir a outro modelo que resolva

Um segundo modelo, de tamanho ou família diferente, resolve o enunciado sem ver a correção. O desacordo indica erros prováveis. Isso não é prova, apenas um filtro.

Reler tudo o que será distribuído

Nenhuma verificação automática substitui a leitura do professor, que continua responsável pelo conteúdo.

#Adaptar uma ficha ao nível dos alunos

A diferenciação é o uso em que o modelo mais contribui, pois reformular é seu ponto forte. Basta partir de uma ficha de exercícios validada e pedir variantes, mantendo os mesmos números e as mesmas respostas para que o gabarito continue válido. Peça a um colega que revise a variante antes de distribuí-la: uma reformulação mais simples pode alterar o sentido de um enunciado, o que é um problema comum nessas reescritas.

#Verificar a precisão, disciplina por disciplina

O ponto em comum é que o modelo escreve com a mesma confiança quando está certo e quando está errado. As diretrizes ministeriais também exigem uma verificação sistemática das produções da IA. Na prática, reserve cinco minutos de revisão por ficha e mantenha um pequeno diário dos erros encontrados: ao final de um mês, você saberá em quais disciplinas o modelo é confiável para você.

#Um ritmo de produção realista

1. 01
   Listar os conceitos da semana

   Três a cinco conceitos, com os trechos das aulas a serem usados como fonte.
2. 02
   Gerar a partir de suas fontes

   Cole o trecho do material da aula na instrução: as perguntas permanecem baseadas no que você ensinou.
3. 03
   Fazer o código calcular as resoluções dos exercícios

   Para tudo que envolver números, use um script como o mostrado acima.
4. 04
   Reler e corrigir

   Leia a ficha como um aluno faria: um erro no gabarito custa caro.
5. 05
   Diagramar e declarar o uso

   Exporte para PDF ou para a ferramenta que você usa em sala de aula e informe aos alunos que uma IA ajudou a preparar a ficha, conforme a exigência de transparência.

• Fundamentos de prompting
• Dominar os system prompts
• Ollama Modelfile: criar e personalizar seu modelo
• LM Studio para iniciantes
• Limitar as alucinações de um LLM local
• Saídas JSON estruturadas com Ollama

• Fonte: síntese das diretrizes de uso da IA na educação (Académie de Normandie)
• Fonte: diretrizes para o uso da IA na educação (ministério)
• Fonte: o arquivo Modelfile do Ollama
• Fonte: saídas estruturadas do Ollama
• Fonte: Qwen 3.5 na biblioteca Ollama