Add initial project structure with FastAPI and poetry generation service

app/api/endpoints/poetry.py

@@ -0,0 +1,44 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+from typing import Optional
+from ...services.poetry_generation import PoetryGenerationService
+
+router = APIRouter()
+
+class PoemRequest(BaseModel):
+    prompt: str = Field(..., description="The prompt for poem generation")
+    temperature: Optional[float] = Field(0.7, ge=0.1, le=2.0)
+    top_p: Optional[float] = Field(0.9, ge=0.1, le=1.0)
+    top_k: Optional[int] = Field(50, ge=1, le=100)
+    max_length: Optional[int] = Field(200, ge=50, le=500)
+    repetition_penalty: Optional[float] = Field(1.1, ge=1.0, le=2.0)
+
+class PoemResponse(BaseModel):
+    poem: str
+    parameters_used: dict
+
+@router.post("/generate", response_model=PoemResponse)
+async def generate_poem(request: PoemRequest):
+    try:
+        service = PoetryGenerationService()
+        poem = await service.generate_poem(
+            prompt=request.prompt,
+            temperature=request.temperature,
+            top_p=request.top_p,
+            top_k=request.top_k,
+            max_length=request.max_length,
+            repetition_penalty=request.repetition_penalty
+        )
+        
+        return PoemResponse(
+            poem=poem,
+            parameters_used={
+                "temperature": request.temperature,
+                "top_p": request.top_p,
+                "top_k": request.top_k,
+                "max_length": request.max_length,
+                "repetition_penalty": request.repetition_penalty
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/services/poetry_generation.py

@@ -0,0 +1,70 @@
+from typing import Optional
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
+
+class PoetryGenerationService:
+    def __init__(self):
+        model_name = "meta-llama/Llama-3.2-3B-Instruct"  # Adjust model name as needed
+        
+        # Initialize tokenizer and model
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            torch_dtype=torch.float16,  # Use float16 for efficiency
+            device_map="auto"  # Automatically handle device placement
+        )
+        
+        # Set model to evaluation mode
+        self.model.eval()
+    
+    async def generate_poem(
+        self,
+        prompt: str,
+        temperature: Optional[float] = 0.7,
+        top_p: Optional[float] = 0.9,
+        top_k: Optional[int] = 50,
+        max_length: Optional[int] = 200,
+        repetition_penalty: Optional[float] = 1.1
+    ) -> str:
+        try:
+            # Tokenize the input prompt
+            inputs = self.tokenizer(prompt, return_tensors="pt", padding=True)
+            
+            # Move input tensors to the same device as the model
+            inputs = {k: v.to(self.model.device) for k, v in inputs.items()}
+            
+            # Generate text with the specified parameters
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    inputs["input_ids"],
+                    attention_mask=inputs["attention_mask"],
+                    do_sample=True,
+                    temperature=temperature,
+                    top_p=top_p,
+                    top_k=top_k,
+                    max_length=max_length,
+                    repetition_penalty=repetition_penalty,
+                    pad_token_id=self.tokenizer.eos_token_id,
+                    eos_token_id=self.tokenizer.eos_token_id,
+                )
+            
+            # Decode the generated text
+            generated_text = self.tokenizer.decode(
+                outputs[0],
+                skip_special_tokens=True,
+                clean_up_tokenization_spaces=True
+            )
+            
+            return generated_text
+            
+        except Exception as e:
+            raise Exception(f"Error generating poem: {str(e)}")
+    
+    def __del__(self):
+        # Clean up resources
+        try:
+            del self.model
+            del self.tokenizer
+            torch.cuda.empty_cache()  # If using GPU
+        except:
+            pass

app/utils/text_processing.py

@@ -0,0 +1,12 @@
+import re
+
+def preprocess_input(mood, theme, style):
+    """Preprocess the user's mood, theme, and style input."""
+    input_text = f"Write a poem with a {mood} mood, about the theme of {theme}, in the style of {style}."
+    input_text = preprocess_text(input_text)
+    return input_text
+
+def preprocess_text(text):
+    """Preprocess the input text (e.g., clean, tokenize)."""
+    text = re.sub(r'\s+', ' ', text.strip().lower())
+    return text

main.py

@@ -0,0 +1,37 @@
+from fastapi import FastAPI
+from app.api.endpoints.poetry import router as poetry_router
+
+app = FastAPI()
+app.include_router(poetry_router, prefix="/api/v1/poetry")
+
+if __name__ == "__main__":
+    import os
+    import logging
+    from typing import Tuple
+    from starlette.applications import Starlette
+    from starlette.responses import Response
+    from starlette.routing import Route
+    from starlette.staticfiles import StaticFiles
+
+    logging.basicConfig(level=logging.INFO)
+    logger = logging.getLogger(__name__)
+
+    def get_app_and_port() -> Tuple[Starlette, int]:
+        port = int(os.getenv("PORT", "8000"))
+        return app, port
+
+    async def lifecheck(request):
+        return Response("OK", media_type="text/plain")
+
+    routes = [
+        Route("/", app.router),
+        Route("/healthz", lifecheck),
+    ]
+
+    app_and_port = get_app_and_port()
+    app = app_and_port[0]
+    port = app_and_port[1]
+
+    logger.info(f"Starting FastAPI server on port {port}")
+    app.mount("/static", StaticFiles(directory="static"), name="static")
+    app.run(host="0.0.0.0", port=port)

requirements.txt

@@ -0,0 +1,19 @@
+# Core dependencies
+gradio==4.19.2
+fastapi==0.109.2
+uvicorn==0.27.1
+pydantic==2.6.1
+
+# For API requests and handling
+requests==2.31.0
+python-multipart==0.0.9
+
+# For model handling
+torch==2.2.0
+transformers==4.37.2
+accelerate==0.27.2
+
+# Optional but recommended for performance
+python-jose==3.3.0  # for JWT handling if you add auth later
+gunicorn==21.2.0    # for production deployment
+python-dotenv==1.0.0  # for environment variables