Model upload

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+node_modules/

app.py

@@ -0,0 +1,113 @@
+# # from fastapi import FastAPI
+# # from pydantic import BaseModel
+# # from final import predict_news, get_gemini_analysis
+
+# # app = FastAPI()
+
+# # class NewsInput(BaseModel):
+# #     text: str
+
+# # @app.post("/analyze")
+# # async def analyze_news(news: NewsInput):
+# #     # Get ML and Knowledge Graph prediction
+# #     prediction = predict_news(news.text)
+    
+# #     # Get Gemini analysis
+# #     gemini_analysis = get_gemini_analysis(news.text)
+    
+# #     return {
+# #         "prediction": prediction,
+# #         "detailed_analysis": gemini_analysis
+# #     }
+
+# # @app.get("/health")
+# # async def health_check():
+# #     return {"status": "healthy"}
+
+# from fastapi import FastAPI
+# from fastapi.middleware.cors import CORSMiddleware
+# from pydantic import BaseModel
+# from final import predict_news, get_gemini_analysis
+
+# 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
+#     }
+
+import streamlit as st
+from final import predict_news, get_gemini_analysis
+
+def main():
+    st.title("News Fact Checker")
+    st.write("Enter news text to analyze its authenticity")
+
+    # Text input area
+    news_text = st.text_area("Enter news text here:", height=200)
+
+    if st.button("Analyze"):
+        if news_text:
+            with st.spinner("Analyzing..."):
+                # Get predictions and analysis
+                prediction = predict_news(news_text)
+                gemini_analysis = get_gemini_analysis(news_text)
+
+                # Display results
+                st.header("Analysis Results")
+                
+                # Main prediction with color coding
+                prediction_color = "green" if prediction == "REAL" else "red"
+                st.markdown(f"### Prediction: <span style='color:{prediction_color}'>{prediction}</span>", unsafe_allow_html=True)
+
+                # Detailed Gemini Analysis
+                st.subheader("Detailed Analysis")
+                
+                # Display structured analysis
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.markdown("#### Content Classification")
+                    st.write(f"Category: {gemini_analysis['text_classification']['category']}")
+                    st.write(f"Writing Style: {gemini_analysis['text_classification']['writing_style']}")
+                    st.write(f"Content Type: {gemini_analysis['text_classification']['content_type']}")
+
+                with col2:
+                    st.markdown("#### Sentiment Analysis")
+                    st.write(f"Primary Emotion: {gemini_analysis['sentiment_analysis']['primary_emotion']}")
+                    st.write(f"Emotional Intensity: {gemini_analysis['sentiment_analysis']['emotional_intensity']}/10")
+                    st.write(f"Sensationalism Level: {gemini_analysis['sentiment_analysis']['sensationalism_level']}")
+
+                # Fact checking section
+                st.markdown("#### Fact Checking")
+                st.write(f"Evidence Present: {gemini_analysis['fact_checking']['evidence_present']}")
+                st.write(f"Fact Check Score: {gemini_analysis['fact_checking']['fact_check_score']}/100")
+                
+                # Verifiable claims
+                st.markdown("#### Verifiable Claims")
+                for claim in gemini_analysis['fact_checking']['verifiable_claims']:
+                    st.write(f"- {claim}")
+
+        else:
+            st.warning("Please enter some text to analyze")
+
+if __name__ == "__main__":
+    main()

final.py

