teste

app/bert_classifier.py

@@ -0,0 +1,34 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+MODEL_DIR = "app/model"
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR)
+model = AutoModelForSequenceClassification.from_pretrained(MODEL_DIR).to(device)
+model.eval()
+
+
+def classify_text(text: str):
+    """
+    Retorna:
+      pred: 0 (fake) ou 1 (real)
+      confidence: probabilidade máxima, já no formato que sua API usa
+    """
+    encoded = tokenizer(
+        text,
+        truncation=True,
+        padding=True,
+        max_length=256,
+        return_tensors="pt"
+    ).to(device)
+
+    with torch.no_grad():
+        out = model(**encoded)
+        logits = out.logits
+        probs = torch.softmax(logits, dim=1).cpu().numpy()[0]
+
+    pred = int(probs.argmax())
+    confidence = float(probs.max())
+
+    return pred, confidence

app/main.py

@@ -0,0 +1,76 @@
+from fastapi import FastAPI, UploadFile, File
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+from app.bert_classifier import classify_text
+from app.ocr import extract_text_from_image
+from app.preprocess import preprocess_text
+
+
+app = FastAPI(
+    title="API Fake News — BERT Fine-Tuned",
+    version="2.0.0"
+)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Modelos de entrada/saída
+class TextInput(BaseModel):
+    text: str
+
+
+@app.get("/")
+def root():
+    return {"message": "API Fake News — BERT Fine-Tuned ativa!"}
+
+# OCR
+@app.post("/img-to-txt")
+async def img_to_txt(file: UploadFile = File(...)):
+    bytes_data = await file.read()
+    text = extract_text_from_image(bytes_data)
+    return {"text": text}
+
+# Predição
+@app.post("/predict")
+async def predict_text(input: TextInput):
+    text = preprocess_text(input.text)
+
+    if len(text) < 20:
+        return {
+            "prediction": "Indefinido",
+            "confidence": 0.0,
+            "message": "O texto é muito curto para análise confiável."
+        }
+
+    pred, conf = classify_text(text)
+
+    if pred == 1:
+        label = "Notícia Real"
+
+        if conf > 0.90:
+            message = "Essa notícia parece altamente confiável."
+        elif conf > 0.75:
+            message = "Provável notícia real, mas é bom conferir as fontes."
+        else:
+            message = "O modelo pende para real, mas com baixa confiança."
+    else:
+        label = "Fake News"
+
+        if conf > 0.90:
+            message = "Forte indicação de que esta notícia é falsa."
+        elif conf > 0.75:
+            message = "Provável conteúdo falso, mas recomenda-se verificar fontes."
+        else:
+            message = "O modelo pende para falsa, mas sem alta confiança."
+
+    return {
+        "prediction": label,
+        "confidence": round(conf, 3),
+        "message": message
+    }

app/model/config.json

