Made changes to the files that need it for testing on huggingface, Dockerfile included

Dockerfile

@@ -1,49 +1,34 @@
-# syntax=docker/dockerfile:1
+# Use a lightweight Python image
+FROM python:3.10.12
 
-# Comments are provided throughout this file to help you get started.
-# If you need more help, visit the Dockerfile reference guide at
-# https://docs.docker.com/engine/reference/builder/
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
 
-ARG PYTHON_VERSION=3.12
-FROM python:${PYTHON_VERSION}-slim as base
-
-# Prevents Python from writing pyc files.
-ENV PYTHONDONTWRITEBYTECODE=1
-
-# Keeps Python from buffering stdout and stderr to avoid situations where
-# the application crashes without emitting any logs due to buffering.
-ENV PYTHONUNBUFFERED=1
+# Create a non-root user
+RUN useradd -m -u 1000 user
 
+# Set up the working directory
 WORKDIR /app
 
-# Create a non-privileged user that the app will run under.
-# See https://docs.docker.com/go/dockerfile-user-best-practices/
-ARG UID=10001
-RUN adduser \
-    --disabled-password \
-    --gecos "" \
-    --home "/nonexistent" \
-    --shell "/sbin/nologin" \
-    --no-create-home \
-    --uid "${UID}" \
-    appuser
-
-# Download dependencies as a separate step to take advantage of Docker's caching.
-# Leverage a cache mount to /root/.cache/pip to speed up subsequent builds.
-# Leverage a bind mount to requirements.txt to avoid having to copy them into
-# into this layer.
-RUN --mount=type=cache,target=/root/.cache/pip \
-    --mount=type=bind,source=requirements.txt,target=requirements.txt \
-    python -m pip install -r requirements.txt
-
-# Switch to the non-privileged user to run the application.
-USER appuser
-
-# Copy the source code into the container.
+# Copy the requirements and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy the rest of the application
 COPY . .
 
-# Expose the port that the application listens on.
-EXPOSE 8000
+# Create and set permissions for the cache directory
+RUN mkdir -p /.cache /app/.cache && \
+    chown -R user:user /.cache /app/.cache && \
+    chmod -R u+w,go-w /.cache /app/.cache
+i
+ENV TORCH_HOME=/app/.cache/torch
+
+# Switch to the non-root user
+USER user
 
-# Run the application.
-CMD uvicorn '.venv.lib.python3.9.site-packages.httpx._transports.asgi:application' --host=0.0.0.0 --port=8000
+# Run the application, including the migration step
+CMD ["bash", "-c", "alembic upgrade head && uvicorn main:app --host 0.0.0.0 --port 7860"]

main.py

@@ -1,128 +1,134 @@
 import base64
-from typing import Annotated, Optional
-from fastapi import (Body, FastAPI, File, Form, HTTPException, UploadFile,
-                     status)
+import logging
+from typing import List, Optional
+from fastapi import Depends, FastAPI, File, Form, HTTPException, UploadFile, status
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
-from pydantic import AnyHttpUrl, UrlConstraints
+from pydantic import AnyHttpUrl, BaseModel, UrlConstraints
+from contextlib import asynccontextmanager
 
-from config import settings
+from config import Settings, get_settings
 import uvicorn
 from utils.audio_utils import AudioUtils
 from utils.caption_utils import ImageCaptioning
 from utils.image_utils import UrlTest
 from utils.topic_generation import TopicGenerator
 
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Pydantic models for request/response
+class TopicResponse(BaseModel):
+    topics: List[str]
+    caption: Optional[str]
+
+class AudioResponse(BaseModel):
+    audio_base64: str
+
+class TranscriptionResponse(BaseModel):
+    audio_transcription: str
+
+# Context manager for startup and shutdown events
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    app.state.topic_generator = TopicGenerator()
+    app.state.img_caption = ImageCaptioning()
+    app.state.audio_utils = AudioUtils()
+    app.state.url_utils = UrlTest()
+    logger.info("Application startup complete")
+    yield
+    # Shutdown
+    logger.info("Application shutdown")
+
 app = FastAPI(
-    title=settings.PROJECT_NAME,
+    title="Rediones API",
+    lifespan=lifespan,
 )
 
 # CORS
