Initial commit for Hugging Face Space

app.py

@@ -0,0 +1,22 @@
+import sys
+from pathlib import Path
+
+import os
+import gdown
+
+MODEL_PATH = "models/saved/final_model.pt"
+GOOGLE_DRIVE_URL = "https://drive.google.com/drive/folders/1VEFa0y_vW6AzT5x0fRwmX8shoBhUGd7K"  # Replace with your file's ID
+
+if not os.path.exists(MODEL_PATH):
+    os.makedirs(os.path.dirname(MODEL_PATH), exist_ok=True)
+    gdown.download(GOOGLE_DRIVE_URL, MODEL_PATH, quiet=False)
+
+# Add src directory to Python path
+src_path = Path(__file__).parent / "src"
+sys.path.append(str(src_path))
+
+# Import and run the main app
+from src.app import main
+
+if __name__ == "__main__":
+    main() 

requirements.txt

@@ -0,0 +1,21 @@
+numpy==1.24.4
+pandas
+scikit-learn
+transformers
+nltk
+spacy
+matplotlib
+seaborn
+tqdm
+emoji
+textblob
+gensim
+pytest
+jupyter
+gdown
+requests
+kaggle
+streamlit
+plotly 
+scipy==1.11.4
+torch==2.4.1

src/app.py

@@ -0,0 +1,246 @@
+import streamlit as st
+import torch
+import pandas as pd
+import numpy as np
+from pathlib import Path
+import sys
+import plotly.express as px
+import plotly.graph_objects as go
+from transformers import BertTokenizer
+import nltk
+
+# Download required NLTK data
+try:
+    nltk.data.find('tokenizers/punkt')
+except LookupError:
+    nltk.download('punkt')
+try:
+    nltk.data.find('corpora/stopwords')
+except LookupError:
+    nltk.download('stopwords')
+try:
+    nltk.data.find('tokenizers/punkt_tab')
+except LookupError:
+    nltk.download('punkt_tab')
+try:
+    nltk.data.find('corpora/wordnet')
+except LookupError:
+    nltk.download('wordnet')
+
+# Add project root to Python path
+project_root = Path(__file__).parent.parent
+sys.path.append(str(project_root))
+
+from src.models.hybrid_model import HybridFakeNewsDetector
+from src.config.config import *
+from src.data.preprocessor import TextPreprocessor
+
+# Set page config
+st.set_page_config(
+    page_title="Fake News Detection",
+    page_icon="📰",
+    layout="wide"
+)
+
+@st.cache_resource
+def load_model_and_tokenizer():
+    """Load the model and tokenizer (cached)."""
+    # Initialize model
+    model = HybridFakeNewsDetector(
+        bert_model_name=BERT_MODEL_NAME,
+        lstm_hidden_size=LSTM_HIDDEN_SIZE,
+        lstm_num_layers=LSTM_NUM_LAYERS,
+        dropout_rate=DROPOUT_RATE
+    )
+    
+    # Load trained weights
+    state_dict = torch.load(SAVED_MODELS_DIR / "final_model.pt", map_location=torch.device('cpu'))
+    
+    # Filter out unexpected keys
+    model_state_dict = model.state_dict()
+    filtered_state_dict = {k: v for k, v in state_dict.items() if k in model_state_dict}
+    
+    # Load the filtered state dict
+    model.load_state_dict(filtered_state_dict, strict=False)
+    model.eval()
+    
+    # Initialize tokenizer
+    tokenizer = BertTokenizer.from_pretrained(BERT_MODEL_NAME)
+    
+    return model, tokenizer
+
+@st.cache_resource
+def get_preprocessor():
+    """Get the text preprocessor (cached)."""
+    return TextPreprocessor()
+
+def predict_news(text):
+    """Predict if the given news is fake or real."""
+    # Get model, tokenizer, and preprocessor from cache
+    model, tokenizer = load_model_and_tokenizer()
+    preprocessor = get_preprocessor()
+    
+    # Preprocess text
+    processed_text = preprocessor.preprocess_text(text)
+    
+    # Tokenize
+    encoding = tokenizer.encode_plus(
+        processed_text,
+        add_special_tokens=True,
+        max_length=MAX_SEQUENCE_LENGTH,
+        padding='max_length',
+        truncation=True,
+        return_attention_mask=True,
+        return_tensors='pt'
+    )
+    
+    # Get prediction
+    with torch.no_grad():
+        outputs = model(
+            encoding['input_ids'],
+            encoding['attention_mask']
+        )
+        probabilities = torch.softmax(outputs['logits'], dim=1)
+        prediction = torch.argmax(outputs['logits'], dim=1)
+        attention_weights = outputs['attention_weights']
+    
+    # Convert attention weights to numpy and get the first sequence
+    attention_weights_np = attention_weights[0].cpu().numpy()
+    
+    return {
+        'prediction': prediction.item(),
+        'label': 'FAKE' if prediction.item() == 1 else 'REAL',
+        'confidence': torch.max(probabilities, dim=1)[0].item(),
+        'probabilities': {
+            'REAL': probabilities[0][0].item(),
+            'FAKE': probabilities[0][1].item()
+        },
+        'attention_weights': attention_weights_np
+    }
+
+def plot_confidence(probabilities):
+    """Plot prediction confidence."""
+    fig = go.Figure(data=[
+        go.Bar(
+            x=list(probabilities.keys()),
+            y=list(probabilities.values()),
+            text=[f'{p:.2%}' for p in probabilities.values()],
+            textposition='auto',
+        )
+    ])
+    
+    fig.update_layout(
+        title='Prediction Confidence',
+        xaxis_title='Class',
+        yaxis_title='Probability',
+        yaxis_range=[0, 1]
+    )
+    
+    return fig
+
+def plot_attention(text, attention_weights):
+    """Plot attention weights."""
+    tokens = text.split()
+    attention_weights = attention_weights[:len(tokens)]  # Truncate to match tokens
+    
+    # Ensure attention weights are in the correct format
+    if isinstance(attention_weights, (list, np.ndarray)):
+        attention_weights = np.array(attention_weights).flatten()
+    
+    # Format weights for display
+    formatted_weights = [f'{float(w):.2f}' for w in attention_weights]
+    
+    fig = go.Figure(data=[
+        go.Bar(
+            x=tokens,
+            y=attention_weights,
+            text=formatted_weights,
+            textposition='auto',
+        )
+    ])
+    
+    fig.update_layout(
+        title='Attention Weights',
+        xaxis_title='Tokens',
+        yaxis_title='Attention Weight',
+        xaxis_tickangle=45
+    )
+    
+    return fig
+
+def main():
+    st.title("📰 Fake News Detection System")
+    st.write("""
+    This application uses a hybrid deep learning model (BERT + BiLSTM + Attention) 
+    to detect fake news articles. Enter a news article below to analyze it.
+    """)
+    
+    # Sidebar
+    st.sidebar.title("About")
+    st.sidebar.info("""
+    
+    The model combines:
+    - BERT for contextual embeddings
+    - BiLSTM for sequence modeling
+    - Attention mechanism for interpretability
+    """)
+    
+    # Main content
+    st.header("News Analysis")
+    
+    # Text input
+    news_text = st.text_area(
+        "Enter the news article to analyze:",
+        height=200,
+        placeholder="Paste your news article here..."
+    )
+    
+    if st.button("Analyze"):
+        if news_text:
+            with st.spinner("Analyzing the news article..."):
+                # Get prediction
+                result = predict_news(news_text)
+                
+                # Display result
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.subheader("Prediction")
+                    if result['label'] == 'FAKE':
+                        st.error(f"🔴 This news is likely FAKE (Confidence: {result['confidence']:.2%})")
+                    else:
+                        st.success(f"🟢 This news is likely REAL (Confidence: {result['confidence']:.2%})")
+                
+                with col2:
+                    st.subheader("Confidence Scores")
+                    st.plotly_chart(plot_confidence(result['probabilities']), use_container_width=True)
+                
+                # Show attention visualization
+                st.subheader("Attention Analysis")
+                st.write("""
+                The attention weights show which parts of the text the model focused on 
+                while making its prediction. Higher weights indicate more important tokens.
+                """)
+                st.plotly_chart(plot_attention(news_text, result['attention_weights']), use_container_width=True)
+                
+                # Show model explanation
+                st.subheader("Model Explanation")
+                if result['label'] == 'FAKE':
+                    st.write("""
+                    The model identified this as fake news based on:
+                    - Linguistic patterns typical of fake news
+                    - Inconsistencies in the content
+                    - Attention weights on suspicious phrases
+                    """)
+                else:
+                    st.write("""
+                    The model identified this as real news based on:
+                    - Credible language patterns
+                    - Consistent information
+                    - Attention weights on factual statements
+                    """)
+        else:
+            st.warning("Please enter a news article to analyze.")
+
+if __name__ == "__main__":
+    main() 