@@ -0,0 +1,32 @@
+{
+  "architectures": [
+    "BertForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "directionality": "bidi",
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "output_past": true,
+  "pad_token_id": 0,
+  "pooler_fc_size": 768,
+  "pooler_num_attention_heads": 12,
+  "pooler_num_fc_layers": 3,
+  "pooler_size_per_head": 128,
+  "pooler_type": "first_token_transform",
+  "position_embedding_type": "absolute",
+  "problem_type": "single_label_classification",
+  "torch_dtype": "float32",
+  "transformers_version": "4.55.4",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 29794
+}

app/model/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27642721c62ef81f6961c3051c3246035166f90d888b853f4e91e2ca8ae3c460
+size 435722224

app/model/special_tokens_map.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b6d346be366a7d1d48332dbc9fdf3bf8960b5d879522b7799ddba59e76237ee3
+size 125

app/model/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b22b95acf8d863293658d68a3996f22ee077bc792415c976e632049e1e399466
+size 678055

app/model/tokenizer_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ab044e4a71cdb2a5cff548e16d3bcd46a757848ef861743426c44a134b00da1
+size 1301

app/model/vocab.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:69c28584c67a0e5018f85ca734aa272cc38e26b5dd0d33fffa28059299f21707
+size 209528

app/ocr.py

@@ -0,0 +1,7 @@
+import pytesseract
+from PIL import Image
+from io import BytesIO
+
+def extract_text_from_image(image_bytes):
+    img = Image.open(BytesIO(image_bytes))
+    return pytesseract.image_to_string(img, lang="por")

app/preprocess.py

@@ -0,0 +1,11 @@
+import re
+import unicodedata
+
+def preprocess_text(text):
+    text = unicodedata.normalize("NFKC", text)
+    text = re.sub(r"http\S+|www\.\S+", "", text)
+    text = re.sub(r"<.*?>", "", text)
+    text = re.sub(r"[^\wÀ-ÖØ-öø-ÿ?!,. ]", " ", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+

app/train_finetune.py

@@ -0,0 +1,131 @@
+import os
+import torch
+from torch.utils.data import DataLoader, Dataset
+from torch.optim import AdamW  
+from transformers import (
+    AutoTokenizer,
+    AutoModelForSequenceClassification,
+    get_linear_schedule_with_warmup
+)
+from tqdm import tqdm
+import random
+
+from app.preprocess import preprocess_text
+
+# CONFIGURAÇÕES
+MODEL_NAME = "neuralmind/bert-base-portuguese-cased"
+OUTPUT_DIR = "app/model"
+FAKE_DIR = "data/fake_news/financeiros"
+REAL_DIR = "data/real_news/financeiros"
+
+EPOCHS = 3
+BATCH_SIZE = 8
+LR = 2e-5
+MAX_LEN = 256
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"🔥 Treinando em: {device}")
+
+# FUNÇÕES AUXILIARES
+def load_texts_from_dir(directory, label):
+    """Lê recursivamente todos os .txt em todas as subpastas."""
+    samples = []
+
+    for root, _, files in os.walk(directory):
+        for fname in files:
+            if fname.endswith(".txt"):
+                path = os.path.join(root, fname)
+                try:
+                    with open(path, "r", encoding="utf-8") as f:
+                        text = f.read()
+                        text = preprocess_text(text)
+                        samples.append((text, label))
+                except Exception as e:
+                    print(f"⚠ Erro ao ler {path}: {e}")
+
+    return samples
+
+
+def load_dataset():
+    """Carrega fake e real em formato único."""
+    print("📂 Carregando dados das pastas...")
+    fake = load_texts_from_dir(FAKE_DIR, 0)
+    real = load_texts_from_dir(REAL_DIR, 1)
+
+    dataset = fake + real
+    random.shuffle(dataset)
+
+    print(f"✔ Total Fake: {len(fake)}")
+    print(f"✔ Total Real: {len(real)}")
+    print(f"✔ Total: {len(dataset)}")
+
+    texts, labels = zip(*dataset)
+    return list(texts), list(labels)
+
+# DATASET DO TORCH
+class NewsDataset(Dataset):
+    def __init__(self, texts, labels, tokenizer):
+        self.texts = texts
+        self.labels = labels
+        self.tokenizer = tokenizer
+
+    def __len__(self):
+        return len(self.texts)
+
+    def __getitem__(self, idx):
+        encoded = self.tokenizer(
+            self.texts[idx],
+            truncation=True,
+            padding="max_length",
+            max_length=MAX_LEN,
+            return_tensors="pt"
+        )
+        encoded = {k: v.squeeze() for k, v in encoded.items()}
+        encoded["labels"] = torch.tensor(self.labels[idx], dtype=torch.long)
+        return encoded
+
+# PROCESSO DE TREINAMENTO
+def train():
+    texts, labels = load_dataset()
+
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+    model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME, num_labels=2).to(device)
+
+    dataset = NewsDataset(texts, labels, tokenizer)
+    loader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)
+
+    optimizer = AdamW(model.parameters(), lr=LR)
+    total_steps = len(loader) * EPOCHS
+    scheduler = get_linear_schedule_with_warmup(optimizer, 0, total_steps)
+
+    print("\n🚀 Iniciando fine-tuning do BERT...\n")
+
+    model.train()
+
+    for epoch in range(EPOCHS):
+        print(f"\n===== Época {epoch+1}/{EPOCHS} =====")
+        epoch_loss = 0
+
+        for batch in tqdm(loader):
+            batch = {k: v.to(device) for k, v in batch.items()}
+
+            outputs = model(**batch)
+            loss = outputs.loss
+            epoch_loss += loss.item()
+
+            loss.backward()
+            optimizer.step()
+            scheduler.step()
+            optimizer.zero_grad()
+
+        print(f"📉 Loss da época: {epoch_loss / len(loader):.4f}")
+
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    model.save_pretrained(OUTPUT_DIR)
+    tokenizer.save_pretrained(OUTPUT_DIR)
+
+    print(f"\n🎉 Modelo salvo em: {OUTPUT_DIR}\n")
+
+
+if __name__ == "__main__":
+    train()

dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    tesseract-ocr \
+    tesseract-ocr-por \
+    libgl1 \
+    && apt-get clean
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+pytesseract
+pillow
+python-multipart
+transformers
+torch
+numpy