Update app.py

app.py

@@ -17,7 +17,7 @@ import urllib.parse
 import http.client
 
 # Suppress warnings
-warnings.filterwarnings('ignore', category=UserWarning)  # Corrected here
+warnings.filterwarnings('ignore', category=UserWarning)
 os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
 
 def initialize_environment():
@@ -52,7 +52,7 @@ logger = initialize_environment()
 
 class GitHubAPI:
     """GitHub API handler with rate limiting and error handling"""
-    
+
     def __init__(self, token: str):
         self.token = token
         self.headers = {
@@ -113,9 +113,9 @@ class GitHubAPI:
 
 class GitHubBot:
     """Main GitHub bot implementation"""
-    
+
     def __init__(self):
-        self.github_api = None 
+        self.github_api = None
     def initialize_api(self, token: str):
         """Initialize GitHub API with token"""
         self.github_api = GitHubAPI(token)
@@ -395,11 +395,12 @@ if __name__ == "__main__":
         raise
     finally:
         logger.info("Application shutdown")
+
 from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
 
 class HuggingFaceModel:
     """Class to handle Hugging Face model loading and predictions"""
-    
+
     def __init__(self, model_name: str):
         self.model_name = model_name
         self.model = None
@@ -496,103 +497,13 @@ def create_gradio_interface():
 
     return demo
 
-from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
-
-class HuggingFaceModel:
-    """Class to handle Hugging Face model loading and predictions"""
-    
-    def __init__(self, model_name: str):
-        self.model_name = model_name
-        self.model = None
-        self.tokenizer = None
-        self.load_model()
-
-    def load_model(self):
-        """Load the Hugging Face model and tokenizer"""
-        try:
-            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-            self.model = AutoModelForSequenceClassification.from_pretrained(self.model_name)
-            logger.info(f"Model {self.model_name} loaded successfully.")
-        except Exception as e:
-            logger.error(f"Error loading model {self.model_name}: {str(e)}")
-            raise
-
-    def predict(self, text: str) -> Dict:
-        """Make a prediction using the loaded model"""
-        try:
-            inputs = self.tokenizer(text, return_tensors="pt")
-            outputs = self.model(**inputs)
-            predictions = outputs.logits.argmax(dim=-1).item()
-            logger.info(f"Prediction made for input: {text} with result: {predictions}")
-            return {"prediction": predictions}
-        except Exception as e:
-            logger.error(f"Error making prediction: {str(e)}")
-            return {"error": str(e)}
-
-# Update the Gradio interface to include model loading and prediction
-def create_gradio_interface():
-    """Create and configure Gradio interface with custom styling"""
-    bot = GitHubBot()
-    hf_model = None  # Initialize Hugging Face model variable
-
-    with gr.Blocks(css=custom_css, theme=gr.themes.Base()) as demo:
-        # Existing Gradio components...
-
-        model_name = gr.Textbox(
-            label="Hugging Face Model Name",
-            placeholder="Enter the model name (e.g., 'distilbert-base-uncased')",
-            elem_classes="input input-bordered input-primary"
-        )
-
-        load_model_button = gr.Button(
-            "Load Model",
-            elem_classes="button button-primary"
-        )
-
-        prediction_text = gr.Textbox(
-            label="Input Text for Prediction",
-            placeholder="Enter text to classify...",
-            elem_classes="textarea textarea-primary"
-        )
-
-        predict_button = gr.Button(
-            "Make Prediction",
-            elem_classes="button button-success"
-        )
-
-        output_prediction = gr.Textbox(
-            label="Prediction Output",
-            interactive=False,
-            elem_classes="output-area"
-        )
-
-        # Load model handler
-        def load_model_handler(model_name_input):
-            nonlocal hf_model
-            try:
-                hf_model = HuggingFaceModel(model_name_input)
-                return f"Model {model_name_input} loaded successfully."
-            except Exception as e:
-                return f"Error loading model: {str(e)}"
-
-        # Prediction handler
-        def predict_handler(input_text):
-            if hf_model is None:
-                return "Model not loaded. Please load a model first."
-            result = hf_model.predict(input_text)
-            return result
-
-        # Connect components
-        load_model_button.click(
-            load_model_handler,
-            inputs=[model_name],
-            outputs=[output_prediction]
-        )
-
-        predict_button.click(
-            predict_handler,
-            inputs=[prediction_text],
-            outputs=[output_prediction]
-        )
+def initialize_zero_gpu():
+    """Initialize Hugging Face ZeroGPU"""
+    try:
+        import torch
+        torch.cuda.is_available()
+        print("Hugging Face ZeroGPU is not available. Using GPU instead.")
+    except Exception as e:
+        print(f"Error initializing Hugging Face ZeroGPU: {str(e)}")
 
-    return demo
+initialize_zero_gpu()