Added model and streamlit file

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,13 @@
+---
+title: Nexus NLP Model
+emoji: 🏆
+colorFrom: green
+colorTo: green
+sdk: streamlit
+sdk_version: 1.41.1
+app_file: app.py
+pinned: false
+short_description: contains nlp model used for truthtell hackathon
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,64 @@
+from fastapi import FastAPI, UploadFile, File
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from final import predict_news, get_gemini_analysis
+import os
+from tempfile import NamedTemporaryFile
+
+app = FastAPI()
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173"],  # Your React app's URL
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Rest of your code remains the same
+class NewsInput(BaseModel):
+    text: str
+
+@app.post("/analyze")
+async def analyze_news(news: NewsInput):
+    prediction = predict_news(news.text)
+    gemini_analysis = get_gemini_analysis(news.text)
+    
+    return {
+        "prediction": prediction,
+        "detailed_analysis": gemini_analysis
+    }
+
+@app.post("/detect-deepfake")
+async def detect_deepfake(file: UploadFile = File(...)):
+    try:
+        # Save uploaded file temporarily
+        with NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.filename)[1]) as temp_file:
+            contents = await file.read()
+            temp_file.write(contents)
+            temp_file_path = temp_file.name
+
+        # Import functions from testing2.py
+        from deepfake2.testing2 import predict_image, predict_video
+
+        # Use appropriate function based on file type
+        if file.filename.lower().endswith('.mp4'):
+            result = predict_video(temp_file_path)
+            file_type = "video"
+        else:
+            result = predict_image(temp_file_path)
+            file_type = "image"
+        
+        # Clean up temp file
+        os.remove(temp_file_path)
+        
+        return {
+            "result": result,
+            "file_type": file_type
+        }
+            
+    except Exception as e:
+        return {"error": str(e)}, 500
+
+

final.py