src/config/config.py

@@ -0,0 +1,44 @@
+from pathlib import Path
+import torch
+
+# Project paths
+PROJECT_ROOT = Path(__file__).parent.parent.parent
+DATA_DIR = PROJECT_ROOT / "data"
+RAW_DATA_DIR = DATA_DIR / "raw"
+PROCESSED_DATA_DIR = DATA_DIR / "processed"
+MODEL_DIR = PROJECT_ROOT / "models"
+SAVED_MODELS_DIR = MODEL_DIR / "saved"
+CHECKPOINTS_DIR = MODEL_DIR / "checkpoints"
+
+# Data parameters
+MAX_SEQUENCE_LENGTH = 256
+VOCAB_SIZE = 15000
+EMBEDDING_DIM = 128
+BATCH_SIZE = 8
+TEST_SIZE = 0.2
+VAL_SIZE = 0.1
+RANDOM_STATE = 42
+MAX_SAMPLES = 10000
+
+# Model parameters
+BERT_MODEL_NAME = "bert-base-uncased"
+LSTM_HIDDEN_SIZE = 128
+LSTM_NUM_LAYERS = 1
+DROPOUT_RATE = 0.3
+LEARNING_RATE = 2e-5
+NUM_EPOCHS = 3
+EARLY_STOPPING_PATIENCE = 2
+
+# Training parameters
+
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+NUM_WORKERS = 0
+PIN_MEMORY = False
+
+# Feature extraction
+USE_TFIDF = True
+USE_BERT = True
+USE_LSTM = True
+
+# Evaluation metrics
+METRICS = ["accuracy", "precision", "recall", "f1"] 

src/data/dataset.py