@@ -0,0 +1,270 @@
+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
+
+# Load spaCy for NER
+nlp = spacy.load("en_core_web_sm")
+
+# Load the trained ML model
+model_path = "./results/checkpoint-5030"  # 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='AIzaSyAQzWpSyWyYCM1G5f-G0ulRCQkXuY7admA')
+    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."""
+    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 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 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"
+
+#########################
+# def analyze_content_gemini(model, text):
+#     prompt = f"""Analyze this news text and provide results in the following JSON-like format:
+
+#     TEXT: {text}
+
+#     Please provide analysis in these specific sections:
+
+#     1. GEMINI ANALYSIS:
+#        - Predicted Classification: [Real/Fake]
+#        - Confidence Score: [0-100%]
+#        - Reasoning: [Key points for classification]
+
+#     2. TEXT CLASSIFICATION:
+#         - Content category/topic
+#         - Writing style: [Formal/Informal/Clickbait]
+#         - Target audience
+#         - Content type: [news/opinion/editorial]
+
+#     3. SENTIMENT ANALYSIS:
+#        - Primary emotion
+#        - Emotional intensity (1-10)
+#        - Sensationalism Level: [High/Medium/Low]
+#        - Bias Indicators: [List if any]
+#        - Tone: (formal/informal), [Professional/Emotional/Neutral]
+#        - Key emotional triggers
+
+#     4. ENTITY RECOGNITION:
+#         - Source Credibility: [High/Medium/Low]
+#        - People mentioned
+#        - Organizations
+#        - Locations
+#        - Dates/Time references
+#        - Key numbers/statistics
+
+#     5. CONTEXT EXTRACTION:
+#        - Main narrative/story
+#        - Supporting elements
+#        - Key claims
+#        - Narrative structure
+
+#     6. FACT CHECKING:
+#        - Verifiable Claims: [List main claims]
+#        - Evidence Present: [Yes/No]
+#        - Fact Check Score: [0-100%]
+
+#     Format the response clearly with distinct sections."""
+    
+#     response = model.generate_content(prompt)
+#     return response.text
+
+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)
+    # 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
+        return json.loads(cleaned_text)
+    except json.JSONDecodeError:
+        # Return a default structured response if JSON parsing fails
+        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)
+    # cleaned_analysis = clean_gemini_output(gemini_analysis)
+    # return cleaned_analysis
+    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
+            
+        # First get ML and Knowledge Graph prediction
+        prediction = predict_news(news_text)
+        print(f"\nML and Knowledge Graph Analysis: {prediction}")
+        
+        # Then get Gemini analysis
+        print("\n=== Detailed Gemini Analysis ===")
+        gemini_result = get_gemini_analysis(news_text)
+        print(gemini_result)
+
+
+if __name__ == "__main__":
+    main()

knowledge_graph_generator.py