-if settings:
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins='*',
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
-
-topic_generator = TopicGenerator()
-img_caption = ImageCaptioning()
-audio_utils = AudioUtils()
-utils = UrlTest()
-
+@app.on_event("startup")
+async def startup_event():
+    settings = get_settings()
+    if settings.ALLOWED_ORIGINS:
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=settings.ALLOWED_ORIGINS,
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
 
 @app.get("/")
-def root():
+async def root():
     return {"message": "Welcome To Rediones API"}
 
-
 @app.get("/health")
-def health():
-    return {"message": "OK"}
-
-
-@app.post("/topicgen")
-def generate_topic(
-    img: UploadFile = File(
-        default=None,
-        description="Image file. It mutually excludes ImgUrl",
-        # regex=r"^.+\.(jpg|png|jpeg)$"
-    ),
-    text: Annotated[Optional[str], Form()] = None,
-    img_url: Annotated[
-        Optional[AnyHttpUrl],
-        UrlConstraints(allowed_schemes=["https"]),
-        Form(description=(
-            "Image url only accepts https scheme. It mutually excludes Img"
-        ))
-    ] = None,
+async def health():
+    return {"status": "OK"}
+
+@app.post("/topicgen", response_model=TopicResponse)
+async def generate_topic(
+    img: UploadFile = File(None),
+    text: Optional[str] = Form(None),
+    img_url: Optional[AnyHttpUrl] = Form(None),
+    settings: Settings = Depends(get_settings)
 ):
-    if img_url and img:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Only one of image_url or img can be accepted"
-        )
-    # if only text is provided
-    elif text is not None and img is None and img_url is None:
-        generated_topics = topic_generator.generate_topics(text)
-        return {"topics": generated_topics}
-
-    # if image/image_url is provided with or without text
-    elif img or img_url or text:
-        img_file_object = None  # initialize img_file_object
-        # decide whether img or img_url is provided
-        if img:
-            # image file must be ended with .jpg, .png, .jpeg
-            if not str(img.filename).endswith(
-                (".jpg", ".png", ".jpeg")
-            ):
-                raise HTTPException(
-                    status_code=status.HTTP_400_BAD_REQUEST,
-                    detail="Image file must be ended with .jpg, .png, .jpeg"
-                )
-            img_file_object = img.file
-        elif img_url:
-            img_file_object = utils.load_image(img_url)
-
-        # decide whether text is provided
-        if text is None:
-            capt = img_caption.get_caption(img_file_object)
-        else:
-            capt = str(text) + "." + img_caption.get_caption(img_file_object)
-
-        generated_topics = topic_generator.generate_topics(capt)
-        return {"topics": generated_topics}
-
-    else:
+    try:
+        if img_url and img:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Only one of image_url or img can be accepted"
+            )
+        
+        if text and not (img or img_url):
+            generated_topics = app.state.topic_generator.generate_topics(text)
+            return TopicResponse(topics=generated_topics, caption=None)
+
+        if img or img_url:
+            img_file_object = None
+            if img:
+                if not img.filename.lower().endswith((".jpg", ".png", ".jpeg")):
+                    raise HTTPException(
+                        status_code=status.HTTP_400_BAD_REQUEST,
+                        detail="Image file must be ended with .jpg, .png, .jpeg"
+                    )
+                img_file_object = img.file
+            elif img_url:
+                img_file_object = app.state.url_utils.load_image(img_url)
+
+            capt = app.state.img_caption.combo_model(img_file_object, text)
+            return TopicResponse(topics=capt.topics, caption=capt.caption)
+
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
-            detail="enter text or image. "
-            "imageurl and img are mutually exclusive"
+            detail="Enter text or image. Image URL and image file are mutually exclusive."
         )