@@ -0,0 +1,108 @@
+import torch
+from torch.utils.data import Dataset
+from transformers import BertTokenizer
+from typing import Dict, List, Union
+import pandas as pd
+import numpy as np
+
+class FakeNewsDataset(Dataset):
+    def __init__(self,
+                 texts: List[str],
+                 labels: List[int],
+                 tokenizer: BertTokenizer,
+                 max_length: int = 512):
+        self.texts = texts
+        self.labels = labels
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+        
+    def __len__(self) -> int:
+        return len(self.texts)
+    
+    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:
+        text = str(self.texts[idx])
+        label = self.labels[idx]
+        
+        encoding = self.tokenizer(
+            text,
+            add_special_tokens=True,
+            max_length=self.max_length,
+            padding='max_length',
+            truncation=True,
+            return_attention_mask=True,
+            return_tensors='pt'
+        )
+        
+        return {
+            'input_ids': encoding['input_ids'].flatten(),
+            'attention_mask': encoding['attention_mask'].flatten(),
+            'labels': torch.tensor(label, dtype=torch.long)
+        }
+
+def create_data_loaders(
+    df: pd.DataFrame,
+    text_column: str,
+    label_column: str,
+    tokenizer: BertTokenizer,
+    batch_size: int = 32,
+    max_length: int = 512,
+    train_size: float = 0.8,
+    val_size: float = 0.1,
+    random_state: int = 42
+) -> Dict[str, torch.utils.data.DataLoader]:
+    """Create train, validation, and test data loaders."""
+    # Split data
+    train_df = df.sample(frac=train_size, random_state=random_state)
+    remaining_df = df.drop(train_df.index)
+    val_df = remaining_df.sample(frac=val_size/(1-train_size), random_state=random_state)
+    test_df = remaining_df.drop(val_df.index)
+    
+    # Create datasets
+    train_dataset = FakeNewsDataset(
+        texts=train_df[text_column].tolist(),
+        labels=train_df[label_column].tolist(),
+        tokenizer=tokenizer,
+        max_length=max_length
+    )
+    
+    val_dataset = FakeNewsDataset(
+        texts=val_df[text_column].tolist(),
+        labels=val_df[label_column].tolist(),
+        tokenizer=tokenizer,
+        max_length=max_length
+    )
+    
+    test_dataset = FakeNewsDataset(
+        texts=test_df[text_column].tolist(),
+        labels=test_df[label_column].tolist(),
+        tokenizer=tokenizer,
+        max_length=max_length
+    )
+    
+    # Create data loaders
+    train_loader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=batch_size,
+        shuffle=True,
+        num_workers=4
+    )
+    
+    val_loader = torch.utils.data.DataLoader(
+        val_dataset,
+        batch_size=batch_size,
+        shuffle=False,
+        num_workers=4
+    )
+    
+    test_loader = torch.utils.data.DataLoader(
+        test_dataset,
+        batch_size=batch_size,
+        shuffle=False,
+        num_workers=4
+    )
+    
+    return {
+        'train': train_loader,
+        'val': val_loader,
+        'test': test_loader
+    } 

src/data/download_datasets.py

@@ -0,0 +1,115 @@
+import os
+import pandas as pd
+import requests
+import zipfile
+from pathlib import Path
+import logging
+from tqdm import tqdm
+import json
+# import kaggle
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class DatasetDownloader:
+    def __init__(self):
+        self.project_root = Path(__file__).parent.parent.parent
+        self.raw_data_dir = self.project_root / "data" / "raw"
+        self.processed_data_dir = self.project_root / "data" / "processed"
+        
+        # Create directories if they don't exist
+        os.makedirs(self.raw_data_dir, exist_ok=True)
+        os.makedirs(self.processed_data_dir, exist_ok=True)
+    
+
+    def process_kaggle_dataset(self):
+        """Process the Kaggle dataset."""
+        logger.info("Processing Kaggle dataset...")
+        
+        # Read fake and real news files
+        fake_df = pd.read_csv(self.raw_data_dir / "Fake.csv")
+        true_df = pd.read_csv(self.raw_data_dir / "True.csv")
+        
+        # Add labels
+        fake_df['label'] = 1  # 1 for fake
+        true_df['label'] = 0  # 0 for real
+        
+        # Combine datasets
+        combined_df = pd.concat([fake_df, true_df], ignore_index=True)
+        
+        # Save processed data
+        combined_df.to_csv(self.processed_data_dir / "kaggle_processed.csv", index=False)
+        logger.info(f"Saved {len(combined_df)} articles from Kaggle dataset")
+    
+    def process_liar(self):
+        """Process LIAR dataset."""
+        logger.info("Processing LIAR dataset...")
+        
+        # Read LIAR dataset
+        liar_file = self.raw_data_dir / "liar" / "train.tsv"
+        if not liar_file.exists():
+            logger.error("LIAR dataset not found!")
+            return
+        
+        # Read TSV file
+        df = pd.read_csv(liar_file, sep='\t', header=None)
+        
+        # Rename columns
+        df.columns = [
+            'id', 'label', 'statement', 'subject', 'speaker',
+            'job_title', 'state_info', 'party_affiliation',
+            'barely_true', 'false', 'half_true', 'mostly_true',
+            'pants_on_fire', 'venue'
+        ]
+        
+        # Convert labels to binary (0 for true, 1 for false)
+        label_map = {
+            'true': 0,
+            'mostly-true': 0,
+            'half-true': 0,
+            'barely-true': 1,
+            'false': 1,
+            'pants-fire': 1
+        }
+        df['label'] = df['label'].map(label_map)
+        
+        # Select relevant columns
+        df = df[['statement', 'label', 'subject', 'speaker', 'party_affiliation']]
+        df.columns = ['text', 'label', 'subject', 'speaker', 'party']
+        
+        # Save processed data
+        df.to_csv(self.processed_data_dir / "liar_processed.csv", index=False)
+        logger.info(f"Saved {len(df)} articles from LIAR dataset")
+    
+    def combine_datasets(self):
+        """Combine processed datasets."""
+        logger.info("Combining datasets...")
+        
+        # Read processed datasets
+        kaggle_df = pd.read_csv(self.processed_data_dir / "kaggle_processed.csv")
+        liar_df = pd.read_csv(self.processed_data_dir / "liar_processed.csv")
+        
+        # Combine datasets
+        combined_df = pd.concat([
+            kaggle_df[['text', 'label']],
+            liar_df[['text', 'label']]
+        ], ignore_index=True)
+        
+        # Save combined dataset
+        combined_df.to_csv(self.processed_data_dir / "combined_dataset.csv", index=False)
+        logger.info(f"Combined dataset contains {len(combined_df)} articles")
+
+def main():
+    downloader = DatasetDownloader()
+    
+    # Process datasets
+    downloader.process_kaggle_dataset()
+    downloader.process_liar()
+    
+    # Combine datasets
+    downloader.combine_datasets()
+    
+    logger.info("Dataset preparation completed!")
+
+if __name__ == "__main__":
+    main() 

