added readme and raw training files

README.md

@@ -1,29 +1,25 @@
 ---
 library_name: transformers
-tags: []
+tags:
+  - text-classification
+  - contact-information-detection
+  - privacy
 ---
 
-# Model Card for Model ID
+# Model Card for ContactShieldAI
 
-<!-- Provide a quick summary of what the model is/does. -->
+ContactShieldAI is a powerful text classification model designed to detect if users are sharing contact information on freelancing websites. This model helps maintain privacy and adherence to platform guidelines by identifying instances where users might be attempting to circumvent communication policies.
 
 
-
-## Model Details
-
 ### Model Description
 
-<!-- Provide a longer summary of what this model is. -->
-
-This is the model card of a 🤗 transformers model that has been pushed on the Hub. This model card has been automatically generated.
+ContactShieldAI is based on an enhanced CNN-LSTM architecture, combining the strengths of both convolutional and recurrent neural networks for effective text classification.
 
-- **Developed by:** [More Information Needed]
-- **Funded by [optional]:** [More Information Needed]
-- **Shared by [optional]:** [More Information Needed]
-- **Model type:** [More Information Needed]
-- **Language(s) (NLP):** [More Information Needed]
-- **License:** [More Information Needed]
-- **Finetuned from model [optional]:** [More Information Needed]
+- **Developed by:** xxparthparekhxx
+- **Model type:** Text Classification
+- **Language(s):** English
+- **License:** Apache 2.0
+- **Finetuned from model:** Trained from scratch, initialized with GloVe embeddings
 
 ### Model Sources [optional]
 
@@ -33,167 +29,179 @@ This is the model card of a 🤗 transformers model that has been pushed on the
 - **Paper [optional]:** [More Information Needed]
 - **Demo [optional]:** [More Information Needed]
 
-## Uses
-
-<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
-
-### Direct Use
 
-<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
-
-[More Information Needed]
+### Uses
 
+ContactShieldAI is designed for:
+- Detecting contact information sharing in text on freelancing platforms
+- Enhancing privacy protection in online marketplaces
+- Assisting moderators in identifying policy violations
 ### Downstream Use [optional]
 
 <!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
 
-[More Information Needed]
+ContactShieldAI can be fine-tuned or integrated into:
+- Content moderation systems for social media platforms
+- Customer support chatbots to protect user privacy
+- Email filtering systems to detect potential policy violations
 
 ### Out-of-Scope Use
 
 <!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
 
-[More Information Needed]
+ContactShieldAI should not be used for:
+- Censoring legitimate communication that doesn't violate platform policies
+- Invading user privacy by scanning personal conversations without consent
+- Making decisions about user accounts without human review
+- Detecting contact information in languages other than English (current version)
+
 
 ## Bias, Risks, and Limitations
 
 <!-- This section is meant to convey both technical and sociotechnical limitations. -->
 
-[More Information Needed]
+- The model is trained on synthetic data and may not capture all real-world variations
+- It's specifically tailored for English language text
+- Performance may vary on very short or highly obfuscated text
 
 ### Recommendations
 
 <!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
 
-Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+While this model is designed to enhance privacy and policy compliance, users should be aware of potential biases in the training data. It should be used as a tool to assist human moderators rather than as a sole decision-maker in content moderation.
 
 ## How to Get Started with the Model
 
-Use the code below to get started with the model.
-
-[More Information Needed]
-
-## Training Details
-
-### Training Data
-
-<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+You can use the model directly with the Hugging Face Transformers library:
 
-[More Information Needed]
+```python
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
 
-### Training Procedure
-
-<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+tokenizer = AutoTokenizer.from_pretrained("xxparthparekhxx/ContactShieldAI")
+model = AutoModelForSequenceClassification.from_pretrained("xxparthparekhxx/ContactShieldAI")
 
-#### Preprocessing [optional]
+text = "Please contact me at [email protected] or call 555-1234."
+inputs = tokenizer(text, return_tensors="pt")
+outputs = model(**inputs)
+prediction = outputs.logits.argmax(-1).item()
 
-[More Information Needed]
+print("Contains contact info" if prediction == 1 else "No contact info")
+```
 
 
-#### Training Hyperparameters
+### Training Data
 
-- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+The model was trained on a synthetically generated dataset:
+- 200,000 examples created using LLaMA 3.1 70B
+- Balanced dataset of positive (containing contact info) and negative examples
 
-#### Speeds, Sizes, Times [optional]
+### Training Procedure
 
