Upload 4 files

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Instalar dependências do sistema
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copiar e instalar dependências Python
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copiar código
+COPY app.py .
+
+# Expor porta do HuggingFace Spaces
+EXPOSE 7860
+
+# Rodar servidor
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +1,27 @@
----
-title: StrandDemo
-emoji: 🌍
-colorFrom: green
-colorTo: gray
-sdk: docker
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Strand Data Demo - HuggingFace Spaces README
+
+---
+title: Strand Data Demo API
+emoji: 🧬
+colorFrom: purple
+colorTo: cyan
+sdk: docker
+pinned: false
+---
+
+# Strand Data Demo API
+
+API de demonstração para classificação de qualidade de texto, Q&A e image captioning.
+
+## Endpoints
+
+- `POST /classify-quality` - Classifica qualidade de texto (sBERT)
+- `POST /qa` - Responde perguntas sobre um texto (LLM)
+- `POST /caption` - Gera legenda para imagem (Vision LLM)
+
+## Configuração
+
+Defina as seguintes secrets no Space:
+- `CHUTES_API_KEY` - API key do Chutes.ai
+- `OPENROUTER_API_KEY` - API key do OpenRouter (fallback)
+- `SBERT_MODEL_NAME` - Nome do modelo sBERT no HuggingFace Hub

app.py