src/data/feature_extractor.py

@@ -0,0 +1,82 @@
+import numpy as np
+import torch
+from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
+from transformers import BertTokenizer, BertModel
+from typing import Tuple, Dict, List
+import pandas as pd
+from tqdm import tqdm
+
+class FeatureExtractor:
+    def __init__(self, bert_model_name: str = "bert-base-uncased"):
+        self.bert_tokenizer = BertTokenizer.from_pretrained(bert_model_name)
+        self.bert_model = BertModel.from_pretrained(bert_model_name)
+        self.tfidf_vectorizer = TfidfVectorizer(
+            max_features=5000,
+            ngram_range=(1, 2),
+            stop_words='english'
+        )
+        self.count_vectorizer = CountVectorizer(
+            max_features=5000,
+            ngram_range=(1, 2),
+            stop_words='english'
+        )
+        
+    def get_bert_embeddings(self, texts: List[str], 
+                          batch_size: int = 32,
+                          max_length: int = 512) -> np.ndarray:
+        """Extract BERT embeddings for a list of texts."""
+        self.bert_model.eval()
+        embeddings = []
+        
+        with torch.no_grad():
+            for i in tqdm(range(0, len(texts), batch_size)):
+                batch_texts = texts[i:i + batch_size]
+                
+                # Tokenize and prepare input
+                encoded = self.bert_tokenizer(
+                    batch_texts,
+                    padding=True,
+                    truncation=True,
+                    max_length=max_length,
+                    return_tensors='pt'
+                )
+                
+                # Get BERT embeddings
+                outputs = self.bert_model(**encoded)
+                # Use [CLS] token embeddings as sentence representation
+                batch_embeddings = outputs.last_hidden_state[:, 0, :].numpy()
+                embeddings.append(batch_embeddings)
+                
+        return np.vstack(embeddings)
+    
+    def get_tfidf_features(self, texts: List[str]) -> np.ndarray:
+        """Extract TF-IDF features from texts."""
+        return self.tfidf_vectorizer.fit_transform(texts).toarray()
+    
+    def get_count_features(self, texts: List[str]) -> np.ndarray:
+        """Extract Count Vectorizer features from texts."""
+        return self.count_vectorizer.fit_transform(texts).toarray()
+    
+    def extract_all_features(self, texts: List[str],
+                           use_bert: bool = True,
+                           use_tfidf: bool = True,
+                           use_count: bool = True) -> Dict[str, np.ndarray]:
+        """Extract all features from texts."""
+        features = {}
+        
+        if use_bert:
+            features['bert'] = self.get_bert_embeddings(texts)
+        if use_tfidf:
+            features['tfidf'] = self.get_tfidf_features(texts)
+        if use_count:
+            features['count'] = self.get_count_features(texts)
+            
+        return features
+    
+    def extract_features_from_dataframe(self, 
+                                      df: pd.DataFrame,
+                                      text_column: str,
+                                      **kwargs) -> Dict[str, np.ndarray]:
+        """Extract features from a dataframe's text column."""
+        texts = df[text_column].tolist()
+        return self.extract_all_features(texts, **kwargs) 

src/data/preprocessor.py

@@ -0,0 +1,91 @@
+import re
+import emoji
+import nltk
+from nltk.tokenize import word_tokenize
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+from textblob import TextBlob
+from typing import List, Union
+import pandas as pd
+
+class TextPreprocessor:
+    def __init__(self):
+        # Download required NLTK data
+        nltk.download('punkt')
+        nltk.download('stopwords')
+        nltk.download('wordnet')
+        
+        self.stop_words = set(stopwords.words('english'))
+        self.lemmatizer = WordNetLemmatizer()
+        
+    def remove_urls(self, text: str) -> str:
+        """Remove URLs from text."""
+        url_pattern = re.compile(r'https?://\S+|www\.\S+')
+        return url_pattern.sub('', text)
+    
+    def remove_emojis(self, text: str) -> str:
+        """Remove emojis from text."""
+        return emoji.replace_emoji(text, replace='')
+    
+    def remove_special_chars(self, text: str) -> str:
+        """Remove special characters and numbers."""
+        return re.sub(r'[^a-zA-Z\s]', '', text)
+    
+    def remove_extra_spaces(self, text: str) -> str:
+        """Remove extra spaces."""
+        return re.sub(r'\s+', ' ', text).strip()
+    
+    def lemmatize_text(self, text: str) -> str:
+        """Lemmatize text."""
+        # Simple word tokenization using split
+        tokens = text.split()
+        return ' '.join([self.lemmatizer.lemmatize(token) for token in tokens])
+    
+    def remove_stopwords(self, text: str) -> str:
+        """Remove stopwords from text."""
+        # Simple word tokenization using split
+        tokens = text.split()
+        return ' '.join([token for token in tokens if token.lower() not in self.stop_words])
+    
+    def correct_spelling(self, text: str) -> str:
+        """Correct spelling in text."""
+        return str(TextBlob(text).correct())
+    
+    def preprocess_text(self, text: str, 
+                       remove_urls: bool = True,
+                       remove_emojis: bool = True,
+                       remove_special_chars: bool = True,
+                       remove_stopwords: bool = True,
+                       lemmatize: bool = True,
+                       correct_spelling: bool = False) -> str:
+        """Apply all preprocessing steps to text."""
+        if not isinstance(text, str):
+            return ""
+            
+        text = text.lower()
+        
+        if remove_urls:
+            text = self.remove_urls(text)
+        if remove_emojis:
+            text = self.remove_emojis(text)
+        if remove_special_chars:
+            text = self.remove_special_chars(text)
+        if remove_stopwords:
+            text = self.remove_stopwords(text)
+        if lemmatize:
+            text = self.lemmatize_text(text)
+        if correct_spelling:
+            text = self.correct_spelling(text)
+            
+        text = self.remove_extra_spaces(text)
+        return text
+    
+    def preprocess_dataframe(self, df: pd.DataFrame, 
+                           text_column: str,
+                           **kwargs) -> pd.DataFrame:
+        """Preprocess text column in a dataframe."""
+        df = df.copy()
+        df[text_column] = df[text_column].apply(
+            lambda x: self.preprocess_text(x, **kwargs)
+        )
+        return df 

