Eu queria construir um Q médico&Um projeto de ajuste fino que permaneceu verdadeiramente nativo de TPU no Kaggle. Este projeto usa o Google “gemma-3–1b-it”, KerasHub, Back-end JAX e Kaggle TPU para otimizar os dados de conversas médicas do ChatDoctor. Também comparei o resultado com um Gemma muito maior 4 modelo operado remotamente.

A versão curta é:

– A Gema 3 pipeline de treinamento executado inteiramente em TPU

– Concluiu o ajuste fino do LoRA em um “TPU v5e-8” em menos de um minuto

– As respostas qualitativas melhoraram mais do que a precisão do benchmark

– Gema 4 permaneceu muito mais forte no MedMCQA no modo zero-shot

É importante notar que as chamadas de ajuste fino e os ganhos de benchmark nem sempre são a mesma coisa.

Você pode conferir o caderno Kaggle Aqui.

Ajuste fino do LLM médico em TPU com Keras + JAX

O que eu construí

Um pipeline que faz cinco coisas:

1. Verifica um ambiente Kaggle TPU onde Keras está vinculado ao back-end JAX.

2. Carrega e formata o conjunto de dados ChatDoctor em pares de prompt/resposta no estilo Gemma Chat.

3. Avalia Gemma básica 3 1B usando um segmento MedMCQA fixo de 100 perguntas.

4. Afinando Gemma 3 1B com LoRA em TPU.

5. Compara o modelo final com Gemma 4 via OpenRouter para obter um ponto de referência zero-shot.

O caminho de treinamento local ativo é totalmente nativo da TPU para Gemma 3. A gema 4 seção é intencionalmente separada e remota, então me refiro claramente a isso como comparação de API e não inferência local de TPU.

Configuração de ambiente e TPU

Esta execução foi feita no Kaggle usando:

Python `3.12.13`
NumPy `2.4.3`
conjuntos de dados `4.8.3`
Difícil `3.13.2`
JAX `0.9.2`

