vkusterl/extrator-cardapios-0.5b

Extrator de cardápios 0.5B

Modelo de 0,5 bilhão de parâmetros que converte cardápios de restaurante escritos em texto livre (mensagens de WhatsApp, texto copiado de PDF, posts e saída de OCR) em um catálogo estruturado em JSON Lines, com nome, descrição, preço, porção, categoria, restrições alimentares, tamanhos e adicionais de cada item. É um ajuste fino com LoRA do Qwen2.5 0.5B Instruct, treinado em uma GTX 1070 sobre o conjunto cardápios sintéticos em português.

A ideia é medir até onde chega, numa tarefa de extração bem delimitada, um modelo pequeno que roda em CPU e custa uma fração de uma chamada a um modelo grande, quando os dados e a avaliação são construídos com cuidado. Uma demonstração em Gradio para rodar localmente está em codigo/demo_gradio.py no conjunto de dados.

English summary. A 0.5B model fine tuned with LoRA from Qwen2.5 0.5B Instruct to turn free text Brazilian Portuguese restaurant menus into a structured JSON Lines catalog. On a hand written out of distribution test set that was never used for any decision, it reaches an item level F1 of 0.645, against 0.450 for a rule based parser and 0.060 for the same base model prompted without fine tuning.

Uso

from transformers import AutoModelForCausalLM, AutoTokenizer

modelo_id = "vkusterl/extrator-cardapios-0.5b"
tok = AutoTokenizer.from_pretrained(modelo_id)
modelo = AutoModelForCausalLM.from_pretrained(modelo_id)

cardapio = """Boa noite! Segue o cardápio de hoje 😋
*Marmita P* arroz, feijão, frango grelhado e salada R$ 18
*Marmita G* arroz, feijão, frango grelhado e salada R$ 24
Adicional de ovo +R$ 2
Refri lata R$ 6"""

mensagens = [
    {"role": "system", "content": "Extraia o cardápio em JSON Lines, com o restaurante na primeira linha quando houver e um item por linha."},
    {"role": "user", "content": cardapio},
]
entrada = tok.apply_chat_template(mensagens, add_generation_prompt=True, return_tensors="pt", return_dict=True)
saida = modelo.generate(**entrada, max_new_tokens=1024, do_sample=False)
print(tok.decode(saida[0, entrada["input_ids"].shape[1]:], skip_special_tokens=True))

A saída deste modelo para o exemplo acima, gerada em CPU, foi a seguinte. O adicional fica no item logo acima dele, que é a convenção dos dados de treino.

{"nome": "Marmita P", "descricao": "Arroz, feijão, frango grelhado e salada", "preco": 18.0, "categoria": "Marmitas"}
{"nome": "Marmita G", "descricao": "Arroz, feijão, frango grelhado e salada", "preco": 24.0, "categoria": "Marmitas", "adicionais": [{"nome": "Ovo", "preco": 2.0}]}
{"nome": "Refri Lata", "preco": 6.0, "categoria": "Bebidas"}

Use sempre a mesma instrução de sistema do exemplo, que é a do treino. A saída tem uma linha por item e pode ser validada com o esquema em codigo/esquema.py do conjunto de dados. Linhas inválidas são raras, mas convém descartá-las em vez de rejeitar o cardápio inteiro, como faz a função de_jsonl.

Resultados

A métrica principal é o F1 de item correto, em que um item só conta quando o nome foi pareado com o gabarito e o preço (ou a grade de tamanhos) e a categoria estão certos. São três conjuntos de avaliação. O teste sintético vem do mesmo gerador do treino. Os dois conjuntos fora da distribuição foram escritos à parte, em formatos que o gerador original não produzia. O de desenvolvimento orientou a segunda versão dos dados, e o de teste foi escrito depois dela e nunca foi usado para decidir nada, então é a medida mais honesta de generalização.

Modelo	Parâmetros	Teste sintético (100)	Desenvolvimento fora da distribuição (24)	Teste fora da distribuição (24)
Extrator v2 (este modelo)	0,5 B	0,972	0,659	0,645
Extrator v1 (primeira rodada)	0,5 B	0,821	0,580	0,582
Qwen2.5 1.5B Instruct sem ajuste fino	1,5 B	n/d	0,051	0,120
Qwen2.5 0.5B Instruct sem ajuste fino	0,5 B	0,064	0,090	0,060
Analisador por regras	não se aplica	0,496	0,359	0,450

Na comparação, o teste sintético usa as 100 primeiras amostras, as mesmas para todos os modelos. No teste sintético completo, com 500 cardápios, este modelo obtém 0,967. Os modelos sem ajuste fino tendem a responder com uma lista JSON dentro de um bloco de código, com campos trocados e categorias fora da lista, e mesmo com leitura tolerante ficam longe do modelo ajustado. O Qwen 1.5B sem ajuste fino não foi rodado no teste sintético, porque nos dois conjuntos fora da distribuição ele já fica muito abaixo do modelo ajustado. Em CPU, limitada a 2 threads, o extrator leva em média 38,2 s por cardápio, gerando cerca de 8 tokens por segundo.

Acerto por campo deste modelo, calculado sobre os itens pareados.

