Upload 6 files

.gitignore

@@ -1,4 +1,4 @@
-venv
-__pycache__/
-*.pyc
-.DS_Store
+venv
+__pycache__/
+*.pyc
+.DS_Store

README.md

@@ -1,13 +1,13 @@
----
-title: MolGenAI
-emoji: 🧬
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: "4.38.1"
-app_file: app.py
-pinned: false
----
-
-# 🧬 MolGenAI
-Generador molecular basado en GPT-2 para estructuras SMILES.
+---
+title: MolGenAI
+emoji: 🧬
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: "4.38.1"
+app_file: app.py
+pinned: false
+---
+
+# 🧬 MolGenAI
+Generador molecular basado en GPT-2 para estructuras SMILES.

app.py

@@ -1,51 +1,51 @@
-import gradio as gr
-import torch
-import main as core
-
-# ---------- Función de inferencia ----------
-def run_inference(input_text: str):
-    if not input_text.strip():
-        return "Ingresá una configuración para generar el resultado."
-
-    if core.model is None or core.tokenizer is None:
-        return "El modelo no está cargado correctamente."
-
-    try:
-        # Tokenización e inferencia
-        inputs = core.tokenizer(input_text, return_tensors="pt").to(core.DEVICE)
-        with torch.no_grad():
-            outputs = core.model.generate(
-                inputs["input_ids"],
-                max_length=60,
-                do_sample=True,
-                top_p=0.95,
-                temperature=0.8
-            )
-
-        # Decodificación
-        tokens = core.tokenizer.convert_ids_to_tokens(outputs[0])
-        tokens_string = core.decodificar_tokens(tokens)
-        smiles = core.postprocesar_smiles(tokens_string)
-
-        if not smiles or len(smiles.strip()) == 0:
-            return "No se generó ningún SMILES válido."
-
-        return smiles
-
-    except Exception as e:
-        return f"Error interno durante la generación: {str(e)}"
-
-# ---------- Interfaz de Gradio ----------
-with gr.Blocks(title="MolGen.AI") as demo:
-    gr.Markdown("## 🧬 MolGen.AI — Generación de moléculas")
-    gr.Markdown("Escribí una configuración y generá una estructura SMILES basada en tu modelo.")
-    inp = gr.Textbox(label="Configuración", placeholder="Ej: CCO[NH2+]...", lines=3)
-    btn = gr.Button("Generar", variant="primary")
-    out = gr.Textbox(label="SMILES generados", lines=6)
-    btn.click(fn=run_inference, inputs=inp, outputs=out)
-
-if __name__ == "__main__":
-    print("🚀 Iniciando MolGen.AI con Gradio...")
-    import os
-    port = int(os.environ.get("PORT", 7860))
-    demo.launch(server_name="0.0.0.0", server_port=port)
+import gradio as gr
+import torch
+import main as core
+
+# ---------- Función de inferencia ----------
+def run_inference(input_text: str):
+    if not input_text.strip():
+        return "Ingresá una configuración para generar el resultado."
+
+    if core.model is None or core.tokenizer is None:
+        return "El modelo no está cargado correctamente."
+
+    try:
+        # Tokenización e inferencia
+        inputs = core.tokenizer(input_text, return_tensors="pt").to(core.DEVICE)
+        with torch.no_grad():
+            outputs = core.model.generate(
+                inputs["input_ids"],
+                max_length=60,
+                do_sample=True,
+                top_p=0.95,
+                temperature=0.8
+            )
+
+        # Decodificación
+        tokens = core.tokenizer.convert_ids_to_tokens(outputs[0])
+        tokens_string = core.decodificar_tokens(tokens)
+        smiles = core.postprocesar_smiles(tokens_string)
+
+        if not smiles or len(smiles.strip()) == 0:
+            return "No se generó ningún SMILES válido."
+
+        return smiles
+
+    except Exception as e:
+        return f"Error interno durante la generación: {str(e)}"
+
+# ---------- Interfaz de Gradio ----------
+with gr.Blocks(title="MolGen.AI") as demo:
+    gr.Markdown("## 🧬 MolGen.AI — Generación de moléculas")
+    gr.Markdown("Escribí una configuración y generá una estructura SMILES basada en tu modelo.")
+    inp = gr.Textbox(label="Configuración", placeholder="Ej: CCO[NH2+]...", lines=3)
+    btn = gr.Button("Generar", variant="primary")
+    out = gr.Textbox(label="SMILES generados", lines=6)
+    btn.click(fn=run_inference, inputs=inp, outputs=out)
+
+if __name__ == "__main__":
+    print("🚀 Iniciando MolGen.AI con Gradio...")
+    import os
+    port = int(os.environ.get("PORT", 7860))
+    demo.launch(server_name="0.0.0.0", server_port=port)

main.py

