Update app.py

app.py

@@ -1,64 +1,107 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
+# from huggingface_hub import InferenceClient
+from transformers import AutoModelForSequenceClassification, AutoConfig, AutoTokenizer
+import torch
+import numpy as np
 
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
 
+MODEL_NAME = "URaBOT2024/debertaV3_FullFeature"
+
+# Load pre-trained models and tokenizers
+model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME, num_labels = 2)
+config = AutoConfig.from_pretrained(MODEL_NAME)
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+
+# Set hardware target for model
+device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+model.to(device)
+model.eval()    # Set model to evaluation mode
+
+
+
+def verify(psudo_id, username, display_name, tweet_content, is_verified, likes):
+    '''
+    Main Endpoint for URaBOT, a POST request that takes in a tweet's data and returns a "bot" score
+
+    Returns: JSON object {"percent": double} 
+    
+    payload:
+        "psudo_id": the temporary id of the tweet (as assigned in local HTML from Twitter)
+        "username": the profile's username (@tag)
+        "display_name": the profiles display name
+        "tweet_content": the text content of the tweet
+    '''
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
+    # #========== Error codes ==========#
 
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
+    # # Confirm that full payload was sent
+    # if 'username' not in request.form:
+    #     return make_response(jsonify({"error": "Invalid request parameters.", "message" : "No username provided"}), 400)
+        
+    # if 'display_name' not in request.form:
+    #     return make_response(jsonify({"error": "Invalid request parameters.", "message" : "No display_name provided"}), 400)
+        
+    # if 'tweet_content' not in request.form:
+    #     return make_response(jsonify({"error": "Invalid request parameters.", "message" : "No tweet_content provided"}), 400)
+        
+    # # Prevent multiple requests for the same tweet
+    # if request.form["psudo_id"] in processed_tweets:
+    #     return make_response(jsonify({"error": "Conflict, tweet is already being/has been processed"}), 409)
 
-    messages.append({"role": "user", "content": message})
 
-    response = ""
+    # #========== Resolve Multiple Requests ==========#
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
+    # # Add tweet to internal (backend) process list
+    # processed_tweets.append(request.form["psudo_id"])
+
+
+    #========== Return Classification ==========#
+
+    # Process the tweet through the model
+    # input = request.form["tweet_content"] + tokenizer.sep_token + request.form["display_name"] + tokenizer.sep_token +  request.form["is_verified"] + tokenizer.sep_token +  request.form["likes"]
+   
+    input = tweet_content + tokenizer.sep_token + display_name + tokenizer.sep_token + is_verified + tokenizer.sep_token + likes
+    tokenized_input = tokenizer(input, return_tensors='pt', padding=True, truncation=True).to(device)
+    with torch.no_grad():
+        outputs = model(**tokenized_input)
+    
+    # Determine classification
+    sigmoid = (1 / (1 + np.exp(-outputs.logits.detach().numpy()))).tolist()[0]
+
+    # Apply Platt Scaling
+    # if USE_PS:
+    #     sigmoid = [(1/(1+ math.exp(-(A * x + B)))) for x in sigmoid] 
+    
+    # Find majority class
+    label = np.argmax(outputs.logits.detach().numpy(), axis=-1).item()
+
+
+    # Return sigmoid-ish value for classification. Can instead return label for strict 0/1 binary classification
+    if label == 0:
+        return 1 -  sigmoid[0]
+    else:
+        return sigmoid[1]
 
-        response += token
-        yield response
 
 
 """
 For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
 """
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
+# Set up the Gradio Interface
+iface = gr.Interface(
+    fn=verify,              # Function to process input
+    inputs=[gr.inputs.Textbox(label= "Text 1"),
+            gr.inputs.Textbox(label= "Text 2"),
+             gr.inputs.Textbox(label= "Text 3"),
+              gr.inputs.Textbox(label= "Text 4")]    # Input type (Textbox for text)
+    outputs=gr.outputs.Textbox(),   # Output type (Textbox for generated text)
+    live=True                        # Optional: To update the result as you type
 )
 
+# Launch the API on a specific port
+
 
 if __name__ == "__main__":
-    demo.launch()
+    iface.launch(share=True)  # share=True will give you a public URL to use the API
+
+    # demo.launch()