@@ -0,0 +1,139 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import spacy
+import google.generativeai as genai
+import json
+import os
+import dotenv
+
+dotenv.load_dotenv()
+
+# Load spaCy for NER
+nlp = spacy.load("en_core_web_sm")
+
+# Load the trained ML model
+model_path = "./results/checkpoint-753"  # Replace with the actual path to your model
+tokenizer = AutoTokenizer.from_pretrained('microsoft/deberta-v3-small')
+model = AutoModelForSequenceClassification.from_pretrained(model_path)
+model.eval()
+
+def setup_gemini():
+    genai.configure(api_key=os.getenv("GEMINI_API"))
+    model = genai.GenerativeModel('gemini-pro')
+    return model
+
+def predict_with_model(text):
+    """Predict whether the news is real or fake using the ML 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()
+    return "FAKE" if predicted_label == 1 else "REAL"
+
+def extract_entities(text):
+    """Extract named entities from text using spaCy."""
+    doc = nlp(text)
+    entities = [(ent.text, ent.label_) for ent in doc.ents]
+    return entities
+
+def predict_news(text):
+    """Predict whether the news is real or fake using the ML model."""
+    # Predict with the ML model
+    prediction = predict_with_model(text)
+    return prediction
+
+def analyze_content_gemini(model, text):
+    prompt = f"""Analyze this news text and return a JSON object with the following structure:
+    {{
+        "gemini_analysis": {{
+            "predicted_classification": "Real or Fake",
+            "confidence_score": "0-100",
+            "reasoning": ["point1", "point2"]
+        }},
+        "text_classification": {{
+            "category": "",
+            "writing_style": "Formal/Informal/Clickbait",
+            "target_audience": "",
+            "content_type": "news/opinion/editorial"
+        }},
+        "sentiment_analysis": {{
+            "primary_emotion": "",
+            "emotional_intensity": "1-10",
+            "sensationalism_level": "High/Medium/Low",
+            "bias_indicators": ["bias1", "bias2"],
+            "tone": {{"formality": "formal/informal", "style": "Professional/Emotional/Neutral"}},
+            "emotional_triggers": ["trigger1", "trigger2"]
+        }},
+        "entity_recognition": {{
+            "source_credibility": "High/Medium/Low",
+            "people": ["person1", "person2"],
+            "organizations": ["org1", "org2"],
+            "locations": ["location1", "location2"],
+            "dates": ["date1", "date2"],
+            "statistics": ["stat1", "stat2"]
+        }},
+        "context": {{
+            "main_narrative": "",
+            "supporting_elements": ["element1", "element2"],
+            "key_claims": ["claim1", "claim2"],
+            "narrative_structure": ""
+        }},
+        "fact_checking": {{
+            "verifiable_claims": ["claim1", "claim2"],
+            "evidence_present": "Yes/No",
+            "fact_check_score": "0-100"
+        }}
+    }}
+
+    Analyze this text and return only the JSON response: {text}"""
+    
+    response = model.generate_content(prompt)
+    try:
+        cleaned_text = response.text.strip()
+        if cleaned_text.startswith('```json'):
+            cleaned_text = cleaned_text[7:-3]
+        return json.loads(cleaned_text)
+    except json.JSONDecodeError:
+        return {
+            "gemini_analysis": {
+                "predicted_classification": "UNCERTAIN",
+                "confidence_score": "50",
+                "reasoning": ["Analysis failed to generate valid JSON"]
+            }
+        }
+
+def clean_gemini_output(text):
+    """Remove markdown formatting from Gemini output"""
+    text = text.replace('##', '')
+    text = text.replace('**', '')
+    return text
+
+def get_gemini_analysis(text):
+    """Get detailed content analysis from Gemini."""
+    gemini_model = setup_gemini()
+    gemini_analysis = analyze_content_gemini(gemini_model, text)
+    return gemini_analysis
+
+def main():
+    print("Welcome to the News Classifier!")
+    print("Enter your news text below. Type 'Exit' to quit.")
+    
+    while True:
+        news_text = input("\nEnter news text: ")
+        
+        if news_text.lower() == 'exit':
+            print("Thank you for using the News Classifier!")
+            return
+            
+        # Get ML prediction
+        prediction = predict_news(news_text)
+        print(f"\nML Analysis: {prediction}")
+        
+        # Get Gemini analysis
+        print("\n=== Detailed Gemini Analysis ===")
+        gemini_result = get_gemini_analysis(news_text)
+        print(gemini_result)
+
+if __name__ == "__main__":
+    main()

results/checkpoint-753/config.json

@@ -0,0 +1,35 @@
+{
+  "_name_or_path": "microsoft/deberta-v3-xsmall",
+  "architectures": [
+    "DebertaV2ForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 384,
+  "initializer_range": 0.02,
+  "intermediate_size": 1536,
+  "layer_norm_eps": 1e-07,
+  "max_position_embeddings": 512,
+  "max_relative_positions": -1,
+  "model_type": "deberta-v2",
+  "norm_rel_ebd": "layer_norm",
+  "num_attention_heads": 6,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "pooler_dropout": 0,
+  "pooler_hidden_act": "gelu",
+  "pooler_hidden_size": 384,
+  "pos_att_type": [
+    "p2c",
+    "c2p"
+  ],
+  "position_biased_input": false,
+  "position_buckets": 256,
+  "relative_attention": true,
+  "share_att_key": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.46.2",
+  "type_vocab_size": 0,
+  "vocab_size": 128100
+}

results/checkpoint-753/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c8bc472032aa1625a83fa5a61358b394aa47e8936084fd5d5fc53d39b4819e7
+size 283347432

results/checkpoint-753/optimizer.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d54a2486861a93c63c9d3f1ad129317a5ec061c153cc35f88750193eb19c8db
+size 566814714

results/checkpoint-753/rng_state.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bab711e45afdac9084a8d3228aa5d84f0234c10b8536782c428a3e5241e763c0
+size 14244

results/checkpoint-753/scheduler.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2254eb2782bb8f96d8221a7f05be58b9aa6b59a9ac623c10f2d2cc29c6abdd07
+size 1064

results/checkpoint-753/trainer_state.json

@@ -0,0 +1,64 @@
+{
+  "best_metric": 0.13373112678527832,
+  "best_model_checkpoint": "./results\\checkpoint-503",
+  "epoch": 2.99403578528827,
+  "eval_steps": 500,
+  "global_step": 753,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 0.9980119284294234,
+      "eval_loss": 0.16927649080753326,
+      "eval_runtime": 34.3209,
+      "eval_samples_per_second": 58.623,
+      "eval_steps_per_second": 3.671,
+      "step": 251
+    },
+    {
+      "epoch": 1.9880715705765408,
+      "grad_norm": 3.436805248260498,
+      "learning_rate": 2.53479125248509e-05,
+      "loss": 0.2895,
+      "step": 500
+    },
+    {
+      "epoch": 2.0,
+      "eval_loss": 0.13373112678527832,
+      "eval_runtime": 32.7048,
+      "eval_samples_per_second": 61.52,
+      "eval_steps_per_second": 3.853,
+      "step": 503
+    },
+    {
+      "epoch": 2.99403578528827,
+      "eval_loss": 0.1674525886774063,
+      "eval_runtime": 33.2196,
+      "eval_samples_per_second": 60.567,
+      "eval_steps_per_second": 3.793,
+      "step": 753
+    }
+  ],
+  "logging_steps": 500,
+  "max_steps": 753,
+  "num_input_tokens_seen": 0,
+  "num_train_epochs": 3,
+  "save_steps": 500,
+  "stateful_callbacks": {
+    "TrainerControl": {
+      "args": {
+        "should_epoch_stop": false,
+        "should_evaluate": false,
+        "should_log": false,
+        "should_save": true,
+        "should_training_stop": true
+      },
+      "attributes": {}
+    }
+  },
+  "total_flos": 198349894207488.0,
+  "train_batch_size": 16,
+  "trial_name": null,
+  "trial_params": null
+}

results/checkpoint-753/training_args.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d020540fc118248e604cd22f9ec20b7acb4023a8953f7fb309148a6a3c3deb8
+size 5240

st.py

@@ -0,0 +1,45 @@
+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
+
+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()