Métrica	Teste sintético (500)	Desenvolvimento (24)	Teste fora da distribuição (24)
Itens encontrados (pareados)	0,989	0,890	0,910
Nome idêntico ou quase	0,994	0,967	0,970
Preço ou grade de tamanhos	0,990	0,934	0,941
Categoria	0,985	0,762	0,743
Porção	0,988	0,910	0,861
Restrições	0,996	0,959	0,980
Adicionais	0,998	1,000	1,000
Descrição (F1 de tokens)	0,975	0,776	0,613
Restaurante	0,994	0,667	0,750
Item correto, precisão	0,969	0,655	0,660
Item correto, revocação	0,964	0,664	0,631
Item correto, F1	0,967	0,659	0,645
JSON válido	0,996	0,958	0,917
Cardápio inteiro perfeito	0,732	0,125	0,042

F1 de item correto por estilo de escrita no teste sintético.

Estilo	Cardápios	Modelo	Regras
corrido	40	0,934	0,000
informal	31	0,929	0,214
instagram	31	0,961	0,203
lista	86	0,964	0,378
ocr	46	0,950	0,361
pdf	113	0,982	0,484
tabela	49	0,966	0,709
whatsapp	104	0,980	0,689

Como o modelo chegou aqui

A primeira versão foi treinada com um gerador que cobria sete estilos de escrita. Ela acertava praticamente tudo no teste sintético, mas ficava em 0,580 no conjunto escrito à parte. A análise dos erros mostrou três padrões. Sabores listados sem o nome do prato, como pizzas sob uma tabela de sabores, recebiam categorias erradas. Linhas com preço compartilhado ("Pastéis (R$ 9,00 cada): carne, queijo...") não eram expandidas em um item por sabor. Tamanhos declarados só no cabeçalho confundiam a associação entre preço e tamanho. Nomes fora do vocabulário também saíam com erros de grafia.

A segunda versão do gerador passou a produzir esses formatos, ganhou um estilo informal, mais nomes compostos e pratos internacionais, e o modelo foi treinado de novo do zero. Para não medir a melhora com o mesmo material que a orientou, um segundo conjunto fora da distribuição foi escrito antes de qualquer resultado da nova versão. Nele, a primeira versão obtém 0,582 e esta obtém 0,645.

A melhora foi real, mas parcial. No teste final, o modelo encontrou 101 dos 111 itens e acertou o nome de quase todos, mas 26 deles saíram com a categoria errada, o que faz da categoria o principal gargalo. Pratos fora do vocabulário do gerador, como abará, quesadilla e bolinho de estudante, tendem a cair em Porções ou Acompanhamentos, e itens de café da manhã como pão de queijo e cuscuz saem como Lanches. Parte desses casos admite mais de uma resposta razoável (mandioca frita pode ser porção ou acompanhamento), mas a maioria é erro de fato.

Os formatos que motivaram a segunda versão ainda falham em parte. Em linhas de preço compartilhado, o modelo às vezes registra só o sabor ("Carne" em vez de "Pastel de Carne"), e grades de tamanho declaradas só no cabeçalho continuam sendo perdidas em alguns cardápios. Também aparecem erros em formatos que o gerador não produz, como o preço promocional ("de R$ 59,90 por R$ 44,90"), a venda por unidade e por cento e o prefixo omitido ("Sanduíche natural de frango 14 / de atum 15"). O próximo passo é ampliar o vocabulário com pratos regionais e de café da manhã e levar esses formatos ao gerador.

Treino

Configuração	Valor
Modelo base	Qwen/Qwen2.5-0.5B-Instruct
Método	LoRA (r 16, alfa 32, dropout 0,05) em todas as projeções lineares, depois incorporado ao modelo
Dados	4.000 cardápios sintéticos, 1 época, perda calculada só na resposta
Otimização	AdamW, taxa de aprendizado 2e-4 com decaimento cosseno, lote efetivo de 8
Comprimento máximo	2.048 tokens
Hardware	NVIDIA GTX 1070 (8 GB), fp32
Tempo	106 minutos
Perda final	treino 0,0276, validação 0,0108

A instrução de sistema usada no treino é curta (40 tokens), porque o formato é aprendido a partir dos dados. Os modelos sem ajuste fino da comparação recebem uma instrução longa, com o esquema e a lista de categorias, que é a melhor condição para eles, e suas respostas são lidas de forma tolerante.

Limitações

O modelo foi treinado só com dados sintéticos, e a diferença entre o teste sintético e os conjuntos fora da distribuição mostra quanto o desempenho cai diante de formatos novos. Cardápios reais com combinações, observações de preparo ou layouts muito irregulares podem gerar itens faltando, nomes alterados ou preços associados ao item errado, então a saída deve passar por revisão humana antes de virar catálogo. Em listas muito curtas, sem descrições, o modelo às vezes inventa descrições e porções que não estão no texto, provavelmente porque cerca de dois terços dos itens dos dados sintéticos trazem descrição. A demonstração descarta esses campos quando suas palavras e seus números não aparecem no cardápio (função filtra em codigo/demo_gradio.py), e o mesmo cuidado vale para qualquer uso real. As categorias seguem uma taxonomia fixa de 14 classes. O modelo não lê imagens, então cardápios em foto precisam de OCR antes. Restrições alimentares só são registradas quando o cardápio as declara, e o modelo não deve ser usado para inferir alergênicos.

Licença e autoria

Apache 2.0, a mesma do modelo base. Treinado e avaliado por Vinicius Kuster Lodi, Universidade Federal de Viçosa. O código de geração, treino e avaliação está na pasta codigo/ do conjunto de dados.