Cleanup: Keep only text analyzer

README-HF.md

@@ -1,31 +1,44 @@
-# Text Classification Model Demo
+# Oversai Models Hub
 
-This is a Gradio interface for text classification using a BERT-based model. The model can classify text into predefined categories.
+A comprehensive hub hosting multiple AI models with easy-to-use Gradio interfaces. Access various machine learning models through a single, unified interface.
 
-## Model Details
+## Available Models
 
+### 1. Text Classification
 - Base Model: prajjwal1/bert-tiny
 - Task: Text Classification
-- Interface: Gradio
+- Interface: Simple text input with classification output
+
+### 2. [Future Models]
+- Additional models will be added here
+- Each with its own specialized interface
+- Easy to extend and add new models
 
 ## Usage
 
-1. Enter your text in the input textbox
-2. Click submit
-3. View the classification results
+1. Select the model tab you want to use
+2. Follow the specific input instructions for each model
+3. Get instant results through the interface
 
 ## Technical Details
 
 - Python 3.9+
 - Key Dependencies:
-  - gradio
-  - transformers
-  - torch
-  - numpy
+  - gradio >= 4.19.2
+  - transformers >= 4.38.2
+  - torch >= 2.2.1
+  - numpy >= 1.26.4
 
 ## Deployment
 
-This model is deployed using Hugging Face Spaces with a Gradio interface.
+This model hub is deployed using Hugging Face Spaces with a Gradio interface. All models are accessible through a single, unified interface with multiple tabs.
+
+## Adding New Models
+
+The hub is designed to be easily extensible. New models can be added by:
+1. Implementing the model in `src/models/`
+2. Creating a Gradio interface for it
+3. Adding it to the tabbed interface in `app_hf.py`
 
 ## License
 

app.py

@@ -7,33 +7,32 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 def create_demo():
-    try:
-        # Initialize the model
-        logger.info("Initializing Text Classification model...")
-        model = TextClassificationModel()
-        
-        # Create the interface
-        logger.info("Creating Gradio interface...")
-        demo = model.create_interface()
-        
-        logger.info("Gradio interface created successfully")
-        return demo
-        
-    except Exception as e:
-        logger.error(f"Error creating demo: {str(e)}")
-        raise
+    # Initialize models
+    logger.info("Initializing models...")
+    text_classification_model = TextClassificationModel()
+    # Add more models here as needed
+    
+    # Create the interfaces
+    logger.info("Creating Gradio interfaces...")
+    text_classification_demo = text_classification_model.create_interface()
+    # Add more model interfaces here
+    
+    # Create a tabbed interface
+    demo = gr.TabbedInterface(
+        interface_list=[
+            text_classification_demo,
+            # Add more interfaces here
+        ],
+        tab_names=[
+            "Text Classification",
+            # Add more tab names here
+        ],
+        title="Oversai Models Hub",
+        description="A collection of AI models for various tasks"
+    )
+    
+    return demo
 
-if __name__ == "__main__":
-    try:
-        logger.info("Starting the application...")
-        demo = create_demo()
-        logger.info("Launching the interface...")
-        demo.launch(
-            server_name="0.0.0.0",  # Allow external connections
-            server_port=7860,       # Specify port explicitly
-            share=True             # Enable public URL
-        )
-        logger.info("Interface launched successfully")
-    except Exception as e:
-        logger.error(f"Application error: {str(e)}")
-        raise 
+# Create and launch the demo
+demo = create_demo()
+demo.launch() 

app_hf.py

@@ -1,16 +0,0 @@
-import gradio as gr
-from src.models.text_classification import TextClassificationModel
-import logging
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Initialize the model
-model = TextClassificationModel()
-
-# Create the interface
-demo = model.create_interface()
-
-# Launch the interface (Hugging Face will handle the server configuration)
-demo.launch() 

requirements-full.txt

@@ -1,10 +0,0 @@
-gradio>=4.19.2
-fastapi>=0.110.0
-uvicorn>=0.27.1
-python-dotenv>=1.0.1
-pydantic>=2.6.3
-numpy>=1.26.4
-torch>=2.2.1
-transformers>=4.38.2
-pillow>=10.2.0
-python-multipart>=0.0.9 

requirements.txt

@@ -6,4 +6,5 @@ fastapi>=0.110.0
 uvicorn>=0.27.1
 pydantic>=2.6.3
 pydantic-settings>=2.2.1
-python-dotenv>=1.0.1 
+python-dotenv>=1.0.1
+huggingface-hub>=0.28.1 

test_api.py