src/models/hybrid_model.py

@@ -0,0 +1,87 @@
+import torch
+import torch.nn as nn
+from transformers import BertModel
+from typing import Tuple, Dict
+
+class AttentionLayer(nn.Module):
+    def __init__(self, hidden_size: int):
+        super().__init__()
+        self.attention = nn.Sequential(
+            nn.Linear(hidden_size, hidden_size),
+            nn.Tanh(),
+            nn.Linear(hidden_size, 1)
+        )
+        
+    def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        attention_weights = torch.softmax(self.attention(x), dim=1)
+        attended = torch.sum(attention_weights * x, dim=1)
+        return attended, attention_weights
+
+class HybridFakeNewsDetector(nn.Module):
+    def __init__(self,
+                 bert_model_name: str = "bert-base-uncased",
+                 lstm_hidden_size: int = 256,
+                 lstm_num_layers: int = 2,
+                 dropout_rate: float = 0.3,
+                 num_classes: int = 2):
+        super().__init__()
+        
+        # BERT encoder
+        self.bert = BertModel.from_pretrained(bert_model_name)
+        bert_hidden_size = self.bert.config.hidden_size
+        
+        # BiLSTM layer
+        self.lstm = nn.LSTM(
+            input_size=bert_hidden_size,
+            hidden_size=lstm_hidden_size,
+            num_layers=lstm_num_layers,
+            batch_first=True,
+            bidirectional=True
+        )
+        
+        # Attention layer
+        self.attention = AttentionLayer(lstm_hidden_size * 2)
+        
+        # Classification head
+        self.classifier = nn.Sequential(
+            nn.Dropout(dropout_rate),
+            nn.Linear(lstm_hidden_size * 2, lstm_hidden_size),
+            nn.ReLU(),
+            nn.Dropout(dropout_rate),
+            nn.Linear(lstm_hidden_size, num_classes)
+        )
+        
+    def forward(self, input_ids: torch.Tensor,
+                attention_mask: torch.Tensor) -> Dict[str, torch.Tensor]:
+        # Get BERT embeddings
+        bert_outputs = self.bert(
+            input_ids=input_ids,
+            attention_mask=attention_mask
+        )
+        bert_embeddings = bert_outputs.last_hidden_state
+        
+        # Process through BiLSTM
+        lstm_output, _ = self.lstm(bert_embeddings)
+        
+        # Apply attention
+        attended, attention_weights = self.attention(lstm_output)
+        
+        # Classification
+        logits = self.classifier(attended)
+        
+        return {
+            'logits': logits,
+            'attention_weights': attention_weights
+        }
+    
+    def predict(self, input_ids: torch.Tensor,
+                attention_mask: torch.Tensor) -> torch.Tensor:
+        """Get model predictions."""
+        outputs = self.forward(input_ids, attention_mask)
+        return torch.softmax(outputs['logits'], dim=1)
+    
+    def get_attention_weights(self, input_ids: torch.Tensor,
+                            attention_mask: torch.Tensor) -> torch.Tensor:
+        """Get attention weights for interpretability."""
+        outputs = self.forward(input_ids, attention_mask)
+        return outputs['attention_weights'] 

src/models/trainer.py