e dispositivos TPU de 8` visíveis para JAX. O detalhe crucial da configuração era garantir que Keras visse “HARD_BACKEND=jax” antes da primeira importação:

importar sistema operacional
os.environ["KERAS_BACKEND"] = "jax"
importação difícil
importar jax
imprimir(keras.backend.backend())
imprimir(jax.devices())

Isso parece insignificante, mas em ambientes de notebook geralmente é a diferença entre uma execução de TPU limpa e uma discrepância confusa de back-end.

Seleção de conjunto de dados: ChatDoctor para ajuste fino, MedMCQA para benchmarking

Usei dois conjuntos de dados com funções diferentes:

– “LinhDuong/chatdoctor-200k” para ajuste médico em conversas

– “medmcqa” para uma referência médica de múltipla escolha

Da última corrida:

– Exemplos brutos de ChatDoctor: “207.408”.

– Exemplos formatados válidos: “207.405”.

– Distribuição de trem usada: “1.800”.

– Divisão de validação usada: “200”.

– Pontuação MedMCQA: “100”.

ChatDoctor foi reformatado em Gemma Chat Rounds:

texto = (
f"<início_do_turno>user\n"
f"You are a helpful medical assistant. Answer the patient's question clearly and safely.\n\n"
f"{paciente_msg}<fim_do_turno>\n"
f"<início_do_turno>model\n"
f"{médico_msg}<fim_do_turno>"
)

Essa estrutura me permitiu continuar o pré-processamento no KerasHub em vez de construir manualmente um pipeline de treinamento de tokenização separado.

Linha de base: Gema 3 1B antes do ajuste fino

Como base, Carreguei “google/gemma-3–1b-it” diretamente via KerasHub:

linha de base_preprocessor = keras_hub.models.Gemma3CausalLMPreprocessor.from_preset(
"hf://google/gemma-3–1b-it",
comprimento_sequência=256,
)
linha de base_gemma_lm = keras_hub.models.Gemma3CausalLM.from_preset(
"hf://google/gemma-3–1b-it",
pré-processador=baseline_preprocessor,
)
linha de base_gemma_lm.compile(sampler="greedy")

Para o segmento MedMCQA de 100 perguntas, o modelo básico alcançado 30/100, uma precisão de 30.0%. Isso me deu o ponto de referência “antes do ajuste fino” para o resto do projeto.

Configuração de ajuste fino: LoRA em TPU

O modelo teve um total de “999.885.952” parâmetros. Depois de ativar o LoRA, apenas “2.609.152” parâmetros foram treináveis, tornando isso prático no Kaggle TPU sem tentar otimizar totalmente o modelo inteiro.

A etapa LoRA foi simples:

gemma_lm.backbone.enable_lora(classificação = 16)

Configuração de treinamento da última execução:

comprimento da sequência: `256`
treinar amostras: `1.800`
amostras de validação: `200`
tamanho do lote: `1`
épocas: `1`
taxa de aprendizagem: `1e-4`
Classificação LoRA: `16`

O modelo foi compilado usando SGD mais entropia cruzada categórica esparsa:

otimizador = keras.optimizers.SGD(taxa_de_aprendizado=1e-4)
gemma_lm.compile(
perda = keras.losses.SparseCategoricalCrossentropy(from_logits = Verdadeiro),
otimizador = otimizador,
métricas_ponderadas=[keras.metrics.SparseCategoricalAccuracy(name="accuracy")],
sampler="greedy",
)

Resultados do treinamento TPU

A execução de treinamento foi concluída com sucesso na TPU, e o primeiro lote se comportou exatamente como os usuários da TPU esperam: inicialmente mais lento devido à compilação XLA, então uma execução em estado estacionário muito mais rápida.

Estatísticas finais de treinamento de TPU do notebook:

hardware: `Google CloudTPU (8 dispositivos)`
modelo: `google/gemma-3–1b-it`
estrutura: `Difícil 3.13.2 + back-end JAX`
método: `LoRA (classificação = 16)`
exemplos de treinamento: `1800`
tamanho do lote: `1`
épocas: `1`
tempo total de trem: `0,7 minutos`
rendimento: `~10512 tokens/seg`
Métricas de treinamento:
perda de trem: `1.8927`
perda de validação: `1.7304`
treinar precisão do token: `0,3061`
precisão do token de validação: `0,3129`

A precisão no nível do token é um sinal de treinamento do modelo de linguagem, não é uma métrica para “precisão nas respostas a perguntas médicas”. Portanto, Eu tratei isso como uma verificação de sanidade, em vez de uma descoberta de manchete.

O ajuste fino melhorou o modelo?

É aqui que a história fica interessante. No MedMCQA a resposta foi: na verdade.

A Gemma afinada 3 modelo alcançado 30/100, uma precisão de 30.0%. Isso é exatamente estável em comparação com a linha de base deste benchmark.

Mas os resultados qualitativos ainda mudaram. Nos exemplos lado a lado, o modelo refinado tornou-se um pouco mais direto e voltado para a segurança. Por exemplo, se você tem dor no peito e falta de ar:

– A resposta básica foi cautelosa e explicativa

– A resposta bem ajustada inclinou-se mais claramente para um exame médico urgente

Esse padrão também ficou evidente nos outros exemplos. Embora o modelo não tenha se tornado repentinamente uma referência, tornou-se mais alinhado com o tom das diretrizes médicas à medida que ajustou os dados.

Esta é uma lição prática importante: O ajuste fino dos dados do domínio de conversação pode alterar significativamente o estilo de resposta e a ênfase na segurança sem alterar significativamente um benchmark de múltipla escolha.

Realizada verificação ROUGE-L

Eu também realizei uma verificação simples em 20 amostras de validação do ChatDoctor e ROUGE-L medido entre resultados do modelo e respostas de referência.

Resultado final: VERMELHO-L: 0.106

Eu não exageraria esse número. É melhor tratá-lo como um sinal bruto de similaridade, em vez de um substituto para a avaliação da qualidade clínica.. Ainda, acrescenta outra perspectiva além do MedMCQA.

Gema 4 comparação via OpenRouter

Para um modelo de referência mais forte, Eu adicionei uma Gemma opcional 4 seção via OpenRouter:

– Modelo: `google/gemma-4–26b-a4b-it`

– Modo de execução: Inferência remota de API

– não é TPU local

A gema 4 comparação foi útil, mas não fazia parte do plano de treinamento da TPU. Serviu para responder a uma pergunta sobre o produto: Como um modelo pequeno bem ajustado se compara a um modelo maior?, modelo mais novo de fábrica?

No mesmo 100 Perguntas MedMCQA, Gema 4 alcançou uma pontuação de 68/100, ou seja. uma precisão de 68.0%. Essa é uma grande diferença entre as execuções básicas e o Gemma bem ajustado 3 corre.

Os resultados qualitativos também foram mais fortes. No exemplo da dor no peito, Gema 4 fui imediatamente para instruções de emergência, dizendo especificamente ao usuário para tratar a situação como uma emergência potencial e procurar atendimento médico imediatamente. Usando o exemplo da fadiga, sede e micção frequente, a tríade clássica de sintomas associados ao diabetes foi claramente reconhecida.

Resultados finais

Métricas adicionais:

• ROUGE-L em amostras retidas do ChatDoctor: “0,106”.

– Parâmetros treináveis ​​com LoRA: “2.609.152”.

– Parâmetros totais: “999.885.952”.

– Tempo de treinamento de TPU de ponta a ponta: “0,7 minutos”.

O que este projeto realmente mostra

A maior vantagem é que o ajuste fino nem sempre é melhor do que um modelo básico melhor. Minha última execução não suporta esta afirmação.

O que isso mostra é:

– Keras e JAX são uma pilha de treinamento TPU conveniente para Kaggle

– Gema 3 1B pode ser totalmente ajustado em uma TPU com um orçamento de personalização muito baixo

– O ajuste fino do diálogo médico pode mudar o comportamento qualitativo, mesmo que a precisão do benchmark permaneça a mesma

– Um modelo mais recente, muito maior, ainda pode dominar a pontuação MCQ médica factual no modo tiro zero

Considerações Finais

A gema 3 o caminho de treinamento funcionou exatamente como eu queria, ou seja. configuração fácil, execução limpa de TPU, pegada treinável pequena, e iteração rápida. Os resultados também foram um bom lembrete de que nem todo treinamento bem-sucedido resulta em um salto de referência atraente.. Às vezes, o verdadeiro sucesso vem da construção de um pipeline sólido, entender o que mudou, e ser honesto sobre o que não mudou.

Geral, Otimizei Gemma com sucesso 3 1B para diálogo médico sobre Kaggle TPU com Keras e JAX, notou melhorias qualitativas na capacidade de resposta, e confirmou que uma Gemma removida 4 a linha de base ainda supera significativamente no MedMCQA.

---

Afinando Gemma 3 em TPU para Medical Q&Um com Keras e JAX foi publicado originalmente no Google Developer Experts on Medium, onde as pessoas continuam a conversa destacando e respondendo a esta história.