@@ -0,0 +1,170 @@
+import pandas as pd
+import networkx as nx
+import spacy
+import pickle
+from datetime import datetime
+import os
+
+# Load spaCy for NER
+nlp = spacy.load("en_core_web_sm")
+
+class KnowledgeGraphBuilder:
+    def __init__(self, model_dir="models"):
+        self.model_dir = model_dir
+        self.knowledge_graph = nx.DiGraph()
+    
+    def extract_entities(self, text):
+        """Extract named entities from text using spaCy"""
+        try:
+            # Convert to string and handle NaN/None values
+            if pd.isna(text) or text is None:
+                return []
+            
+            # Convert float or int to string if necessary
+            if isinstance(text, (float, int)):
+                text = str(text)
+            
+            # Ensure text is a string
+            text = str(text).strip()
+            
+            # Skip empty strings
+            if not text:
+                return []
+                
+            doc = nlp(text)
+            entities = [(ent.text, ent.label_) for ent in doc.ents]
+            return entities
+        except Exception as e:
+            print(f"Error processing text: {text}")
+            print(f"Error message: {str(e)}")
+            return []
+
+    def update_knowledge_graph(self, text, is_real):
+        """Update knowledge graph with entities and their relationships"""
+        try:
+            entities = self.extract_entities(text)
+            
+            # Skip if no entities were found
+            if not entities:
+                return
+            
+            # Add nodes and edges to the graph
+            for entity, entity_type in entities:
+                # Add node if it doesn't exist
+                if not self.knowledge_graph.has_node(entity):
+                    self.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:
+                    # Update counts
+                    if is_real:
+                        self.knowledge_graph.nodes[entity]['real_count'] += 1
+                    else:
+                        self.knowledge_graph.nodes[entity]['fake_count'] += 1
+            
+            # Add edges between entities in the same text
+            for i, (entity1, _) in enumerate(entities):
+                for entity2, _ in entities[i+1:]:
+                    if not self.knowledge_graph.has_edge(entity1, entity2):
+                        self.knowledge_graph.add_edge(
+                            entity1,
+                            entity2,
+                            weight=1,
+                            is_real=is_real
+                        )
+                    else:
+                        self.knowledge_graph[entity1][entity2]['weight'] += 1
+        except Exception as e:
+            print(f"Error updating knowledge graph: {str(e)}")
+
+    def save_knowledge_graph(self, filename=None):
+        """Save the knowledge graph to a file"""
+        if filename is None:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = os.path.join(self.model_dir, f"knowledge_graph_{timestamp}.pkl")
+        
+        os.makedirs(self.model_dir, exist_ok=True)
+        
+        # Convert the graph to a dictionary format for better serialization
+        graph_data = {
+            'nodes': dict(self.knowledge_graph.nodes(data=True)),
+            'edges': {}
+        }
+        
+        # Properly format edges with their data
+        for u, v, data in self.knowledge_graph.edges(data=True):
+            if u not in graph_data['edges']:
+                graph_data['edges'][u] = {}
+            graph_data['edges'][u][v] = data
+        
+        try:
+            with open(filename, 'wb') as f:
+                pickle.dump(graph_data, f)
+            print(f"Knowledge graph saved to {filename}")
+            print(f"Total nodes: {len(graph_data['nodes'])}")
+            print(f"Total edges: {sum(len(edges) for edges in graph_data['edges'].values())}")
+            return filename
+        except Exception as e:
+            print(f"Error saving knowledge graph: {str(e)}")
+            return None
+    
+    def get_graph_statistics(self):
+        """Get basic statistics about the knowledge graph"""
+        stats = {
+            'total_nodes': self.knowledge_graph.number_of_nodes(),
+            'total_edges': self.knowledge_graph.number_of_edges(),
+            'entity_types': {},
+            'reliability_scores': {}
+        }
+        
+        # Count entity types
+        for node, attrs in self.knowledge_graph.nodes(data=True):
+            entity_type = attrs.get('type', 'UNKNOWN')
+            stats['entity_types'][entity_type] = stats['entity_types'].get(entity_type, 0) + 1
+            
+            # Calculate reliability score
+            real_count = attrs.get('real_count', 0)
+            fake_count = attrs.get('fake_count', 0)
+            total = real_count + fake_count
+            if total > 0:
+                reliability = real_count / total
+                stats['reliability_scores'][node] = reliability
+        
+        return stats
+
+def main():
+    # Initialize the knowledge graph builder
+    builder = KnowledgeGraphBuilder()
+    
+    # Load your dataset
+    df = pd.read_csv('./combined.csv')  # Replace with your actual data file
+    
+    # Create knowledge graph
+    print("Building knowledge graph...")
+    total_rows = len(df)
+    for idx, row in df.iterrows():
+        try:
+            builder.update_knowledge_graph(row['text'], row['label'] == 'REAL')
+            if (idx + 1) % 100 == 0:
+                print(f"Processed {idx + 1}/{total_rows} entries ({(idx + 1)/total_rows*100:.1f}%)...")
+        except Exception as e:
+            print(f"Error processing row {idx}: {str(e)}")
+            continue
+    
+    # Save the knowledge graph
+    graph_path = builder.save_knowledge_graph()
+    
+    # Print statistics
+    stats = builder.get_graph_statistics()
+    print("\nKnowledge Graph Statistics:")
+    print(f"Total nodes: {stats['total_nodes']}")
+    print(f"Total edges: {stats['total_edges']}")
+    print("\nEntity types distribution:")
+    for entity_type, count in stats['entity_types'].items():
+        print(f"{entity_type}: {count}")
+
+if __name__ == "__main__":
+    main()

models/knowledge_graph.pkl

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

nlp_trainer.py