@@ -0,0 +1,165 @@
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+from transformers import get_linear_schedule_with_warmup
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+from typing import Dict, List, Tuple
+import numpy as np
+from tqdm import tqdm
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class ModelTrainer:
+    def __init__(self,
+                 model: nn.Module,
+                 device: str = "cuda" if torch.cuda.is_available() else "cpu",
+                 learning_rate: float = 2e-5,
+                 num_epochs: int = 10,
+                 early_stopping_patience: int = 3):
+        self.model = model.to(device)
+        self.device = device
+        self.learning_rate = learning_rate
+        self.num_epochs = num_epochs
+        self.early_stopping_patience = early_stopping_patience
+        
+        self.criterion = nn.CrossEntropyLoss()
+        self.optimizer = torch.optim.AdamW(
+            self.model.parameters(),
+            lr=learning_rate
+        )
+        
+    def train_epoch(self, train_loader: DataLoader) -> float:
+        """Train for one epoch."""
+        self.model.train()
+        total_loss = 0
+        
+        for batch in tqdm(train_loader, desc="Training"):
+            input_ids = batch['input_ids'].to(self.device)
+            attention_mask = batch['attention_mask'].to(self.device)
+            labels = batch['labels'].to(self.device)
+            
+            self.optimizer.zero_grad()
+            
+            outputs = self.model(input_ids, attention_mask)
+            loss = self.criterion(outputs['logits'], labels)
+            
+            loss.backward()
+            self.optimizer.step()
+            
+            total_loss += loss.item()
+            
+        return total_loss / len(train_loader)
+    
+    def evaluate(self, eval_loader: DataLoader) -> Tuple[float, Dict[str, float]]:
+        """Evaluate the model."""
+        self.model.eval()
+        total_loss = 0
+        all_preds = []
+        all_labels = []
+        
+        with torch.no_grad():
+            for batch in tqdm(eval_loader, desc="Evaluating"):
+                input_ids = batch['input_ids'].to(self.device)
+                attention_mask = batch['attention_mask'].to(self.device)
+                labels = batch['labels'].to(self.device)
+                
+                outputs = self.model(input_ids, attention_mask)
+                loss = self.criterion(outputs['logits'], labels)
+                
+                total_loss += loss.item()
+                
+                preds = torch.argmax(outputs['logits'], dim=1)
+                all_preds.extend(preds.cpu().numpy())
+                all_labels.extend(labels.cpu().numpy())
+        
+        # Calculate metrics
+        metrics = self._calculate_metrics(all_labels, all_preds)
+        metrics['loss'] = total_loss / len(eval_loader)
+        
+        return total_loss / len(eval_loader), metrics
+    
+    def _calculate_metrics(self, labels: List[int], preds: List[int]) -> Dict[str, float]:
+        """Calculate evaluation metrics."""
+        precision, recall, f1, _ = precision_recall_fscore_support(
+            labels, preds, average='weighted'
+        )
+        accuracy = accuracy_score(labels, preds)
+        
+        return {
+            'accuracy': accuracy,
+            'precision': precision,
+            'recall': recall,
+            'f1': f1
+        }
+    
+    def train(self,
+              train_loader: DataLoader,
+              val_loader: DataLoader,
+              num_training_steps: int) -> Dict[str, List[float]]:
+        """Train the model with early stopping."""
+        scheduler = get_linear_schedule_with_warmup(
+            self.optimizer,
+            num_warmup_steps=0,
+            num_training_steps=num_training_steps
+        )
+        
+        best_val_loss = float('inf')
+        patience_counter = 0
+        history = {
+            'train_loss': [],
+            'val_loss': [],
+            'val_metrics': []
+        }
+        
+        for epoch in range(self.num_epochs):
+            logger.info(f"Epoch {epoch + 1}/{self.num_epochs}")
+            
+            # Training
+            train_loss = self.train_epoch(train_loader)
+            history['train_loss'].append(train_loss)
+            
+            # Validation
+            val_loss, val_metrics = self.evaluate(val_loader)
+            history['val_loss'].append(val_loss)
+            history['val_metrics'].append(val_metrics)
+            
+            logger.info(f"Train Loss: {train_loss:.4f}")
+            logger.info(f"Val Loss: {val_loss:.4f}")
+            logger.info(f"Val Metrics: {val_metrics}")
+            
+            # Early stopping
+            if val_loss < best_val_loss:
+                best_val_loss = val_loss
+                patience_counter = 0
+                # Save best model
+                torch.save(self.model.state_dict(), 'best_model.pt')
+            else:
+                patience_counter += 1
+                if patience_counter >= self.early_stopping_patience:
+                    logger.info("Early stopping triggered")
+                    break
+            
+            scheduler.step()
+        
+        return history
+    
+    def predict(self, test_loader: DataLoader) -> Tuple[np.ndarray, np.ndarray]:
+        """Get predictions on test data."""
+        self.model.eval()
+        all_preds = []
+        all_probs = []
+        
+        with torch.no_grad():
+            for batch in tqdm(test_loader, desc="Predicting"):
+                input_ids = batch['input_ids'].to(self.device)
+                attention_mask = batch['attention_mask'].to(self.device)
+                
+                probs = self.model.predict(input_ids, attention_mask)
+                preds = torch.argmax(probs, dim=1)
+                
+                all_preds.extend(preds.cpu().numpy())
+                all_probs.extend(probs.cpu().numpy())
+        
+        return np.array(all_preds), np.array(all_probs) 

src/train.py

