Seperated knowledge graph and Model responses

app.py

@@ -4,6 +4,9 @@ from pydantic import BaseModel
 from final import predict_news, get_gemini_analysis
 import os
 from tempfile import NamedTemporaryFile
+from knowledge_graph_generator import KnowledgeGraphBuilder
+import networkx as nx
+import plotly.graph_objects as go
 
 app = FastAPI()
 
@@ -81,3 +84,62 @@ async def detect_deepfake(file: UploadFile = File(...)):
             
     except Exception as e:
         return {"error": str(e)}, 500
+
+@app.post("/generate-knowledge-graph")
+async def generate_knowledge_graph(news: NewsInput):
+    kg_builder = KnowledgeGraphBuilder()
+    is_fake = predict_news(news.text) == "FAKE"
+    kg_builder.update_knowledge_graph(news.text, not is_fake)
+    
+    pos = nx.spring_layout(kg_builder.knowledge_graph)
+    
+    # Create edge traces with different colors
+    edge_trace = go.Scatter(
+        x=[], y=[], 
+        line=dict(
+            width=2, 
+            color='rgba(255,0,0,0.7)' if is_fake else 'rgba(0,255,0,0.7)'  # Using rgba for transparency
+        ),
+        hoverinfo='none', 
+        mode='lines'
+    )
+    
+    node_trace = go.Scatter(
+        x=[], y=[], 
+        mode='markers+text',
+        hoverinfo='text', 
+        textposition='top center',
+        marker=dict(
+            size=15, 
+            color='white',
+            line=dict(width=2, color='black')
+        ),
+        text=[]
+    )
+
+    # Add edges to visualization
+    for edge in kg_builder.knowledge_graph.edges():
+        x0, y0 = pos[edge[0]]
+        x1, y1 = pos[edge[1]]
+        edge_trace['x'] += (x0, x1, None)
+        edge_trace['y'] += (y0, y1, None)
+
+    # Add nodes to visualization
+    for node in kg_builder.knowledge_graph.nodes():
+        x, y = pos[node]
+        node_trace['x'] += (x,)
+        node_trace['y'] += (y,)
+        node_trace['text'] += (node,)
+
+    fig = go.Figure(data=[edge_trace, node_trace],
+                   layout=go.Layout(
+                       showlegend=False,
+                       hovermode='closest',
+                       margin=dict(b=0,l=0,r=0,t=0),
+                       xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                       yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                       plot_bgcolor='rgba(0,0,0,0)',
+                       paper_bgcolor='rgba(0,0,0,0)'
+                   ))
+    
+    return fig.to_html()

final.py

@@ -1,9 +1,6 @@
 import torch
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
-import networkx as nx
 import spacy
-import pickle
-import pandas as pd
 import google.generativeai as genai
 import json
 import os
@@ -20,23 +17,10 @@ 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
-#########################
-
-# Load the knowledge graph
-graph_path = "./models/knowledge_graph.pkl"  # Replace with the actual path to your knowledge graph
-with open(graph_path, 'rb') as f:
-    graph_data = pickle.load(f)
-
-knowledge_graph = nx.DiGraph()
-knowledge_graph.add_nodes_from(graph_data['nodes'].items())
-for u, edges in graph_data['edges'].items():
-    for v, data in edges.items():
-        knowledge_graph.add_edge(u, v, **data)
 
 def predict_with_model(text):
     """Predict whether the news is real or fake using the ML model."""
@@ -47,76 +31,17 @@ def predict_with_model(text):
     predicted_label = torch.argmax(probabilities, dim=-1).item()
     return "FAKE" if predicted_label == 1 else "REAL"
 
-def update_knowledge_graph(text, is_real):
-    """Update the knowledge graph with the new article."""
-    entities = extract_entities(text)
-    for entity, entity_type in entities:
-        if not knowledge_graph.has_node(entity):
-            knowledge_graph.add_node(
-                entity,
-                type=entity_type,
-                real_count=1 if is_real else 0,
-                fake_count=0 if is_real else 1
-            )
-        else:
-            if is_real:
-                knowledge_graph.nodes[entity]['real_count'] += 1
-            else:
-                knowledge_graph.nodes[entity]['fake_count'] += 1
-
-    for i, (entity1, _) in enumerate(entities):
-        for entity2, _ in entities[i+1:]:
-            if not knowledge_graph.has_edge(entity1, entity2):
-                knowledge_graph.add_edge(
-                    entity1,
-                    entity2,
-                    weight=1,
-                    is_real=is_real
-                )
-            else:
-                knowledge_graph[entity1][entity2]['weight'] += 1
-
 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_with_knowledge_graph(text):
-    """Predict whether the news is real or fake using the knowledge graph."""
-    entities = extract_entities(text)
-    real_score = 0
-    fake_score = 0
-
-    for entity, _ in entities:
-        if knowledge_graph.has_node(entity):
-            real_count = knowledge_graph.nodes[entity].get('real_count', 0)
-            fake_count = knowledge_graph.nodes[entity].get('fake_count', 0)
-            total = real_count + fake_count
-            if total > 0:
-                real_score += real_count / total
-                fake_score += fake_count / total
-
-    if real_score > fake_score:
-        return "REAL"
-    else:
-        return "FAKE"
-
 def predict_news(text):
-    """Predict whether the news is real or fake using both the ML model and the knowledge graph."""
+    """Predict whether the news is real or fake using the ML model."""
     # Predict with the ML model