@@ -0,0 +1,130 @@
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from transformers import Trainer, TrainingArguments
+from torch.utils.data import Dataset
+import torch
+import re
+import string
+import logging
+logging.basicConfig(level=logging.INFO)
+
+def load_dataset(path="./combined.csv"):
+    df = pd.read_csv(path, dtype={'text': str, 'label': str})  # Explicitly set dtypes
+    df = df.dropna()  # Remove any null values
+    
+    # Ensure consistent column names
+    if 'news' in df.columns:
+        df = df.rename(columns={"news": "text"})
+    if 'target' in df.columns:
+        df = df.rename(columns={"target": "label"})
+    
+    # Convert labels to integers safely
+    label_map = {"real": 0, "fake": 1}
+    df['label'] = df['label'].str.lower().map(label_map)
+    
+    # Drop any rows where label mapping failed
+    df = df.dropna(subset=['label'])
+    df['label'] = df['label'].astype(int)
+    
+    X = df['text'].apply(str).tolist()  # Ensure text is string
+    y = df['label'].tolist()
+    
+    return train_test_split(X, y, test_size=0.2, random_state=42)
+
+class NewsDataset(Dataset):
+    def __init__(self, texts, labels, tokenizer, max_len):
+        self.texts = texts
+        self.labels = labels
+        self.tokenizer = tokenizer
+        self.max_len = max_len
+
+    def __len__(self):
+        return len(self.texts)
+
+    def __getitem__(self, idx):
+        text = str(self.texts[idx])
+        encoding = self.tokenizer(
+            text,
+            max_length=self.max_len,
+            padding='max_length',
+            truncation=True,
+            return_tensors="pt"
+        )
+        return {
+            'input_ids': encoding['input_ids'].squeeze(0),
+            'attention_mask': encoding['attention_mask'].squeeze(0),
+            'labels': torch.tensor(int(self.labels[idx]), dtype=torch.long)
+        }
+
+def train_model(train_texts, train_labels, val_texts, val_labels):
+    tokenizer = AutoTokenizer.from_pretrained('microsoft/deberta-v3-small')
+    model = AutoModelForSequenceClassification.from_pretrained('microsoft/deberta-v3-small', num_labels=2)
+
+    train_dataset = NewsDataset(train_texts, train_labels, tokenizer, max_len=128)
+    val_dataset = NewsDataset(val_texts, val_labels, tokenizer, max_len=128)
+
+    training_args = TrainingArguments(
+        output_dir='./results',
+        num_train_epochs=5,
+        per_device_train_batch_size=8,
+        per_device_eval_batch_size=8,
+        warmup_steps=500,
+        weight_decay=0.01,
+        logging_dir='./logs',
+        evaluation_strategy="epoch",
+        save_strategy="epoch"
+    )
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=val_dataset
+    )
+
+    trainer.train()
+    return tokenizer, model
+
+def predict_news(tokenizer, model, news_text):
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model.to(device)
+    print(device)
+    model.eval()
+
+    encoding = tokenizer(
+        str(news_text),
+        max_length=128,
+        padding='max_length',
+        truncation=True,
+        return_tensors="pt"
+    )
+    
+    input_ids = encoding['input_ids'].to(device)
+    attention_mask = encoding['attention_mask'].to(device)
+
+    with torch.no_grad():
+        outputs = model(input_ids=input_ids, attention_mask=attention_mask)
+        prediction = torch.argmax(outputs.logits, dim=1).item()
+
+    return "Fake" if prediction == 1 else "Real"
+
+def main():
+    try:
+        X_train, X_test, y_train, y_test = load_dataset()
+        tokenizer, model = train_model(X_train, y_train, X_test, y_test)
+
+        while True:
+            user_input = input("\nEnter news text (or 'exit' to quit): ")
+            if user_input.lower() == 'exit':
+                break
+            result = predict_news(tokenizer, model, user_input)
+            print(f"The news is: {result}")
+
+    except Exception as e:
+        logging.error(f"An error occurred: {str(e)}")
+        raise
+
+if __name__ == "__main__":
+    main()

package-lock.json

@@ -0,0 +1,111 @@
+{
+  "name": "complete_nlp_stuff",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "axios": "^1.7.9"
+      }
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
+    "node_modules/axios": {
+      "version": "1.7.9",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.9.tgz",
+      "integrity": "sha512-LhLcE7Hbiryz8oMDdDptSrWowmB4Bl6RCt6sIJKpRB4XtVf0iEgewX3au/pJqm+Py1kCASkb/FFKjxQaLtxJvw==",
+      "license": "MIT",
+      "dependencies": {
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.0",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.9",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
+      "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.1.tgz",
+      "integrity": "sha512-tzN8e4TX8+kkxGPK8D5u0FNmjPUjw3lwC9lSLxxoB/+GtsJG91CO8bSWy73APlgAZzZbXEYZJuxjkHH2w+Ezhw==",
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    }
+  }
+}

package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "axios": "^1.7.9"
+  }
+}

results/checkpoint-5030/config.json