-<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+The training procedure for ContactShieldAI follows these steps:
 
-[More Information Needed]
+1. Data Preparation:
+   - Load the dataset using the `load_data()` function
+   - Create a vocabulary from the dataset using `build_vocab_from_iterator()`
+   - Initialize GloVe embeddings for the vocabulary
 
-## Evaluation
+2. Model Initialization:
+   - Create an instance of `EnhancedContactSharingModel`
+   - Initialize the embedding layer with pretrained GloVe embeddings
 
-<!-- This section describes the evaluation protocols and provides the results. -->
+3. Dataset and DataLoader Creation:
+   - Create a `ContactSharingDataset` instance
+   - Use `DataLoader` with custom `collate_batch` function for efficient batching
 
-### Testing Data, Factors & Metrics
+4. Training Loop:
+   - Implement k-fold cross-validation (k=5) using `KFold` from sklearn
+   - For each fold:
+     - Reset model parameters (except embeddings)
+     - Create train and validation data loaders
+     - Initialize Adam optimizer and ReduceLROnPlateau scheduler
+     - Train for a specified number of epochs (default: 4)
+     - In each epoch:
+       - Iterate through batches, compute loss, and update model parameters
+       - Evaluate on validation set and update learning rate if needed
+     - Save the best model based on validation loss
 
-#### Testing Data
+5. Evaluation:
+   - Implement an `evaluate()` function to compute loss on a given dataset
 
-<!-- This should link to a Dataset Card if possible. -->
+6. Prediction:
+   - Implement a `predict()` function for making predictions on new text inputs
 
-[More Information Needed]
+The training process utilizes techniques such as learning rate scheduling, early stopping, and k-fold cross-validation to ensure robust model performance and generalization.
 
-#### Factors
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
 
-<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+#### Preprocessing [optional]
 
-[More Information Needed]
+- Text tokenization using SpaCy
+- Vocabulary built from the training data
+- Texts padded to uniform length
 
-#### Metrics
+#### Training Hyperparameters
 
-<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+- Optimizer: Adam (lr=0.0001, weight_decay=1e-5)
+- Loss Function: Cross Entropy Loss
+- Learning Rate Scheduler: ReduceLROnPlateau
+- Batch Size: 128
+- Epochs: 15 (early stopping based on validation loss)
 
-[More Information Needed]
 
 ### Results
 
-[More Information Needed]
+The model achieved an impressive validation loss of 0.0211, indicating high accuracy in detecting contact information sharing.
 
 #### Summary
 
 
+ContactShieldAI is a powerful model designed to detect contact information sharing in text. Key features include:
 
-## Model Examination [optional]
-
-<!-- Relevant interpretability work for the model goes here -->
+- Trained on a large, balanced dataset of 200,000 examples
+- Utilizes a sophisticated architecture combining LSTM and CNN
+- Achieves high accuracy with a validation loss of 0.0211
+- Easy to use with Hugging Face Transformers library
+- Suitable for various applications requiring privacy protection and data security
 
-[More Information Needed]
+The model's architecture and training procedure are optimized for efficient and accurate detection of contact information, making it a valuable tool for safeguarding user privacy in various text-based applications.
 
-## Environmental Impact
 
-<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
 
-Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
-
-- **Hardware Type:** [More Information Needed]
-- **Hours used:** [More Information Needed]
-- **Cloud Provider:** [More Information Needed]
-- **Compute Region:** [More Information Needed]
-- **Carbon Emitted:** [More Information Needed]
 
 ## Technical Specifications [optional]
 
-### Model Architecture and Objective
-
-[More Information Needed]
-
-### Compute Infrastructure
-
-[More Information Needed]
 
-#### Hardware
+### Model Architecture and Objective
 
-[More Information Needed]
+ContactShieldAI utilizes a sophisticated architecture:
 
-#### Software
+1. **Embedding Layer:** Initialized with GloVe 6B 300d embeddings, expanded to 600d
+2. **Bidirectional LSTM:** Processes the embedded sequence
+3. **Multi-scale CNN:** Multiple convolutional layers with different filter sizes (3 to 10)
+4. **Max Pooling:** Applied after each convolutional layer
+5. **Fully Connected Layers:** Two FC layers with ReLU activation and dropout
+6. **Output Layer:** 2-dimensional output for binary classification
 
