app.py

# # import streamlit as st
# # import torch
# # from transformers import AutoTokenizer, AutoModelForSequenceClassification

# # # Load the model and tokenizer
# # # @st.cache_resource
# # # def load_model():
# # #     tokenizer = AutoTokenizer.from_pretrained('microsoft/deberta-v3-small')
# # #     model = AutoModelForSequenceClassification.from_pretrained("./results/checkpoint-753")
# # #     model.eval()
# # #     return tokenizer, model
# # @st.cache_resource
# # def load_model():
# #     tokenizer = AutoTokenizer.from_pretrained('microsoft/deberta-v3-small', use_fast=False)
# #     model = AutoModelForSequenceClassification.from_pretrained("./results/checkpoint-753")
# #     model.eval()
# #     return tokenizer, model

# # def predict_news(text, tokenizer, model):
# #     inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
# #     with torch.no_grad():
# #         outputs = model(**inputs)
# #     probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
# #     predicted_label = torch.argmax(probabilities, dim=-1).item()
# #     confidence = probabilities[0][predicted_label].item()
# #     return "FAKE" if predicted_label == 1 else "REAL", confidence

# # def main():
# #     st.title("News Classifier")
    
# #     # Load model
# #     tokenizer, model = load_model()
    
# #     # Text input
# #     news_text = st.text_area("Enter news text to analyze:", height=200)
    
# #     if st.button("Classify"):
# #         if news_text:
# #             with st.spinner('Analyzing...'):
# #                 prediction, confidence = predict_news(news_text, tokenizer, model)
                
# #                 # Display results
# #                 if prediction == "FAKE":
# #                     st.error(f"⚠️ {prediction} NEWS")
# #                 else:
# #                     st.success(f"✅ {prediction} NEWS")
                
# #                 st.info(f"Confidence: {confidence*100:.2f}%")

# # if __name__ == "__main__":
# #     main()


import streamlit as st
import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification
from fastapi import FastAPI, Request
from pydantic import BaseModel
from threading import Thread
from streamlit.web import cli

# FastAPI app
api_app = FastAPI()

# Load the model and tokenizer
@st.cache_resource
def load_model():
    tokenizer = AutoTokenizer.from_pretrained('microsoft/deberta-v3-small', use_fast=False)
    model = AutoModelForSequenceClassification.from_pretrained("./results/checkpoint-753")
    model.eval()
    return tokenizer, model

# Prediction function
def predict_news(text, tokenizer, model):
    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
    with torch.no_grad():
        outputs = model(**inputs)
    probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
    predicted_label = torch.argmax(probabilities, dim=-1).item()
    confidence = probabilities[0][predicted_label].item()
    return "FAKE" if predicted_label == 1 else "REAL", confidence

# FastAPI request model
class NewsInput(BaseModel):
    text: str

# FastAPI route for POST requests
@api_app.post("/classify")
async def classify_news(data: NewsInput):
    tokenizer, model = load_model()
    prediction, confidence = predict_news(data.text, tokenizer, model)
    return {
        "prediction": prediction,
        "confidence": f"{confidence*100:.2f}%"
    }

# Streamlit app
def run_streamlit():
    def main():
        st.title("News Classifier")
        
        # Load model
        tokenizer, model = load_model()
        
        # Text input
        news_text = st.text_area("Enter news text to analyze:", height=200)
        
        if st.button("Classify"):
            if news_text:
                with st.spinner('Analyzing...'):
                    prediction, confidence = predict_news(news_text, tokenizer, model)
                    
                    # Display results
                    if prediction == "FAKE":
                        st.error(f"⚠️ {prediction} NEWS")
                    else:
                        st.success(f"✅ {prediction} NEWS")
                    
                    st.info(f"Confidence: {confidence*100:.2f}%")

    main()

# Threaded execution for FastAPI and Streamlit
def start_fastapi():
    import uvicorn
    uvicorn.run(api_app, host="0.0.0.0", port=8502)

if __name__ == "__main__":
    fastapi_thread = Thread(target=start_fastapi, daemon=True)
    fastapi_thread.start()

    # Start Streamlit
    cli.main()

# from fastapi import FastAPI, HTTPException
# from pydantic import BaseModel
# from transformers import AutoTokenizer, AutoModelForSequenceClassification
# import torch

# from fastapi.middleware.cors import CORSMiddleware


# # Define the FastAPI app
# app = FastAPI()

# app.add_middleware(
#     CORSMiddleware,
#     allow_origins=["*"],  # Update with your frontend's URL for security
#     allow_credentials=True,
#     allow_methods=["*"],
#     allow_headers=["*"],
# )
# # Define the input data schema
# class InputText(BaseModel):
#     text: str

# # Load the model and tokenizer (ensure these paths are correct in your Space)
# tokenizer = AutoTokenizer.from_pretrained('microsoft/deberta-v3-small', use_fast=False)
# model = AutoModelForSequenceClassification.from_pretrained("./results/checkpoint-753")
# model.eval()

# # Prediction function
# def predict_news(text: str):
#     inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
#     with torch.no_grad():
#         outputs = model(**inputs)
#     probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
#     predicted_label = torch.argmax(probabilities, dim=-1).item()
#     confidence = probabilities[0][predicted_label].item()
#     return {
#         "prediction": "FAKE" if predicted_label == 1 else "REAL",
#         "confidence": round(confidence * 100, 2)  # Return confidence as a percentage
#     }

# # Define the POST endpoint
# @app.post("/predict")
# async def classify_news(input_text: InputText):
#     try:
#         result = predict_news(input_text.text)
#         return result
#     except Exception as e:
#         raise HTTPException(status_code=500, detail=str(e))