@@ -1,60 +0,0 @@
-import requests
-import time
-import logging
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-def test_api():
-    # Wait a bit for the model to load
-    logger.info("Waiting for the server to start...")
-    time.sleep(10)
-    
-    base_url = "http://127.0.0.1:7860"
-    
-    # Test single prediction
-    test_texts = [
-        "This is amazing! I love it!",
-        "This is terrible, I hate it.",
-        "It's okay, nothing special."
-    ]
-    
-    logger.info("\nTesting single predictions:")
-    for text in test_texts:
-        try:
-            logger.info(f"\nTesting with text: {text}")
-            response = requests.post(
-                f"{base_url}/api/predict",
-                json={"text": text}
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                logger.info(f"Result: {result}")
-            else:
-                logger.error(f"Error: {response.status_code} - {response.text}")
-                
-        except Exception as e:
-            logger.error(f"Request failed: {str(e)}")
-        
-        time.sleep(1)  # Small delay between requests
-    
-    # Test batch prediction
-    logger.info("\nTesting batch prediction:")
-    try:
-        response = requests.post(
-            f"{base_url}/api/predict_batch",
-            json={"texts": test_texts}
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
-            logger.info(f"Batch results: {result}")
-        else:
-            logger.error(f"Batch Error: {response.status_code} - {response.text}")
-            
-    except Exception as e:
-        logger.error(f"Batch request failed: {str(e)}")
-
-if __name__ == "__main__":
-    test_api() 

test_client.py

@@ -1,130 +0,0 @@
-import requests
-import json
-import time
-import logging
-from typing import Dict, List, Any, Optional
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class MLModelsClient:
-    """Client for interacting with the ML Models API."""
-    
-    def __init__(self, base_url: str = "http://localhost:8000"):
-        self.base_url = base_url
-        
-    def list_models(self) -> List[Dict]:
-        """List all available models."""
-        try:
-            logger.info("Fetching available models...")
-            response = requests.get(f"{self.base_url}/api/models")
-            response.raise_for_status()
-            models = response.json()
-            logger.info(f"Found {len(models)} models")
-            return models
-        except Exception as e:
-            logger.error(f"Error listing models: {str(e)}")
-            raise
-
-    def get_model_info(self, model_id: str) -> Dict:
-        """Get information about a specific model."""
-        try:
-            logger.info(f"Fetching info for model {model_id}...")
-            response = requests.get(f"{self.base_url}/api/models/{model_id}")
-            response.raise_for_status()
-            return response.json()
-        except Exception as e:
-            logger.error(f"Error getting model info: {str(e)}")
-            raise
-
-    def get_model_status(self, model_id: str) -> str:
-        """Get the current status of a model."""
-        try:
-            logger.info(f"Fetching status for model {model_id}...")
-            response = requests.get(f"{self.base_url}/api/models/{model_id}/status")
-            response.raise_for_status()
-            return response.json()["status"]
-        except Exception as e:
-            logger.error(f"Error getting model status: {str(e)}")
-            raise
-
-    def load_model(self, model_id: str) -> str:
-        """Load a model into memory."""
-        try:
-            logger.info(f"Loading model {model_id}...")
-            response = requests.post(f"{self.base_url}/api/models/{model_id}/load")
-            response.raise_for_status()
-            return response.json()["status"]
-        except Exception as e:
-            logger.error(f"Error loading model: {str(e)}")
-            raise
-
-    def predict(self, model_id: str, text: str) -> Dict:
-        """Make a prediction using a model."""
-        try:
-            logger.info(f"Making prediction with model {model_id}...")
-            model_info = self.get_model_info(model_id)
-            response = requests.post(
-                f"{self.base_url}{model_info.get('api_path')}/predict",
-                json={"text": text}
-            )
-            response.raise_for_status()
-            return response.json()
-        except Exception as e:
-            logger.error(f"Error making prediction: {str(e)}")
-            raise
-
-def test_model_workflow():
-    """Test the complete model workflow."""
-    client = MLModelsClient()
-    
-    try:
-        # 1. List available models
-        logger.info("\n1. Testing model listing...")
-        models = client.list_models()
-        for model in models:
-            logger.info(f"Found model: {json.dumps(model, indent=2)}")
-
-        if not models:
-            logger.error("No models found!")
-            return
-
-        # Use the first model for testing
-        model_id = models[0]["id"]
-
-        # 2. Get model information
-        logger.info(f"\n2. Testing model info retrieval for {model_id}...")
-        model_info = client.get_model_info(model_id)
-        logger.info(f"Model info: {json.dumps(model_info, indent=2)}")
-
-        # 3. Get model status
-        logger.info(f"\n3. Testing model status retrieval for {model_id}...")
-        status = client.get_model_status(model_id)
-        logger.info(f"Model status: {status}")
-
-        # 4. Load the model
-        logger.info(f"\n4. Testing model loading for {model_id}...")
-        load_status = client.load_model(model_id)
-        logger.info(f"Load status: {load_status}")
-
-        # 5. Test predictions
-        test_texts = [
-            "This is amazing! I really love it!",
-            "This is terrible, I hate it.",
-            "It's okay, nothing special."
-        ]
-
-        logger.info(f"\n5. Testing predictions for {model_id}...")
-        for text in test_texts:
-            logger.info(f"\nPredicting for text: {text}")
-            result = client.predict(model_id, text)
-            logger.info(f"Prediction: {json.dumps(result, indent=2)}")
-            time.sleep(1)  # Small delay between predictions
-
-    except Exception as e:
-        logger.error(f"Test workflow failed: {str(e)}")
-        raise
-
-if __name__ == "__main__":
-    logger.info("Starting model testing workflow...")
-    test_model_workflow()