@@ -0,0 +1,35 @@
+{
+  "_name_or_path": "microsoft/deberta-v3-small",
+  "architectures": [
+    "DebertaV2ForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "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": 12,
+  "num_hidden_layers": 6,
+  "pad_token_id": 0,
+  "pooler_dropout": 0,
+  "pooler_hidden_act": "gelu",
+  "pooler_hidden_size": 768,
+  "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-5030/model.safetensors

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

results/checkpoint-5030/optimizer.pt

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

results/checkpoint-5030/rng_state.pth

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

results/checkpoint-5030/scheduler.pt

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

results/checkpoint-5030/trainer_state.json

@@ -0,0 +1,143 @@
+{
+  "best_metric": null,
+  "best_model_checkpoint": null,
+  "epoch": 5.0,
+  "eval_steps": 500,
+  "global_step": 5030,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 0.4970178926441352,
+      "grad_norm": 11.328213691711426,
+      "learning_rate": 5e-05,
+      "loss": 0.3471,
+      "step": 500
+    },
+    {
+      "epoch": 0.9940357852882704,
+      "grad_norm": 0.29149460792541504,
+      "learning_rate": 4.448123620309051e-05,
+      "loss": 0.1462,
+      "step": 1000
+    },
+    {
+      "epoch": 1.0,
+      "eval_loss": 0.14880910515785217,
+      "eval_runtime": 32.5193,
+      "eval_samples_per_second": 61.871,
+      "eval_steps_per_second": 7.749,
+      "step": 1006
+    },
+    {
+      "epoch": 1.4910536779324055,
+      "grad_norm": 0.04432953894138336,
+      "learning_rate": 3.896247240618102e-05,
+      "loss": 0.0738,
+      "step": 1500
+    },
+    {
+      "epoch": 1.9880715705765408,
+      "grad_norm": 0.004722778219729662,
+      "learning_rate": 3.3443708609271526e-05,
+      "loss": 0.0599,
+      "step": 2000
+    },
+    {
+      "epoch": 2.0,
+      "eval_loss": 0.17704755067825317,
+      "eval_runtime": 32.4526,
+      "eval_samples_per_second": 61.998,
+      "eval_steps_per_second": 7.765,
+      "step": 2012
+    },
+    {
+      "epoch": 2.485089463220676,
+      "grad_norm": 0.0014285552315413952,
+      "learning_rate": 2.792494481236203e-05,
+      "loss": 0.0176,
+      "step": 2500
+    },
+    {
+      "epoch": 2.982107355864811,
+      "grad_norm": 0.0008603875176049769,
+      "learning_rate": 2.240618101545254e-05,
+      "loss": 0.026,
+      "step": 3000
+    },
+    {
+      "epoch": 3.0,
+      "eval_loss": 0.16322186589241028,
+      "eval_runtime": 32.2403,
+      "eval_samples_per_second": 62.406,
+      "eval_steps_per_second": 7.816,
+      "step": 3018
+    },
+    {
+      "epoch": 3.4791252485089466,
+      "grad_norm": 0.000587798363994807,
+      "learning_rate": 1.688741721854305e-05,
+      "loss": 0.0042,
+      "step": 3500
+    },
+    {
+      "epoch": 3.9761431411530817,
+      "grad_norm": 0.00033068188349716365,
+      "learning_rate": 1.1368653421633555e-05,
+      "loss": 0.0012,
+      "step": 4000
+    },
+    {
+      "epoch": 4.0,
+      "eval_loss": 0.20389850437641144,
+      "eval_runtime": 33.2829,
+      "eval_samples_per_second": 60.452,
+      "eval_steps_per_second": 7.571,
+      "step": 4024
+    },
+    {
+      "epoch": 4.473161033797217,
+      "grad_norm": 0.0048806252889335155,
+      "learning_rate": 5.8498896247240626e-06,
+      "loss": 0.0013,
+      "step": 4500
+    },
+    {
+      "epoch": 4.970178926441352,
+      "grad_norm": 0.00042022508569061756,
+      "learning_rate": 3.3112582781456954e-07,
+      "loss": 0.0006,
+      "step": 5000
+    },
+    {
+      "epoch": 5.0,
+      "eval_loss": 0.19458653032779694,
+      "eval_runtime": 33.1006,
+      "eval_samples_per_second": 60.784,
+      "eval_steps_per_second": 7.613,
+      "step": 5030
+    }
+  ],
+  "logging_steps": 500,
+  "max_steps": 5030,
+  "num_input_tokens_seen": 0,
+  "num_train_epochs": 5,
+  "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": 1332007138928640.0,
+  "train_batch_size": 8,
+  "trial_name": null,
+  "trial_params": null
+}

results/checkpoint-5030/training_args.bin

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