@@ -1,135 +1,145 @@
-import os
-import re
-import torch
-from typing import Optional
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-from transformers import AutoTokenizer, AutoModelForCausalLM
-
-app = FastAPI(title="Chem SMILES Generator", version="1.0.0")
-
-# ---------- Config ----------
-MODEL_NAME = os.getenv("MODEL_NAME", "ncfrey/ChemGPT-4.7M")
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-SPECIAL_TOKENS = {"[CLS]", "[SEP]", "[PAD]", "[UNK]", "[BOS]", "[EOS]", "[MASK]"}
-
-# ---------- Modelo global (cargado una vez) ----------
-tokenizer = None
-model = None
-
-@app.on_event("startup")
-def load_model():
-    global tokenizer, model
-    try:
-        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-        model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
-        model.to(DEVICE)
-        model.eval()
-    except Exception as e:
-        raise RuntimeError(f"No se pudo cargar el modelo '{MODEL_NAME}': {e}")
-
-# ---------- Utilidades de decodificación/postpro ----------
-def decodificar_tokens(tokens):
-    mol = []
-    for tok in tokens:
-        if tok in SPECIAL_TOKENS:
-            continue
-        if tok.startswith("[") and tok.endswith("]"):
-            contenido = tok[1:-1]
-            if re.match(r'^[A-Za-z0-9@=#+\\/-]+$', contenido):
-                mol.append(contenido)
-            else:
-                mol.append(tok)
-        else:
-            mol.append(tok)
-    return "".join(mol)
-
-def postprocesar_smiles(tokens_string: str) -> str:
-    pattern = re.compile(r'\[.*?\]')
-    tokens = pattern.split(tokens_string)
-    matches = pattern.findall(tokens_string)
-
-    result = []
-    branch_stack = []
-    ring_open = {}
-
-    for i in range(len(tokens)):
-        result.append(tokens[i])
-
-        if i < len(matches):
-            tok = matches[i]
-
-            if tok.startswith("[Branch"):
-                result.append("(")
-                branch_stack.append(")")
-
-            elif tok.startswith("[Ring"):
-                nums = re.findall(r'\d+', tok)
-                if nums:
-                    n = nums[0]
-                    if n not in ring_open:
-                        ring_open[n] = True
-                    else:
-                        del ring_open[n]
-                    result.append(n)
-
-            else:
-                result.append(tok)
-
-    while branch_stack:
-        result.append(branch_stack.pop())
-
-    return "".join(result)
-
-# ---------- Tipos de request/response ----------
-class GenerateRequest(BaseModel):
-    input_text: str
-    max_length: Optional[int] = 60
-    top_k: Optional[int] = 50
-    top_p: Optional[float] = 0.95
-    temperature: Optional[float] = 1.0
-
-class GenerateResponse(BaseModel):
-    raw_tokens_string: str
-    smiles_postprocesado: str
-
-# ---------- Rutas ----------
-@app.get("/health")
-def health():
-    return {"status": "ok", "device": DEVICE, "model": MODEL_NAME}
-
-@app.post("/generate", response_model=GenerateResponse)
-def generate(req: GenerateRequest):
-    if tokenizer is None or model is None:
-        raise HTTPException(status_code=500, detail="Modelo no inicializado")
-
-    try:
-        inputs = tokenizer(req.input_text, return_tensors="pt").to(DEVICE)
-        # Preferimos el token [EOS] si existe, si no el por defecto del tokenizer
-        eos_id = tokenizer.convert_tokens_to_ids("[EOS]")
-        if eos_id is None or eos_id == tokenizer.unk_token_id:
-            eos_id = tokenizer.eos_token_id
-
-        with torch.no_grad():
-            outputs = model.generate(
-                inputs["input_ids"],
-                max_length=req.max_length,
-                do_sample=True,
-                top_k=req.top_k,
-                top_p=req.top_p,
-                temperature=req.temperature,
-                eos_token_id=eos_id,
-            )
-
-        tokens = tokenizer.convert_ids_to_tokens(outputs[0])
-        tokens_string = decodificar_tokens(tokens)
-        smiles = postprocesar_smiles(tokens_string)
-        smiles_final = smiles.replace("Ring", "")
-
-        return GenerateResponse(
-            raw_tokens_string=tokens_string,
-            smiles_postprocesado=smiles
-        )
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error generando SMILES: {str(e)}")
-
+import os
+import re
+import torch
+from typing import Optional
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+app = FastAPI(title="Chem SMILES Generator", version="1.0.0")
+
+# Enable CORS for all origins
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
+# ---------- Config ----------
+MODEL_NAME = os.getenv("MODEL_NAME", "ncfrey/ChemGPT-4.7M")
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+SPECIAL_TOKENS = {"[CLS]", "[SEP]", "[PAD]", "[UNK]", "[BOS]", "[EOS]", "[MASK]"}
+
+# ---------- Modelo global (cargado una vez) ----------
+tokenizer = None
+model = None
+
+@app.on_event("startup")
+def load_model():
+    global tokenizer, model
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+        model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
+        model.to(DEVICE)
+        model.eval()
+    except Exception as e:
+        raise RuntimeError(f"No se pudo cargar el modelo '{MODEL_NAME}': {e}")
+
+# ---------- Utilidades de decodificación/postpro ----------
+def decodificar_tokens(tokens):
+    mol = []
+    for tok in tokens:
+        if tok in SPECIAL_TOKENS:
+            continue
+        if tok.startswith("[") and tok.endswith("]"):
+            contenido = tok[1:-1]
+            if re.match(r'^[A-Za-z0-9@=#+\\/-]+$', contenido):
+                mol.append(contenido)
+            else:
+                mol.append(tok)
+        else:
+            mol.append(tok)
+    return "".join(mol)
+
+def postprocesar_smiles(tokens_string: str) -> str:
+    pattern = re.compile(r'\[.*?\]')
+    tokens = pattern.split(tokens_string)
+    matches = pattern.findall(tokens_string)
+
+    result = []
+    branch_stack = []
+    ring_open = {}
+
+    for i in range(len(tokens)):
+        result.append(tokens[i])
+
+        if i < len(matches):
+            tok = matches[i]
+
+            if tok.startswith("[Branch"):
+                result.append("(")
+                branch_stack.append(")")
+
+            elif tok.startswith("[Ring"):
+                nums = re.findall(r'\d+', tok)
+                if nums:
+                    n = nums[0]
+                    if n not in ring_open:
+                        ring_open[n] = True
+                    else:
+                        del ring_open[n]
+                    result.append(n)
+
+            else:
+                result.append(tok)
+
+    while branch_stack:
+        result.append(branch_stack.pop())
+
+    return "".join(result)
+
+# ---------- Tipos de request/response ----------
+class GenerateRequest(BaseModel):
+    input_text: str
+    max_length: Optional[int] = 60
+    top_k: Optional[int] = 50
+    top_p: Optional[float] = 0.95
+    temperature: Optional[float] = 1.0
+
+class GenerateResponse(BaseModel):
+    raw_tokens_string: str
+    smiles_postprocesado: str
+
+# ---------- Rutas ----------
+@app.get("/health")
+def health():
+    return {"status": "ok", "device": DEVICE, "model": MODEL_NAME}
+
+@app.post("/generate", response_model=GenerateResponse)
+def generate(req: GenerateRequest):
+    if tokenizer is None or model is None:
+        raise HTTPException(status_code=500, detail="Modelo no inicializado")
+
+    try:
+        inputs = tokenizer(req.input_text, return_tensors="pt").to(DEVICE)
+        # Preferimos el token [EOS] si existe, si no el por defecto del tokenizer
+        eos_id = tokenizer.convert_tokens_to_ids("[EOS]")
+        if eos_id is None or eos_id == tokenizer.unk_token_id:
+            eos_id = tokenizer.eos_token_id
+
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs["input_ids"],
+                max_length=req.max_length,
+                do_sample=True,
+                top_k=req.top_k,
+                top_p=req.top_p,
+                temperature=req.temperature,
+                eos_token_id=eos_id,
+            )
+
+        tokens = tokenizer.convert_ids_to_tokens(outputs[0])
+        tokens_string = decodificar_tokens(tokens)
+        smiles = postprocesar_smiles(tokens_string)
+        smiles_final = smiles.replace("Ring", "")
+
+        return GenerateResponse(
+            raw_tokens_string=tokens_string,
+            smiles_postprocesado=smiles
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generando SMILES: {str(e)}")
+

requirements.txt

@@ -1,16 +1,16 @@
---extra-index-url https://download.pytorch.org/whl/cpu
-torch==2.3.1          # wheel CPU estable y liviana
-transformers==4.46.3
-tokenizers==0.20.1    # wheel precompilada (evita compilar Rust)
-safetensors==0.4.5
-huggingface_hub==0.24.6
-
-fastapi==0.115.2
-uvicorn[standard]==0.30.6
-pydantic==2.7.4
-python-dotenv==1.0.1
-httpx==0.28.1         # si lo usás
-pytest==8.4.2
-pytest-asyncio==1.2.0
-gradio==4.44.0
-numpy==1.26.4
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch==2.3.1          # wheel CPU estable y liviana
+transformers==4.46.3
+tokenizers==0.20.1    # wheel precompilada (evita compilar Rust)
+safetensors==0.4.5
+huggingface_hub==0.24.6
+
+fastapi==0.115.2
+uvicorn[standard]==0.30.6
+pydantic==2.7.4
+python-dotenv==1.0.1
+httpx==0.28.1         # si lo usás
+pytest==8.4.2
+pytest-asyncio==1.2.0
+gradio==4.44.0
+numpy==1.26.4

test_local.py

@@ -0,0 +1,14 @@
+import requests
+
+url = "http://127.0.0.1:8000/generate"
+payload = {
+    "input_text": "CCO",
+    "max_length": 60,
+    "top_k": 50,
+    "top_p": 0.95,
+    "temperature": 1.0
+}
+
+response = requests.post(url, json=payload)
+print(response.status_code)
+print(response.json())