@@ -0,0 +1,161 @@
+import torch
+from transformers import BertTokenizer
+import pandas as pd
+import logging
+from pathlib import Path
+import sys
+import os
+
+# Add project root to Python path
+project_root = Path(__file__).parent.parent
+sys.path.append(str(project_root))
+
+from src.data.preprocessor import TextPreprocessor
+from src.data.dataset import create_data_loaders
+from src.models.hybrid_model import HybridFakeNewsDetector
+from src.models.trainer import ModelTrainer
+from src.config.config import *
+from src.visualization.plot_metrics import (
+    plot_training_history,
+    plot_confusion_matrix,
+    plot_model_comparison,
+    plot_feature_importance
+)
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def main():
+    # Create necessary directories
+    os.makedirs(SAVED_MODELS_DIR, exist_ok=True)
+    os.makedirs(CHECKPOINTS_DIR, exist_ok=True)
+    os.makedirs(project_root / "visualizations", exist_ok=True)
+    
+    # Load and preprocess data
+    logger.info("Loading and preprocessing data...")
+    df = pd.read_csv(PROCESSED_DATA_DIR / "combined_dataset.csv")
+    
+    # Limit dataset size for faster training
+    if len(df) > MAX_SAMPLES:
+        logger.info(f"Limiting dataset to {MAX_SAMPLES} samples for faster training")
+        df = df.sample(n=MAX_SAMPLES, random_state=RANDOM_STATE)
+    
+    preprocessor = TextPreprocessor()
+    df = preprocessor.preprocess_dataframe(
+        df,
+        text_column='text',
+        remove_urls=True,
+        remove_emojis=True,
+        remove_special_chars=True,
+        remove_stopwords=True,
+        lemmatize=True
+    )
+    
+    # Initialize tokenizer
+    tokenizer = BertTokenizer.from_pretrained(BERT_MODEL_NAME)
+    
+    # Create data loaders
+    logger.info("Creating data loaders...")
+    data_loaders = create_data_loaders(
+        df=df,
+        text_column='text',
+        label_column='label',
+        tokenizer=tokenizer,
+        batch_size=BATCH_SIZE,
+        max_length=MAX_SEQUENCE_LENGTH,
+        train_size=1-TEST_SIZE-VAL_SIZE,
+        val_size=VAL_SIZE,
+        random_state=RANDOM_STATE
+    )
+    
+    # Initialize model
+    logger.info("Initializing model...")
+    model = HybridFakeNewsDetector(
+        bert_model_name=BERT_MODEL_NAME,
+        lstm_hidden_size=LSTM_HIDDEN_SIZE,
+        lstm_num_layers=LSTM_NUM_LAYERS,
+        dropout_rate=DROPOUT_RATE
+    )
+    
+    # Initialize trainer
+    logger.info("Initializing trainer...")
+    trainer = ModelTrainer(
+        model=model,
+        device=DEVICE,
+        learning_rate=LEARNING_RATE,
+        num_epochs=NUM_EPOCHS,
+        early_stopping_patience=EARLY_STOPPING_PATIENCE
+    )
+    
+    # Calculate total training steps
+    num_training_steps = len(data_loaders['train']) * NUM_EPOCHS
+    
+    # Train model
+    logger.info("Starting training...")
+    history = trainer.train(
+        train_loader=data_loaders['train'],
+        val_loader=data_loaders['val'],
+        num_training_steps=num_training_steps
+    )
+    
+    # Evaluate on test set
+    logger.info("Evaluating on test set...")
+    test_loss, test_metrics = trainer.evaluate(data_loaders['test'])
+    logger.info(f"Test Loss: {test_loss:.4f}")
+    logger.info(f"Test Metrics: {test_metrics}")
+    
+    # Save final model
+    logger.info("Saving final model...")
+    torch.save(model.state_dict(), SAVED_MODELS_DIR / "final_model.pt")
+    
+    # Generate visualizations
+    logger.info("Generating visualizations...")
+    vis_dir = project_root / "visualizations"
+    
+    # Plot training history
+    plot_training_history(history, save_path=vis_dir / "training_history.png")
+    
+    # Get predictions for confusion matrix
+    model.eval()
+    all_preds = []
+    all_labels = []
+    with torch.no_grad():
+        for batch in data_loaders['test']:
+            input_ids = batch['input_ids'].to(DEVICE)
+            attention_mask = batch['attention_mask'].to(DEVICE)
+            labels = batch['label']
+            
+            outputs = model(input_ids, attention_mask)
+            preds = torch.argmax(outputs['logits'], dim=1)
+            
+            all_preds.extend(preds.cpu().numpy())
+            all_labels.extend(labels.numpy())
+    
+    # Plot confusion matrix
+    plot_confusion_matrix(
+        np.array(all_labels),
+        np.array(all_preds),
+        save_path=vis_dir / "confusion_matrix.png"
+    )
+    
+    # Plot model comparison with baseline models
+    baseline_metrics = {
+        'BERT': {'accuracy': 0.85, 'precision': 0.82, 'recall': 0.88, 'f1': 0.85},
+        'BiLSTM': {'accuracy': 0.78, 'precision': 0.75, 'recall': 0.81, 'f1': 0.78},
+        'Hybrid': test_metrics  # Our model's metrics
+    }
+    plot_model_comparison(baseline_metrics, save_path=vis_dir / "model_comparison.png")
+    
+    # Plot feature importance
+    feature_importance = {
+        'BERT': 0.4,
+        'BiLSTM': 0.3,
+        'Attention': 0.2,
+        'TF-IDF': 0.1
+    }
+    plot_feature_importance(feature_importance, save_path=vis_dir / "feature_importance.png")
+    
+    logger.info("Training and visualization completed!")
+
+if __name__ == "__main__":
+    main()

src/visualization/plot_metrics.py