-[More Information Needed]
+Key Parameters:
+- Vocabulary Size: 225,817
+- Embedding Dimension: 600
+- Number of Filters: 600
+- Filter Sizes: [3, 4, 5, 6, 7, 8, 9, 10]
+- LSTM Hidden Dimension: 768
+- Dropout: 0.5
 
-## Citation [optional]
+<!-- ## Citation [optional]
 
 <!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
 
-**BibTeX:**
-
-[More Information Needed]
-
-**APA:**
-
-[More Information Needed]
-
-## Glossary [optional]
-
-<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
-
-[More Information Needed]
-
-## More Information [optional]
-
-[More Information Needed]
-
-## Model Card Authors [optional]
-
-[More Information Needed]
-
-## Model Card Contact
+**APA:** -->
 
-[More Information Needed]
+@misc{ContactShieldAI,
+  author = {xxparthparekhxx},
+  title = {ContactShieldAI: A Model for Detecting Contact Information Sharing},
+  year = {2023},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  howpublished = {\url{https://huggingface.co/xxparthparekhxx/ContactShieldAI}}
+}

raw/contact_sharing_epoch_1.pth

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

raw/tester.py

@@ -0,0 +1,103 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchtext.vocab import build_vocab_from_iterator, GloVe
+from torchtext.data.utils import get_tokenizer
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+class ContactSharingClassifier(nn.Module):
+    def __init__(self, vocab_size, embed_dim, num_filters, filter_sizes, lstm_hidden_dim, output_dim, dropout, pad_idx):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=pad_idx)
+        self.lstm = nn.LSTM(embed_dim, lstm_hidden_dim, bidirectional=True, batch_first=True)
+        self.convs = nn.ModuleList([
+            nn.Conv1d(in_channels=lstm_hidden_dim*2, out_channels=num_filters, kernel_size=fs)
+            for fs in filter_sizes
+        ])
+        self.fc1 = nn.Linear(len(filter_sizes) * num_filters, len(filter_sizes) * num_filters // 2)
+        self.fc2 = nn.Linear(len(filter_sizes) * num_filters // 2, output_dim)
+        self.dropout = nn.Dropout(dropout)
+        self.layer_norm = nn.LayerNorm(len(filter_sizes) * num_filters)
+
+    def forward(self, text):
+        embedded = self.embedding(text)
+        lstm_out, _ = self.lstm(embedded)
+        lstm_out = lstm_out.permute(0, 2, 1)
+        conved = [F.relu(conv(lstm_out)) for conv in self.convs]
+        pooled = [F.max_pool1d(conv, conv.shape[2]).squeeze(2) for conv in conved]
+        cat = self.dropout(torch.cat(pooled, dim=1))
+        cat = self.layer_norm(cat)
+        x = F.relu(self.fc1(cat))
+        x = self.dropout(x)
+        return self.fc2(x)
+
+# Initialize tokenizer and vocabulary
+tokenizer = get_tokenizer("spacy", language="en_core_web_sm")
+vocab = torch.load('vocab.pth')  # Assuming you've saved the vocabulary
+
+# Define text pipeline
+def text_pipeline(x):
+    return [vocab[token] for token in tokenizer(x)]
+
+# Model parameters
+VOCAB_SIZE = len(vocab)
+EMBED_DIM = 600
+NUM_FILTERS = 600
+FILTER_SIZES = [3, 4, 5, 6, 7, 8, 9, 10]
+LSTM_HIDDEN_DIM = 768
+OUTPUT_DIM = 2
+DROPOUT = 0.5
+PAD_IDX = vocab["<pad>"]
+
+# Load the model
+
+model = ContactSharingClassifier(VOCAB_SIZE, EMBED_DIM, NUM_FILTERS, FILTER_SIZES, LSTM_HIDDEN_DIM, OUTPUT_DIM, DROPOUT, PAD_IDX)
+model.load_state_dict(torch.load('contact_sharing_epoch_1.pth', map_location=device))
+model.to(device)
+model.eval()
+
+# Test sentences
+test_sentences = [
+    "You can reach me at my electronic mail address, it's my first name dot last name at that popular search engine company's mail service.",
+    "Call me on my cellular device, the digits are the same as the year the Declaration of Independence was signed, followed by my birth year, twice.",
+    "Visit my online presence at triple w dot my full name without spaces or punctuation dot com.",
+    "Send a message to username 'not_my_real_name' on that instant messaging platform that starts with 'disc' and ends with 'ord'.",
+    "My contact info is hidden in this sentence: Eight Six Seven Five Three Oh Nine.",
+    "Find me on the professional networking site, just search for my name plus 'software engineer in San Francisco'.",
+    "My handle on the bird-themed social media platform is at symbol followed by 'definitely_not_my_email_address'.",
+    "You know that video sharing site? My channel is there, just add 'cool_coder_' before my full name, all lowercase.",
+    "I'm listed in the phone book under 'Smith, John' but replace 'Smith' with my actual last name and 'John' with my first name.",
+    "My contact details are encrypted: Rot13('[email protected]')",
+    
+    # New non-contact sharing examples
+    "The weather today is absolutely beautiful, perfect for a picnic in the park.",
+    "I'm really excited about the new sci-fi movie coming out next month.",
+    "Did you hear about the latest advancements in artificial intelligence? It's fascinating!",
+    "I'm planning to go hiking this weekend in the nearby mountains.",
+    "The recipe calls for two cups of flour and a pinch of salt.",
+    "The annual tech conference will be held virtually this year due to ongoing health concerns.",
+    "I've been learning to play the guitar for the past six months. It's challenging but rewarding.",
+    "The local farmer's market has the freshest produce every Saturday morning.",
+    "Did you catch the game last night? It was an incredible comeback in the final quarter!",
+    "Lets do '42069' tonight it will be really fun what do you say ?"
+]
+
+
+# Function to predict
+def predict(text):
+    with torch.no_grad():
+        inputs = torch.tensor([text_pipeline(text)])
+        if inputs.size(1) < max(FILTER_SIZES):
+            # Pad the input if it's shorter than the largest filter size
+            padding = torch.zeros(1, max(FILTER_SIZES) - inputs.size(1), dtype=torch.long)
+            inputs = torch.cat([inputs, padding], dim=1)
+        inputs = inputs.to(device)
+        outputs = model(inputs)
+        return torch.argmax(outputs, dim=1).item()
+
+# Test the sentences
+for i, sentence in enumerate(test_sentences, 1):
+    prediction = predict(sentence)
+    result = "Contains contact info" if prediction == 1 else "No contact info"
+    print(f"Sentence {i}: {result}")
+    print(f"Text: {sentence}\n")

raw/trainer.py

@@ -0,0 +1,173 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchtext.vocab import build_vocab_from_iterator, GloVe
+from torchtext.data.utils import get_tokenizer
+import json
+from sklearn.model_selection import KFold
+from torch.utils.data import Dataset, DataLoader
+from tqdm import tqdm
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+class ContactSharingDataset(Dataset):
+    def __init__(self, data, text_pipeline, label_pipeline):
+        self.data = data
+        self.text_pipeline = text_pipeline
+        self.label_pipeline = label_pipeline
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        text, label = self.data[idx]
+        return self.text_pipeline(text), self.label_pipeline(label)
+
+class EnhancedContactSharingModel(nn.Module):
+    def __init__(self, vocab_size, embed_dim, num_filters, filter_sizes, lstm_hidden_dim, output_dim, dropout, pad_idx):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=pad_idx)
+        self.lstm = nn.LSTM(embed_dim, lstm_hidden_dim, bidirectional=True, batch_first=True)
+        self.convs = nn.ModuleList([
+            nn.Conv1d(in_channels=lstm_hidden_dim*2, out_channels=num_filters, kernel_size=fs)
+            for fs in filter_sizes
+        ])
+        self.fc1 = nn.Linear(len(filter_sizes) * num_filters, len(filter_sizes) * num_filters // 2)
+        self.fc2 = nn.Linear(len(filter_sizes) * num_filters // 2, output_dim)
+        self.dropout = nn.Dropout(dropout)
+        self.layer_norm = nn.LayerNorm(len(filter_sizes) * num_filters)
+
+    def forward(self, text):
+        embedded = self.embedding(text)
+        lstm_out, _ = self.lstm(embedded)
+        lstm_out = lstm_out.permute(0, 2, 1)
+        conved = [F.relu(conv(lstm_out)) for conv in self.convs]
+        pooled = [F.max_pool1d(conv, conv.shape[2]).squeeze(2) for conv in conved]
+        cat = self.dropout(torch.cat(pooled, dim=1))
+        cat = self.layer_norm(cat)
+        x = F.relu(self.fc1(cat))
+        x = self.dropout(x)
+        return self.fc2(x)
+
+def load_data(filename='contacts_data.json'):
+    with open(filename, 'r') as f:
+        data = json.load(f)
+    return [(item['text'], item['label']) for item in data]
+
+tokenizer = get_tokenizer("spacy", language="en_core_web_sm")
+def yield_tokens(data_iter):
+    for text, _ in data_iter:
+        yield tokenizer(text)
+
+data = load_data()
+vocab = build_vocab_from_iterator(yield_tokens(data), specials=["<unk>", "<pad>"])
+vocab.set_default_index(vocab["<unk>"])
+
+glove = GloVe(name="6B", dim=300)
+pretrained_embedding = torch.zeros(len(vocab), 300)
+for token, index in vocab.get_stoi().items():
+    if token in glove.stoi:
+        pretrained_embedding[index] = glove[token]
+
+def text_pipeline(x):
+    return [vocab[token] for token in tokenizer(x)]
+
+def label_pipeline(x):
+    return int(x)
+
+def collate_batch(batch):
+    label_list, text_list = [], []
+    for (_text, _label) in batch:
+        label_list.append(_label)
+        processed_text = torch.tensor(_text, dtype=torch.int64)
+        text_list.append(processed_text)
+    label_list = torch.tensor(label_list, dtype=torch.int64)
+    text_list = nn.utils.rnn.pad_sequence(text_list, batch_first=True, padding_value=vocab["<pad>"])
+    return text_list, label_list
+
+VOCAB_SIZE = len(vocab)
+EMBED_DIM = 600
+NUM_FILTERS = 600
+FILTER_SIZES = [3, 4, 5, 6, 7, 8, 9, 10]
+LSTM_HIDDEN_DIM = 768
+OUTPUT_DIM = 2
+DROPOUT = 0.5
+PAD_IDX = vocab["<pad>"]
+
+model = EnhancedContactSharingModel(VOCAB_SIZE, EMBED_DIM, NUM_FILTERS, FILTER_SIZES, LSTM_HIDDEN_DIM, OUTPUT_DIM, DROPOUT, PAD_IDX).to(device)
+pretrained_embedding_padded = torch.zeros(VOCAB_SIZE, EMBED_DIM)
+pretrained_embedding_padded[:, :300] = pretrained_embedding
+model.embedding.weight.data.copy_(pretrained_embedding_padded)
+
+def train_model(model, train_loader, val_loader, optimizer, criterion, scheduler, num_epochs=15):
+    best_val_loss = float('inf')
+    for epoch in range(num_epochs):
+        model.train()
+        total_loss = 0
+        for batch in tqdm(train_loader, desc=f"Epoch {epoch+1}/{num_epochs}"):
+            text, labels = batch
+            text, labels = text.to(device), labels.to(device)
+            optimizer.zero_grad()
+            predictions = model(text)
+            loss = criterion(predictions, labels)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        
+        avg_train_loss = total_loss / len(train_loader)
+        val_loss = evaluate(model, val_loader, criterion)
+        scheduler.step(val_loss)
+        
+        print(f"Epoch {epoch+1}/{num_epochs}, Train Loss: {avg_train_loss:.4f}, Val Loss: {val_loss:.4f}")
+        
+        if val_loss < best_val_loss:
+            best_val_loss = val_loss
+            torch.save(model.state_dict(), 'best_model.pth')
+
+def evaluate(model, data_loader, criterion):
+    model.eval()
+    total_loss = 0
+    with torch.no_grad():
+        for batch in data_loader:
+            text, labels = batch
+            text, labels = text.to(device), labels.to(device)
+            predictions = model(text)
+            loss = criterion(predictions, labels)
+            total_loss += loss.item()
+    return total_loss / len(data_loader)
+
+def k_fold_cross_validation(model, dataset, k=5, batch_size=128, num_epochs=4):
+    kf = KFold(n_splits=k, shuffle=True, random_state=42)
+    
+    for fold, (train_idx, val_idx) in enumerate(kf.split(dataset)):
+        print(f"Fold {fold+1}/{k}")
+        
+        train_subsampler = torch.utils.data.SubsetRandomSampler(train_idx)
+        val_subsampler = torch.utils.data.SubsetRandomSampler(val_idx)
+        
+        train_loader = DataLoader(dataset, batch_size=batch_size, sampler=train_subsampler, collate_fn=collate_batch)
+        val_loader = DataLoader(dataset, batch_size=batch_size, sampler=val_subsampler, collate_fn=collate_batch)
+        
+        model.apply(lambda m: m.reset_parameters() if hasattr(m, 'reset_parameters') else None)
+        model.embedding.weight.data.copy_(pretrained_embedding_padded)
+        
+        optimizer = torch.optim.Adam(model.parameters(), lr=0.0001, weight_decay=1e-5)
+        criterion = nn.CrossEntropyLoss()
+        scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=3)
+        
+        train_model(model, train_loader, val_loader, optimizer, criterion, scheduler, num_epochs)
+
+def predict(text):
+    model.eval()
+    with torch.no_grad():
+        text = torch.tensor(text_pipeline(text)).unsqueeze(0).to(device)
+        output = model(text)
+        return output.argmax(1).item()
+
+if __name__ == "__main__":
+    dataset = ContactSharingDataset(data, text_pipeline, label_pipeline)
+    k_fold_cross_validation(model, dataset)
+
+    sample_text = "Please contact me at [email protected] or call 555-1234."
+    prediction = predict(sample_text)
+    print(f"Prediction for '{sample_text}': {'Contains contact info' if prediction == 1 else 'No contact info'}")

raw/uploader.py

@@ -0,0 +1,84 @@
+import torch
+from transformers import PreTrainedModel, PretrainedConfig
+from huggingface_hub import push_to_hub_pytorch
+from torchtext.vocab import build_vocab_from_iterator, GloVe
+from torchtext.data.utils import get_tokenizer
+import torch.nn as nn
+import torch.nn.functional as F
+
+# Define the configuration class
+class ContactSharingConfig(PretrainedConfig):
+    model_type = "contact_sharing"
+    
+    def __init__(
+        self,
+        vocab_size=0,
+        embed_dim=600,
+        num_filters=600,
+        filter_sizes=[3, 4, 5, 6, 7, 8, 9, 10],
+        lstm_hidden_dim=768,
+        output_dim=2,
+        dropout=0.5,
+        pad_idx=0,
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.vocab_size = vocab_size
+        self.embed_dim = embed_dim
+        self.num_filters = num_filters
+        self.filter_sizes = filter_sizes
+        self.lstm_hidden_dim = lstm_hidden_dim
+        self.output_dim = output_dim
+        self.dropout = dropout
+        self.pad_idx = pad_idx
+
+# Define the model class
+class ContactSharingClassifier(PreTrainedModel):
+    config_class = ContactSharingConfig
+    
+    def __init__(self, config):
+        super().__init__(config)
+        self.embedding = nn.Embedding(config.vocab_size, config.embed_dim, padding_idx=config.pad_idx)
+        self.lstm = nn.LSTM(config.embed_dim, config.lstm_hidden_dim, bidirectional=True, batch_first=True)
+        self.convs = nn.ModuleList([
+            nn.Conv1d(in_channels=config.lstm_hidden_dim*2, out_channels=config.num_filters, kernel_size=fs)
+            for fs in config.filter_sizes
+        ])
+        self.fc1 = nn.Linear(len(config.filter_sizes) * config.num_filters, len(config.filter_sizes) * config.num_filters // 2)
+        self.fc2 = nn.Linear(len(config.filter_sizes) * config.num_filters // 2, config.output_dim)
+        self.dropout = nn.Dropout(config.dropout)
+        self.layer_norm = nn.LayerNorm(len(config.filter_sizes) * config.num_filters)
+
+    def forward(self, text):
+        embedded = self.embedding(text)
+        lstm_out, _ = self.lstm(embedded)
+        lstm_out = lstm_out.permute(0, 2, 1)
+        conved = [F.relu(conv(lstm_out)) for conv in self.convs]
+        pooled = [F.max_pool1d(conv, conv.shape[2]).squeeze(2) for conv in conved]
+        cat = self.dropout(torch.cat(pooled, dim=1))
+        cat = self.layer_norm(cat)
+        x = F.relu(self.fc1(cat))
+        x = self.dropout(x)
+        return self.fc2(x)
+
+# Load vocabulary
+vocab = torch.load('vocab.pth')
+
+# Create configuration
+config = ContactSharingConfig(vocab_size=len(vocab), pad_idx=vocab["<pad>"])
+
+# Create model
+model = ContactSharingClassifier(config)
+
+# Load trained weights
+model.load_state_dict(torch.load('contact_sharing_epoch_1.pth', map_location='cpu'))
+
+# Push to Hub
+push_to_hub_pytorch(
+    model,
+    repo_name="contact-sharing-classifier",
+    organization=None,  # Set this to your organization name if you're pushing to an organization
+    use_temp_dir=True
+)
+
+print("Model uploaded successfully to Hugging Face Hub!")