-
-
-@app.post("/audioverse")
-def generate_audio(
-    text: Annotated[str, Body(description="Text to be transcribed.")]
-):
-    if text is not None:
-        audio_bytes = audio_utils.speak(text)
+    except Exception as e:
+        logger.error(f"Error in generate_topic: {str(e)}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="An unexpected error occurred")
+
+@app.post("/audioverse", response_model=AudioResponse)
+async def generate_audio(text: str):
+    try:
+        audio_bytes = app.state.audio_utils.speak(text)
         audio_base64 = base64.b64encode(audio_bytes).decode("utf-8")
-        return JSONResponse(content={"audio_base64": audio_base64})
-
-@app.post("/transcribe")
-def transcribe_audio(
-    audio: UploadFile = File(
-        default=None,
-        description="Audio file to be transcribed."
-    )
+        return AudioResponse(audio_base64=audio_base64)
+    except Exception as e:
+        logger.error(f"Error in generate_audio: {str(e)}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="An unexpected error occurred")
+
+@app.post("/transcribe", response_model=TranscriptionResponse)
+async def transcribe_audio(
+    audio: UploadFile = File(..., description="Audio file to be transcribed.")
 ):
-    if audio is not None:
-        audio_transcribe = audio_utils.improved_transcribe(0.8, audio_file=audio.file)
-        return JSONResponse(content={"audio_transcription": audio_transcribe})
-    
+    try:
+        audio_transcribe = app.state.audio_utils.improved_transcribe(0.8, audio_file=audio.file)
+        return TranscriptionResponse(audio_transcription=audio_transcribe)
+    except Exception as e:
+        logger.error(f"Error in transcribe_audio: {str(e)}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="An unexpected error occurred")
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="127.0.0.1", port=8000)
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

utils/caption_utils.py

@@ -21,53 +21,75 @@ class ImageCaptioning:
     def generate_caption(self, image):
         # Generate Caption
         input_text = self.blip_processor(image, return_tensors="pt")
-        outputs = self.blip_model.generate(pixel_values=input_text["pixel_values"], max_new_tokens=128, do_sample=True, temperature=0.9, top_k=50, top_p=0.95)
+        outputs = self.blip_model.generate(pixel_values=input_text["pixel_values"], max_new_tokens=128, do_sample=True, temperature=0.5, top_k=50, top_p=0.95)
         caption_output = [self.blip_processor.decode(output, skip_special_tokens=True) for output in outputs]
 
         return outputs
 
     
-    def generate_topics(self, user_input, num_topics=3):
-        query = f"""Generate a topic sentence idea based on the user input. 
-            The generated topics should portray the context or idea behind the given sentences or phrase.
-            For Instance,
-                - "Grocery Shopping" OR "Grocery List" OR "Shopping List": "I'm going grocery shopping tomorrow, 
-                and I would like to get the following things on my grocery list: Milk, Soybeans, Cowpeas, 
-                Saturated Water, Onions, Tomatoes, etc."
-                - "Studying For Exams" OR "Exams Studies": "Exams aare coming up and I have to prepare for the core 
-                courses. I'll be studying for Control Systems, Software Engineering and Circuit Theory."
-                - "Healthy Breakfast": "To prepare a healthy breakfast, I need the appropriate combination of balanced 
-                diet. I'll need oats, yogurt, fresh berries, honey and smoothies."
-                -  "Fitness Routine": "Starting a fitness routine involves workout clothes, running shoes, 
-                a water bottles, and a gym membership. With this, I can start a proper fitness plan."
-                - "Summer Vacation": "Packing swimsuits and enjoy the view of the ocean."
-                - "Coffee Break": "Sipping Coffee at the table."
-                - "Relaxation": "Sitting at the table enjoying."
-                
-            This is what I'm expecting the model to do. Here is the input: {user_input}
-                       """
-            
-        caption_input = self.topic_generator_processor(query, return_tensors="pt", padding=True, truncation=True, max_length=512)
-        caption_output = self.topic_generator_model.generate(**caption_input, temperature=0.1, num_return_sequences=num_topics, do_sample=True, max_length=50, top_k=50, top_p=0.95, num_beams=5) 
-        caption_output = [self.topic_generator_processor.decode(output, skip_special_tokens=True) for output in caption_output]
+    def generate_topics(self, caption, additional_text=None, num_topics=3):
+        base_prompt = "Generate short, creative titles or topics based on the detailed information provided:"
 
-        return caption_output
+        # Construct the prompt based on whether additional context is provided
+        if additional_text:
+            full_prompt = (f"{base_prompt}\n\n"
+                        f"Image description: {caption}\n\n"
+                        f"Additional context: {additional_text}\n\n"
+                        f"Task: Create {num_topics} inventive titles or topics (2-5 words each) that blend the essence of the image with the additional context. "
+                        f"These titles should be imaginative and suitable for use as hashtags, image titles, or starting points for discussions."
+                        f"IMPORTANT: Be imaginative and concise in your responses. Avoid repeating the same ideas in different words."
+                        f"Also make sure to provide a title/topic that relates to every context provided while following the examples listed below as a way of being creative and intuitive."
+                        )
+        else:
+            full_prompt = (f"{base_prompt}\n\n"
+                        f"Image description: {caption}\n\n"
+                        f"Task: Create {num_topics} inventive titles or topics (2-5 words each) that encapsulate the essence of the image. "
+                        f"These titles should be imaginative and suitable for use as hashtags, image titles, or starting points for discussions."
+                        f"IMPORTANT: Be imaginative and concise in your responses. Avoid repeating the same ideas in different words."
+                        f"Also make sure to provide a title/topic that relates to every context provided while following the examples listed below as a way of being creative and intuitive."
+                        )
 
-    def combo_model(self, image):
+        # Provide creative examples to inspire the model
+        examples = """
+        Creative examples to inspire your titles/topics:
+        - "Misty Peaks at Dawn"
+        - "Graffiti Lanes of Urbania"
+        - "Chef’s Secret Ingredients"
+        - "Neon Future Skylines"
+        - "Puppy’s First Snow"
+        - "Edge of Adventure"
+        """
+
+        # Append the examples to the prompt with a clear creative directive
+        full_prompt += f"\n{examples}\nNow, inspired by these examples, create {num_topics} short and descriptive titles/topics based on the information provided.\n"
+
+        print(full_prompt)
+
+        # Generate the topics using the T5 model with adjusted parameters
+        inputs = self.topic_generator_processor(full_prompt, return_tensors="pt", padding=True, truncation=True, max_length=512)
+        outputs = self.topic_generator_model.generate(
+            **inputs,
+            num_return_sequences=num_topics,
+            do_sample=True,
+            temperature=0.7,
+            max_length=32,  # Reduced for shorter outputs
+            top_k=50,
+            top_p=0.95,
+            num_beams=5,
+            no_repeat_ngram_size=2
+        )
+
+        topics = [self.topic_generator_processor.decode(output, skip_special_tokens=True).strip() for output in outputs]
+        return [topic for topic in topics if topic and len(topic.split()) > 1]
+
+    def combo_model(self, image, additional_text=None):
         image = img.load_image(image)
         caption = self.generate_caption(image)
         caption = self.blip_processor.decode(caption[0], skip_special_tokens=True)
-        topics = self.generate_topics(caption)
-        topics = [topic for topic in topics if len(topic) > 0]
-        return {"caption": caption,
-                "topics": topics}
+        topics = self.generate_topics(caption, additional_text)
+        
+        return {
+            "caption": caption,
+            "topics": topics
+        }
 
-    
-if __name__ == "__main__":
-    # Initialize Model
-    model = ImageCaptioning()
-    # Test Image
-    image = "1071642.jpg"
-    # Generate Caption and Topics
-    outputs = model.combo_model(image)
-    print(outputs)

utils/topic_generation.py

@@ -1,51 +1,45 @@
 import requests
-from dotenv import load_dotenv
-import os
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 
-load_dotenv()
-
-huggingface = os.getenv("HUGGINGFACE")
 
 
 class TopicGenerator:
 
     def __init__(self):
-        # Initialize API-URL and authorization headers
-        self.url = "https://api-inference.huggingface.co/models/google/flan-t5-large"
-        self.headers = {"Authorization": f"Bearer {huggingface}"}
-
-    def query(self, payload):
-        response = requests.post(self.url, headers=self.headers,
-                                 json=payload)
-        return response
+        # Initialize Model and Tokenizer
+        self.topic_generator_processor = AutoTokenizer.from_pretrained("google/flan-t5-large")
+        self.topic_generator_model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-large")
+        self.topic_generator_model.eval()
     
     def generate_topics(self, user_input, num_topics=3):
-        payload = {
-            "inputs": f"""Generate a topic sentence idea based on the user input. 
-            The generated topics should portray the context or idea behind the given sentences or phrase.
-            For Instance,
-                - "Grocery Shopping" OR "Grocery List" OR "Shopping List": "I'm going grocery shopping tomorrow, 
-                and I would like to get the following things on my grocery list: Milk, Soybeans, Cowpeas, 
-                Saturated Water, Onions, Tomatoes, etc."
-                - "Studying For Exams" OR "Exams Studies": "Exams aare coming up and I have to prepare for the core 
-                courses. I'll be studying for Control Systems, Software Engineering and Circuit Theory."
-                - "Healthy Breakfast": "To prepare a healthy breakfast, I need the appropriate combination of balanced 
-                diet. I'll need oats, yogurt, fresh berries, honey and smoothies."
-                -  "Fitness Routine": "Starting a fitness routine involves workout clothes, running shoes, 
-                a water bottles, and a gym membership. With this, I can start a proper fitness plan."
-                - "Summer Vacation": "Packing swimsuits and enjoy the view of the ocean."
-                - "Coffee Break": "Sipping Coffee at the table."
-                - "Relaxation": "Sitting at the table enjoying."
-                
-            This is what I'm expecting the model to do. Here is the input: {user_input}
-                       """,
-            "do_sample": True,
-            "temperature": 0.7,
-            "num_return_sequences": num_topics
-            }
-        output = self.query(payload)
-        if output.status_code == 200:
-            topic = output.json()
-            return topic
-        else:
-            return f"Error: Received response code {output.status_code}"
+        base_prompt = "Generate short, creative titles or topics based on the detailed information provided:"
+
+        # Construct the prompt based on whether additional context is provided
+        full_prompt = (f"{base_prompt}\n\n"
+                    f"Context: {user_input}\n\n"
+                    f"Task: Create {num_topics} inventive titles or topics (2-5 words each) that blend the essence of the image with the additional context. "
+                    f"These titles should be imaginative and suitable for use as hashtags, image titles, or starting points for discussions."
+                    f"IMPORTANT: Be imaginative and concise in your responses. Avoid repeating the same ideas in different words."
+                    f"Also make sure to provide a title/topic that relates to every context provided while following the examples listed below as a way of being creative and intuitive."
+                    )
+        
+        # Provide creative examples to inspire the model
+        examples = """
+        Creative examples to inspire your titles/topics:
+        - "Misty Peaks at Dawn"
+        - "Graffiti Lanes of Urbania"
+        - "Chef’s Secret Ingredients"
+        - "Neon Future Skylines"
+        - "Puppy’s First Snow"
+        - "Edge of Adventure"
+        """
+
+        full_prompt += examples
+
+        # Generate Topics
+        input_text = self.topic_generator_processor(full_prompt, return_tensors="pt")
+        outputs = self.topic_generator_model.generate(input_ids=input_text["input_ids"], max_length=20, num_return_sequences=num_topics, num_beams=5, no_repeat_ngram_size=5, top_k=50, top_p=0.95, temperature=0.9)
+        topics = [self.topic_generator_processor.decode(output, skip_special_tokens=True) for output in outputs]
+
+        return topics
+