@@ -0,0 +1,274 @@
+"""
+Strand Data - Demo Backend
+Deploy em HuggingFace Spaces
+
+Endpoints:
+- POST /classify-quality: Classifica qualidade de texto com sBERT
+- POST /qa: Q&A sobre texto usando LLM
+- POST /caption: Gera descrição de imagem
+"""
+
+import os
+import base64
+import httpx
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from sentence_transformers import SentenceTransformer
+import numpy as np
+from typing import Optional
+
+app = FastAPI(title="Strand Data Demo API")
+
+# CORS para permitir requests do frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Em produção, restringir ao domínio do site
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ================================
+# Configuração
+# ================================
+
+# API Keys (usar secrets do HuggingFace)
+CHUTES_API_KEY = os.getenv("CHUTES_API_KEY", "")
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
+
+# Modelo sBERT (substitua pelo seu modelo no HF Hub)
+SBERT_MODEL_NAME = os.getenv("SBERT_MODEL_NAME", "sentence-transformers/all-MiniLM-L6-v2")
+
+# Carregar modelo sBERT
+print(f"Carregando modelo sBERT: {SBERT_MODEL_NAME}")
+sbert_model = SentenceTransformer(SBERT_MODEL_NAME)
+
+# ================================
+# Anchor Quality Embeddings
+# ================================
+
+# Exemplos de textos de alta qualidade (âncoras)
+# Gabriel: substitua por textos reais do seu dataset de qualidade
+HIGH_QUALITY_ANCHORS = [
+    "Este artigo apresenta uma análise detalhada dos métodos de aprendizado de máquina aplicados à visão computacional, com resultados quantitativos robustos.",
+    "O estudo demonstra correlação significativa entre as variáveis analisadas, utilizando metodologia rigorosa e amostra representativa.",
+    "A implementação do algoritmo proposto apresenta complexidade O(n log n), com benchmarks comparativos contra soluções estado-da-arte.",
+]
+
+LOW_QUALITY_ANCHORS = [
+    "oi gente hj vou falar sobre ia eh mt legal ne",
+    "entao tipo assim a coisa funciona mais ou menos",
+    "nao sei explicar direito mas acho q eh isso ai",
+]
+
+# Pré-computar embeddings das âncoras
+print("Computando embeddings das âncoras de qualidade...")
+high_quality_embeddings = sbert_model.encode(HIGH_QUALITY_ANCHORS)
+low_quality_embeddings = sbert_model.encode(LOW_QUALITY_ANCHORS)
+
+# Média dos embeddings para cada classe
+high_quality_centroid = np.mean(high_quality_embeddings, axis=0)
+low_quality_centroid = np.mean(low_quality_embeddings, axis=0)
+
+# ================================
+# Modelos de Request/Response
+# ================================
+
+class QualityRequest(BaseModel):
+    text: str
+
+class QualityResponse(BaseModel):
+    quality: str  # "high" ou "low"
+    score: float  # 0-100, quanto maior mais qualidade
+    high_similarity: float
+    low_similarity: float
+
+class QARequest(BaseModel):
+    context: str
+    question: str
+
+class QAResponse(BaseModel):
+    answer: str
+
+class CaptionRequest(BaseModel):
+    image_base64: str  # Imagem em base64
+
+class CaptionResponse(BaseModel):
+    caption: str
+
+# ================================
+# Funções Utilitárias
+# ================================
+
+def cosine_similarity(a: np.ndarray, b: np.ndarray) -> float:
+    """Calcula similaridade de cosseno entre dois vetores."""
+    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))
+
+async def call_llm(prompt: str, system: str = "", max_tokens: int = 500) -> str:
+    """Chama LLM via Chutes ou OpenRouter."""
+    
+    # Tentar Chutes primeiro
+    if CHUTES_API_KEY:
+        try:
+            async with httpx.AsyncClient(timeout=30) as client:
+                response = await client.post(
+                    "https://llm.chutes.ai/v1/chat/completions",
+                    headers={
+                        "Authorization": f"Bearer {CHUTES_API_KEY}",
+                        "Content-Type": "application/json"
+                    },
+                    json={
+                        "model": "deepseek-ai/DeepSeek-V3-0324",
+                        "messages": [
+                            {"role": "system", "content": system} if system else None,
+                            {"role": "user", "content": prompt}
+                        ],
+                        "max_tokens": max_tokens,
+                        "temperature": 0.7
+                    }
+                )
+                if response.status_code == 200:
+                    return response.json()["choices"][0]["message"]["content"]
+        except Exception as e:
+            print(f"Erro Chutes: {e}")
+    
+    # Fallback para OpenRouter
+    if OPENROUTER_API_KEY:
+        try:
+            async with httpx.AsyncClient(timeout=30) as client:
+                response = await client.post(
+                    "https://openrouter.ai/api/v1/chat/completions",
+                    headers={
+                        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+                        "Content-Type": "application/json"
+                    },
+                    json={
+                        "model": "meta-llama/llama-3.3-70b-instruct",
+                        "messages": [
+                            {"role": "system", "content": system} if system else None,
+                            {"role": "user", "content": prompt}
+                        ],
+                        "max_tokens": max_tokens
+                    }
+                )
+                if response.status_code == 200:
+                    return response.json()["choices"][0]["message"]["content"]
+        except Exception as e:
+            print(f"Erro OpenRouter: {e}")
+    
+    raise HTTPException(status_code=503, detail="Nenhuma API de LLM disponível")
+
+async def call_vision_llm(image_base64: str, prompt: str) -> str:
+    """Chama LLM multimodal para image captioning."""
+    
+    # Usar Chutes com modelo multimodal
+    if CHUTES_API_KEY:
+        try:
+            async with httpx.AsyncClient(timeout=60) as client:
+                response = await client.post(
+                    "https://llm.chutes.ai/v1/chat/completions",
+                    headers={
+                        "Authorization": f"Bearer {CHUTES_API_KEY}",
+                        "Content-Type": "application/json"
+                    },
+                    json={
+                        "model": "Qwen/Qwen2.5-VL-72B-Instruct",
+                        "messages": [
+                            {
+                                "role": "user",
+                                "content": [
+                                    {"type": "text", "text": prompt},
+                                    {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_base64}"}}
+                                ]
+                            }
+                        ],
+                        "max_tokens": 300
+                    }
+                )
+                if response.status_code == 200:
+                    return response.json()["choices"][0]["message"]["content"]
+        except Exception as e:
+            print(f"Erro Vision Chutes: {e}")
+    
+    raise HTTPException(status_code=503, detail="API de visão não disponível")
+
+# ================================
+# Endpoints
+# ================================
+
+@app.get("/")
+async def root():
+    return {"message": "Strand Data Demo API", "status": "online"}
+
+@app.get("/health")
+async def health():
+    return {"status": "healthy", "model_loaded": sbert_model is not None}
+
+@app.post("/classify-quality", response_model=QualityResponse)
+async def classify_quality(request: QualityRequest):
+    """
+    Classifica a qualidade de um texto usando sBERT.
+    Compara o embedding do texto com âncoras de alta/baixa qualidade.
+    """
+    # Gerar embedding do texto
+    text_embedding = sbert_model.encode(request.text)
+    
+    # Calcular similaridade com cada centróide
+    high_sim = cosine_similarity(text_embedding, high_quality_centroid)
+    low_sim = cosine_similarity(text_embedding, low_quality_centroid)
+    
+    # Normalizar para score 0-100
+    # Quanto mais próximo de alta qualidade e distante de baixa, maior o score
+    raw_score = (high_sim - low_sim + 1) / 2  # Normaliza para 0-1
+    score = round(raw_score * 100, 2)
+    
+    quality = "high" if high_sim > low_sim else "low"
+    
+    return QualityResponse(
+        quality=quality,
+        score=score,
+        high_similarity=round(high_sim, 4),
+        low_similarity=round(low_sim, 4)
+    )
+
+@app.post("/qa", response_model=QAResponse)
+async def question_answering(request: QARequest):
+    """
+    Responde perguntas sobre um texto usando LLM.
+    """
+    system_prompt = """Você é um assistente especializado em responder perguntas sobre textos.
+Responda de forma precisa e concisa, baseando-se APENAS no contexto fornecido.
+Se a resposta não estiver no contexto, diga "Não encontrei essa informação no texto."
+Responda em português."""
+
+    prompt = f"""CONTEXTO:
+{request.context}
+
+PERGUNTA:
+{request.question}
+
+RESPOSTA:"""
+
+    answer = await call_llm(prompt, system_prompt, max_tokens=300)
+    return QAResponse(answer=answer.strip())
+
+@app.post("/caption", response_model=CaptionResponse)
+async def generate_caption(request: CaptionRequest):
+    """
+    Gera uma descrição/legenda para uma imagem.
+    """
+    prompt = """Descreva esta imagem em detalhes. 
+Inclua: objetos principais, cores, ações, ambiente/cenário.
+Responda em português, em 2-3 frases."""
+
+    caption = await call_vision_llm(request.image_base64, prompt)
+    return CaptionResponse(caption=caption.strip())
+
+# ================================
+# Para rodar localmente
+# ================================
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,17 @@
+# Strand Data Demo - Backend Dependencies
+
+# FastAPI e servidor
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+python-multipart==0.0.6
+
+# HTTP client assíncrono
+httpx==0.26.0
+
+# Sentence Transformers (sBERT)
+sentence-transformers==2.2.2
+torch>=2.0.0
+
+# Utilidades
+numpy>=1.24.0
+pydantic>=2.0.0