🐍 Exemplos de Código•7 min de leitura
Tradutor Automático com IA e Python
Exemplo completo de um tradutor automático multilíngue usando modelos de IA: detecção de idioma, tradução e API REST.
#tradução#ia#python#nlp#api
O que vamos construir
Um tradutor automático inteligente que:
- Detecta o idioma de origem automaticamente
- Traduz entre qualquer par de idiomas
- Mantém contexto e tom do texto original
- Oferece múltiplas opções de tradução (formal/informal)
- Serve via API REST com FastAPI
Arquitetura
Texto Original → Detecção de Idioma → Tradução → Pós-processamento → Resultado
↓ ↓
langdetect OpenAI API / HuggingFace
Código Completo
1. Tradutor com OpenAI
"""
tradutor_ia.py - Tradutor automático com IA
"""
import os
from dataclasses import dataclass
from typing import Optional
from enum import Enum
from openai import OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
class Formalidade(str, Enum):
FORMAL = "formal"
INFORMAL = "informal"
TECNICO = "técnico"
LITERARIO = "literário"
@dataclass
class ResultadoTraducao:
"""Resultado de uma tradução."""
texto_original: str
texto_traduzido: str
idioma_origem: str
idioma_destino: str
formalidade: str
confianca_deteccao: float
notas: Optional[str] = None
class TradutorIA:
"""Tradutor automático multilíngue com IA."""
IDIOMAS = {
'pt': 'Português Brasileiro',
'en': 'Inglês',
'es': 'Espanhol',
'fr': 'Francês',
'de': 'Alemão',
'it': 'Italiano',
'ja': 'Japonês',
'ko': 'Coreano',
'zh': 'Chinês Mandarim',
'ru': 'Russo',
'ar': 'Árabe',
}
def __init__(self, model: str = "gpt-4o-mini"):
self.model = model
def detectar_idioma(self, texto: str) -> tuple[str, float]:
"""Detecta o idioma do texto usando IA."""
response = client.chat.completions.create(
model=self.model,
messages=[
{"role": "system", "content": (
"Você é um detector de idiomas. Responda APENAS com o código "
"ISO 639-1 do idioma (ex: pt, en, es, fr, de, it, ja, ko, zh, ru, ar). "
"Nada mais."
)},
{"role": "user", "content": f"Detecte o idioma: {texto[:500]}"},
],
temperature=0,
max_tokens=10,
)
idioma = response.choices[0].message.content.strip().lower()[:2]
# Confiança baseada em heurísticas simples
confianca = 0.95 if len(texto) > 50 else 0.80
return idioma, confianca
def traduzir(
self,
texto: str,
idioma_destino: str = "pt",
idioma_origem: Optional[str] = None,
formalidade: Formalidade = Formalidade.FORMAL,
contexto: Optional[str] = None,
) -> ResultadoTraducao:
"""Traduz texto para o idioma de destino."""
# Detectar idioma de origem se não fornecido
confianca = 0.0
if idioma_origem is None:
idioma_origem, confianca = self.detectar_idioma(texto)
else:
confianca = 1.0
# Nomes dos idiomas
nome_origem = self.IDIOMAS.get(idioma_origem, idioma_origem)
nome_destino = self.IDIOMAS.get(idioma_destino, idioma_destino)
# Construir prompt de tradução
instrucoes_formalidade = {
Formalidade.FORMAL: "Use linguagem formal e profissional.",
Formalidade.INFORMAL: "Use linguagem informal e coloquial, como em uma conversa casual.",
Formalidade.TECNICO: "Use terminologia técnica precisa. Mantenha termos técnicos em inglês quando apropriado.",
Formalidade.LITERARIO: "Use linguagem literária e elegante, preservando figuras de linguagem.",
}
system_prompt = f"""Você é um tradutor profissional de {nome_origem} para {nome_destino}.
REGRAS:
1. Traduza o texto mantendo o significado e o tom original
2. {instrucoes_formalidade[formalidade]}
3. Preserve nomes próprios, marcas e siglas
4. Adapte expressões idiomáticas para equivalentes naturais no idioma de destino
5. Retorne APENAS a tradução, sem explicações adicionais
6. Mantenha a formatação original (parágrafos, listas, etc.)"""
if contexto:
system_prompt += f"\n7. CONTEXTO ADICIONAL: {contexto}"
response = client.chat.completions.create(
model=self.model,
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": texto},
],
temperature=0.3,
max_tokens=4000,
)
texto_traduzido = response.choices[0].message.content.strip()
return ResultadoTraducao(
texto_original=texto,
texto_traduzido=texto_traduzido,
idioma_origem=idioma_origem,
idioma_destino=idioma_destino,
formalidade=formalidade.value,
confianca_deteccao=confianca,
)
def traduzir_multiplos(
self,
texto: str,
idiomas_destino: list[str],
) -> list[ResultadoTraducao]:
"""Traduz texto para múltiplos idiomas."""
resultados = []
idioma_origem, _ = self.detectar_idioma(texto)
for idioma in idiomas_destino:
if idioma == idioma_origem:
continue
resultado = self.traduzir(
texto, idioma_destino=idioma, idioma_origem=idioma_origem
)
resultados.append(resultado)
return resultados
def traduzir_com_alternativas(
self,
texto: str,
idioma_destino: str = "pt",
) -> dict:
"""Traduz com diferentes níveis de formalidade."""
resultados = {}
for formalidade in [Formalidade.FORMAL, Formalidade.INFORMAL, Formalidade.TECNICO]:
resultado = self.traduzir(
texto, idioma_destino=idioma_destino, formalidade=formalidade
)
resultados[formalidade.value] = resultado.texto_traduzido
return resultados
2. Tradutor com Hugging Face (Offline/Gratuito)
"""
tradutor_local.py - Tradutor offline com modelos Hugging Face
"""
from transformers import MarianMTModel, MarianTokenizer, pipeline
class TradutorLocal:
"""Tradutor offline usando modelos Helsinki-NLP."""
MODELOS = {
('en', 'pt'): 'Helsinki-NLP/opus-mt-en-ROMANCE',
('pt', 'en'): 'Helsinki-NLP/opus-mt-ROMANCE-en',
('en', 'es'): 'Helsinki-NLP/opus-mt-en-es',
('es', 'en'): 'Helsinki-NLP/opus-mt-es-en',
('en', 'fr'): 'Helsinki-NLP/opus-mt-en-fr',
('fr', 'en'): 'Helsinki-NLP/opus-mt-fr-en',
('en', 'de'): 'Helsinki-NLP/opus-mt-en-de',
('de', 'en'): 'Helsinki-NLP/opus-mt-de-en',
}
def __init__(self):
self._models: dict = {}
self._tokenizers: dict = {}
def _load_model(self, origem: str, destino: str):
"""Carrega modelo sob demanda."""
key = (origem, destino)
if key not in self._models:
model_name = self.MODELOS.get(key)
if not model_name:
raise ValueError(f"Par {origem}→{destino} não suportado offline")
print(f"📥 Carregando modelo {model_name}...")
self._tokenizers[key] = MarianTokenizer.from_pretrained(model_name)
self._models[key] = MarianMTModel.from_pretrained(model_name)
print(f"✅ Modelo carregado!")
def traduzir(self, texto: str, origem: str, destino: str) -> str:
"""Traduz texto offline."""
self._load_model(origem, destino)
key = (origem, destino)
tokenizer = self._tokenizers[key]
model = self._models[key]
# Prefixo necessário para modelos ROMANCE
if 'ROMANCE' in self.MODELOS.get(key, ''):
if destino == 'pt':
texto = f">>por<< {texto}"
elif destino == 'es':
texto = f">>spa<< {texto}"
elif destino == 'fr':
texto = f">>fra<< {texto}"
inputs = tokenizer(texto, return_tensors="pt", padding=True, truncation=True, max_length=512)
outputs = model.generate(**inputs, max_new_tokens=512)
traduzido = tokenizer.decode(outputs[0], skip_special_tokens=True)
return traduzido
def traduzir_lote(self, textos: list[str], origem: str, destino: str) -> list[str]:
"""Traduz múltiplos textos de uma vez (mais eficiente)."""
self._load_model(origem, destino)
key = (origem, destino)
tokenizer = self._tokenizers[key]
model = self._models[key]
inputs = tokenizer(textos, return_tensors="pt", padding=True, truncation=True, max_length=512)
outputs = model.generate(**inputs, max_new_tokens=512)
traduzidos = [tokenizer.decode(out, skip_special_tokens=True) for out in outputs]
return traduzidos
3. API REST
"""
api_tradutor.py - API REST para o tradutor
"""
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from typing import Optional
from enum import Enum
app = FastAPI(title="API Tradutor com IA", version="1.0.0")
tradutor = TradutorIA()
class IdiomaEnum(str, Enum):
PT = "pt"
EN = "en"
ES = "es"
FR = "fr"
DE = "de"
IT = "it"
JA = "ja"
KO = "ko"
ZH = "zh"
class TraducaoRequest(BaseModel):
texto: str = Field(..., min_length=1, max_length=5000)
idioma_destino: IdiomaEnum = IdiomaEnum.PT
idioma_origem: Optional[IdiomaEnum] = None
formalidade: Formalidade = Formalidade.FORMAL
contexto: Optional[str] = None
class TraducaoResponse(BaseModel):
texto_original: str
texto_traduzido: str
idioma_origem: str
idioma_destino: str
formalidade: str
confianca_deteccao: float
@app.post("/traduzir", response_model=TraducaoResponse)
def api_traduzir(request: TraducaoRequest):
"""Traduz texto para o idioma de destino."""
try:
resultado = tradutor.traduzir(
texto=request.texto,
idioma_destino=request.idioma_destino.value,
idioma_origem=request.idioma_origem.value if request.idioma_origem else None,
formalidade=request.formalidade,
contexto=request.contexto,
)
return TraducaoResponse(
texto_original=resultado.texto_original,
texto_traduzido=resultado.texto_traduzido,
idioma_origem=resultado.idioma_origem,
idioma_destino=resultado.idioma_destino,
formalidade=resultado.formalidade,
confianca_deteccao=resultado.confianca_deteccao,
)
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/detectar")
def api_detectar(texto: str = Field(..., min_length=1)):
"""Detecta o idioma de um texto."""
idioma, confianca = tradutor.detectar_idioma(texto)
return {
"idioma": idioma,
"nome": TradutorIA.IDIOMAS.get(idioma, "Desconhecido"),
"confianca": confianca,
}
@app.get("/idiomas")
def api_idiomas():
"""Lista idiomas suportados."""
return TradutorIA.IDIOMAS
4. Exemplo de Uso
def main():
"""Demonstração do tradutor."""
tradutor = TradutorIA()
print("=" * 60)
print("TRADUTOR AUTOMÁTICO COM IA")
print("=" * 60)
# Teste 1: Inglês → Português
texto_en = "Machine learning is a subset of artificial intelligence that enables systems to learn and improve from experience."
resultado = tradutor.traduzir(texto_en, idioma_destino="pt")
print(f"\n📝 Original ({resultado.idioma_origem}): {texto_en}")
print(f"🌐 Tradução ({resultado.idioma_destino}): {resultado.texto_traduzido}")
print(f" Confiança: {resultado.confianca_deteccao:.0%}")
# Teste 2: Espanhol → Português
texto_es = "La inteligencia artificial está cambiando el mundo de maneras que no imaginábamos hace unos años."
resultado = tradutor.traduzir(texto_es, idioma_destino="pt")
print(f"\n📝 Original ({resultado.idioma_origem}): {texto_es}")
print(f"🌐 Tradução ({resultado.idioma_destino}): {resultado.texto_traduzido}")
# Teste 3: Português → Múltiplos idiomas
texto_pt = "O Brasil é o maior país da América do Sul e tem uma cultura rica e diversificada."
print(f"\n📝 Original: {texto_pt}")
resultados = tradutor.traduzir_multiplos(texto_pt, ["en", "es", "fr", "de"])
for r in resultados:
nome = TradutorIA.IDIOMAS.get(r.idioma_destino, r.idioma_destino)
print(f" 🌐 {nome}: {r.texto_traduzido}")
# Teste 4: Alternativas de formalidade
texto_formal = "Could you please send me the report by end of day?"
print(f"\n📝 Original: {texto_formal}")
alternativas = tradutor.traduzir_com_alternativas(texto_formal, "pt")
for estilo, traducao in alternativas.items():
print(f" [{estilo:10s}]: {traducao}")
if __name__ == "__main__":
main()
Como Rodar
# Instalar
pip install openai fastapi uvicorn transformers
# Configurar
export OPENAI_API_KEY="sk-..."
# Script direto
python tradutor_ia.py
# API
uvicorn api_tradutor:app --reload --port 8000
# Acesse: http://localhost:8000/docs
Saída Esperada
============================================================
TRADUTOR AUTOMÁTICO COM IA
============================================================
📝 Original (en): Machine learning is a subset of artificial intelligence...
🌐 Tradução (pt): Aprendizado de máquina é um subconjunto da inteligência artificial...
Confiança: 95%
📝 Original (es): La inteligencia artificial está cambiando el mundo...
🌐 Tradução (pt): A inteligência artificial está mudando o mundo...
📝 Original: O Brasil é o maior país da América do Sul...
🌐 Inglês: Brazil is the largest country in South America...
🌐 Espanhol: Brasil es el país más grande de América del Sur...
🌐 Francês: Le Brésil est le plus grand pays d'Amérique du Sud...
Expansões Possíveis
- Cache: armazenar traduções frequentes com Redis
- Glossário: termos técnicos customizados por domínio
- Batch: traduzir documentos inteiros (PDF, DOCX)
- Interface: frontend com Streamlit para tradução visual
- Avaliação: métricas BLEU para comparar qualidade
Um tradutor com IA é significativamente mais natural do que tradutores baseados em regras — e com este código, você tem um funcional em minutos! 🌐