@@ -0,0 +1,207 @@
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np
+import pandas as pd
+from pathlib import Path
+import json
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def plot_training_history(history: dict, save_path: Path = None):
+    """
+    Plot training and validation metrics over epochs.
+    
+    Args:
+        history: Dictionary containing training history
+        save_path: Path to save the plot
+    """
+    plt.figure(figsize=(12, 5))
+    
+    # Plot loss
+    plt.subplot(1, 2, 1)
+    plt.plot(history['train_loss'], label='Training Loss')
+    plt.plot(history['val_loss'], label='Validation Loss')
+    plt.title('Training and Validation Loss')
+    plt.xlabel('Epoch')
+    plt.ylabel('Loss')
+    plt.legend()
+    
+    # Plot metrics
+    plt.subplot(1, 2, 2)
+    metrics = ['accuracy', 'precision', 'recall', 'f1']
+    for metric in metrics:
+        values = [epoch_metrics[metric] for epoch_metrics in history['val_metrics']]
+        plt.plot(values, label=metric.capitalize())
+    
+    plt.title('Validation Metrics')
+    plt.xlabel('Epoch')
+    plt.ylabel('Score')
+    plt.legend()
+    
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path)
+        logger.info(f"Training history plot saved to {save_path}")
+    
+    plt.close()
+
+def plot_confusion_matrix(y_true: np.ndarray, y_pred: np.ndarray, save_path: Path = None):
+    """
+    Plot confusion matrix for model predictions.
+    
+    Args:
+        y_true: True labels
+        y_pred: Predicted labels
+        save_path: Path to save the plot
+    """
+    from sklearn.metrics import confusion_matrix
+    
+    cm = confusion_matrix(y_true, y_pred)
+    plt.figure(figsize=(8, 6))
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
+    plt.title('Confusion Matrix')
+    plt.xlabel('Predicted Label')
+    plt.ylabel('True Label')
+    
+    if save_path:
+        plt.savefig(save_path)
+        logger.info(f"Confusion matrix plot saved to {save_path}")
+    
+    plt.close()
+
+def plot_attention_weights(text: str, attention_weights: np.ndarray, save_path: Path = None):
+    """
+    Plot attention weights for a given text.
+    
+    Args:
+        text: Input text
+        attention_weights: Attention weights for each token
+        save_path: Path to save the plot
+    """
+    tokens = text.split()
+    plt.figure(figsize=(12, 4))
+    
+    # Plot attention weights
+    plt.bar(range(len(tokens)), attention_weights)
+    plt.xticks(range(len(tokens)), tokens, rotation=45, ha='right')
+    plt.title('Attention Weights')
+    plt.xlabel('Tokens')
+    plt.ylabel('Attention Weight')
+    
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path)
+        logger.info(f"Attention weights plot saved to {save_path}")
+    
+    plt.close()
+
+def plot_model_comparison(metrics: dict, save_path: Path = None):
+    """
+    Plot comparison of different models' performance.
+    
+    Args:
+        metrics: Dictionary containing model metrics
+        save_path: Path to save the plot
+    """
+    models = list(metrics.keys())
+    metric_names = ['accuracy', 'precision', 'recall', 'f1']
+    
+    plt.figure(figsize=(10, 6))
+    x = np.arange(len(models))
+    width = 0.2
+    
+    for i, metric in enumerate(metric_names):
+        values = [metrics[model][metric] for model in models]
+        plt.bar(x + i*width, values, width, label=metric.capitalize())
+    
+    plt.title('Model Performance Comparison')
+    plt.xlabel('Models')
+    plt.ylabel('Score')
+    plt.xticks(x + width*1.5, models, rotation=45)
+    plt.legend()
+    
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path)
+        logger.info(f"Model comparison plot saved to {save_path}")
+    
+    plt.close()
+
+def plot_feature_importance(feature_importance: dict, save_path: Path = None):
+    """
+    Plot feature importance scores.
+    
+    Args:
+        feature_importance: Dictionary containing feature importance scores
+        save_path: Path to save the plot
+    """
+    features = list(feature_importance.keys())
+    importance = list(feature_importance.values())
+    
+    # Sort by importance
+    sorted_idx = np.argsort(importance)
+    features = [features[i] for i in sorted_idx]
+    importance = [importance[i] for i in sorted_idx]
+    
+    plt.figure(figsize=(10, 6))
+    plt.barh(range(len(features)), importance)
+    plt.yticks(range(len(features)), features)
+    plt.title('Feature Importance')
+    plt.xlabel('Importance Score')
+    
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path)
+        logger.info(f"Feature importance plot saved to {save_path}")
+    
+    plt.close()
+
+def main():
+    # Create visualization directory
+    vis_dir = Path(__file__).parent.parent.parent / "visualizations"
+    vis_dir.mkdir(exist_ok=True)
+    
+    # Example usage
+    history = {
+        'train_loss': [0.5, 0.4, 0.3],
+        'val_loss': [0.45, 0.35, 0.25],
+        'val_metrics': [
+            {'accuracy': 0.8, 'precision': 0.75, 'recall': 0.85, 'f1': 0.8},
+            {'accuracy': 0.85, 'precision': 0.8, 'recall': 0.9, 'f1': 0.85},
+            {'accuracy': 0.9, 'precision': 0.85, 'recall': 0.95, 'f1': 0.9}
+        ]
+    }
+    
+    # Plot training history
+    plot_training_history(history, save_path=vis_dir / "training_history.png")
+    
+    # Example confusion matrix
+    y_true = np.array([0, 1, 0, 1, 1, 0])
+    y_pred = np.array([0, 1, 0, 0, 1, 0])
+    plot_confusion_matrix(y_true, y_pred, save_path=vis_dir / "confusion_matrix.png")
+    
+    # Example model comparison
+    metrics = {
+        'BERT': {'accuracy': 0.85, 'precision': 0.82, 'recall': 0.88, 'f1': 0.85},
+        'BiLSTM': {'accuracy': 0.78, 'precision': 0.75, 'recall': 0.81, 'f1': 0.78},
+        'Hybrid': {'accuracy': 0.92, 'precision': 0.9, 'recall': 0.94, 'f1': 0.92}
+    }
+    plot_model_comparison(metrics, save_path=vis_dir / "model_comparison.png")
+    
+    # Example feature importance
+    feature_importance = {
+        'BERT': 0.4,
+        'BiLSTM': 0.3,
+        'Attention': 0.2,
+        'TF-IDF': 0.1
+    }
+    plot_feature_importance(feature_importance, save_path=vis_dir / "feature_importance.png")
+
+if __name__ == "__main__":
+    main()