-    ml_prediction = predict_with_model(text)
-    is_real = ml_prediction == "REAL"
-
-    # Update the knowledge graph
-    update_knowledge_graph(text, is_real)
-
-    # Predict with the knowledge graph
-    kg_prediction = predict_with_knowledge_graph(text)
-
-    # Combine predictions (for simplicity, we use the ML model's prediction here)
-    # You can enhance this by combining the scores from both predictions
-    return ml_prediction if ml_prediction == kg_prediction else "UNCERTAIN"
+    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:
@@ -164,16 +89,12 @@ def analyze_content_gemini(model, text):
     Analyze this text and return only the JSON response: {text}"""
     
     response = model.generate_content(prompt)
-    # return json.loads(response.text)
-    # Add error handling and response cleaning
     try:
-        # Clean the response text to ensure it's valid JSON
         cleaned_text = response.text.strip()
         if cleaned_text.startswith('```json'):
-            cleaned_text = cleaned_text[7:-3]  # Remove ```json and ``` markers
+            cleaned_text = cleaned_text[7:-3]
         return json.loads(cleaned_text)
     except json.JSONDecodeError:
-        # Return a default structured response if JSON parsing fails
         return {
             "gemini_analysis": {
                 "predicted_classification": "UNCERTAIN",
@@ -182,7 +103,6 @@ def analyze_content_gemini(model, text):
             }
         }
 
-
 def clean_gemini_output(text):
     """Remove markdown formatting from Gemini output"""
     text = text.replace('##', '')
@@ -193,10 +113,7 @@ def get_gemini_analysis(text):
     """Get detailed content analysis from Gemini."""
     gemini_model = setup_gemini()
     gemini_analysis = analyze_content_gemini(gemini_model, text)
-    # cleaned_analysis = clean_gemini_output(gemini_analysis)
-    # return cleaned_analysis
     return gemini_analysis
-#########################
 
 def main():
     print("Welcome to the News Classifier!")
@@ -209,15 +126,14 @@ def main():
             print("Thank you for using the News Classifier!")
             return
             
-        # First get ML and Knowledge Graph prediction
+        # Get ML prediction
         prediction = predict_news(news_text)
-        print(f"\nML and Knowledge Graph Analysis: {prediction}")
+        print(f"\nML Analysis: {prediction}")
         
-        # Then get Gemini analysis
+        # Get Gemini analysis
         print("\n=== Detailed Gemini Analysis ===")
         gemini_result = get_gemini_analysis(news_text)
         print(gemini_result)
 
-
 if __name__ == "__main__":
     main()

nexus-frontend/src/pages/Dashboard.tsx

@@ -110,6 +110,7 @@ const AnimatedBackground = memo(() => {
 });
 
 const Dashboard = () => {
+  const [knowledgeGraphData, setKnowledgeGraphData] = useState(null);
   const [inputText, setInputText] = useState('');
   const [isProcessing, setIsProcessing] = useState(false);
   const [result, setResult] = useState<{
@@ -184,6 +185,24 @@ const Dashboard = () => {
     }
   };
 
+  const generateKnowledgeGraph = async () => {
+    try {
+      const response = await fetch('http://localhost:8000/generate-knowledge-graph', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ text: inputText }),
+      });
+      
+      const data = await response.json();
+      setKnowledgeGraphData(data);
+    } catch (err) {
+      console.error('Knowledge graph generation error:', err);
+    }
+  };
+  
+
   return (
     <div className="min-h-screen relative overflow-hidden">
       <AnimatedBackground />
@@ -203,13 +222,30 @@ const Dashboard = () => {
                 className="w-full h-40 p-4 rounded-xl bg-gray-700 text-white placeholder-gray-400 focus:outline-none"
                 placeholder="Enter text to analyze..."
               />
-              <button
+              {/* <button
                 onClick={processInput}
                 disabled={isProcessing || !inputText.trim()}
                 className="absolute bottom-4 right-4 px-6 py-2 rounded-lg bg-blue-500 hover:bg-blue-600 text-white disabled:opacity-50"
               >
                 Analyze
-              </button>
+              </button> */}
+              <div className="flex gap-2">
+  <button
+    onClick={processInput}
+    disabled={isProcessing || !inputText.trim()}
+    className="px-6 py-2 rounded-lg bg-blue-500 hover:bg-blue-600 text-white disabled:opacity-50"
+  >
+    Analyze
+  </button>
+  <button
+    onClick={generateKnowledgeGraph}
+    disabled={!inputText.trim()}
+    className="px-6 py-2 rounded-lg bg-green-500 hover:bg-green-600 text-white disabled:opacity-50"
+  >
+    Visualize Graph
+  </button>
+</div>
+
             </div>
 
             {isProcessing && (
@@ -293,7 +329,22 @@ const Dashboard = () => {
     </div>
   </div>
 )}
-
+  {knowledgeGraphData && (
+    <div className="mt-4 bg-gray-800 rounded-lg p-4">
+      <h3 className="text-xl font-semibold text-white mb-3">Knowledge Graph</h3>
+      <div className="w-full h-[500px] bg-gray-900 rounded-lg overflow-hidden">
+        <iframe
+          srcDoc={knowledgeGraphData}
+          className="w-full h-full border-0"
+          style={{
+            backgroundColor: 'transparent',
+            width: '100%',
+            height: '100%'
+          }}
+        />
+      </div>
+    </div>
+  )}
 
                 </div>
               </div>