added app files

.gitattributes

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

README.md

@@ -11,4 +11,90 @@ license: apache-2.0
 short_description: MGT-Detection
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# MGT-Detection
+
+## Overview
+MGT-Detection (Machine-Generated Text Detection) is a project designed to classify and detect whether a given text is human-written or machine-generated. The project leverages state-of-the-art natural language processing (NLP) models and pipelines to achieve accurate classification results. It includes tools for training, evaluating, and deploying models for text classification tasks.
+
+## Features
+- **Text Classification**: Detects whether a text is human-written or machine-generated.
+- **Model Training Pipeline**: Includes hyperparameter optimization, dataset preparation, and model training.
+- **Evaluation**: Provides metrics such as accuracy, precision, recall, and F1 score.
+- **Dataset Management**: Tools for preparing and tokenizing datasets.
+- **Model Deployment**: Save and load fine-tuned models for deployment.
+
+## Project Structure
+```
+MGT-Detection/
+├── app.py                # Main application for text classification
+├── pipeline/
+│   ├── dataset.py        # Dataset preparation and management
+│   ├── model_pipeline.py # Model training and evaluation pipeline
+│   ├── main.py           # Entry point for running the training pipeline
+├── samples.json          # Sample dataset for testing
+```
+
+
+## Usage
+### Running the Application
+To launch the text classification application:
+```bash
+python app.py
+```
+
+### Training a Model
+To train a model using the pipeline:
+```bash
+python pipeline/main.py \
+  --file_path <path_to_dataset> \
+  --out_path <output_directory> \
+  --model_name <model_name> \
+  --num_labels 2 \
+  --sample_frac 1.0 \
+  --num_trials 5 \
+  --num_epochs 5
+```
+
+### Dataset Preparation
+Ensure your dataset is in JSON format with the following structure:
+```json
+[
+  {
+    "text": "<text_sample>",
+    "label": "<label>",
+  },
+  ...
+]
+```
+
+## Key Components
+### `app.py`
+- Provides a user interface for classifying text as human-written or machine-generated.
+
+### `pipeline/model_pipeline.py`
+- Contains functions for model training, hyperparameter optimization, and evaluation.
+
+### `pipeline/dataset.py`
+- Handles dataset preparation, tokenization, and saving/loading datasets.
+
+### `samples.json`
+- A sample dataset for testing the application.
+
+## Requirements
+- Python 3.8+
+- Transformers
+- Datasets
+- Optuna
+- Gradio
+- Scikit-learn
+
+## Contributing
+Contributions are welcome! Please fork the repository and submit a pull request with your changes.
+
+## License
+This project is licensed under the MIT License. See the LICENSE file for details.
+
+## Acknowledgments
+- Hugging Face Transformers
+- Optuna for hyperparameter optimization
+- Gradio for building the user interface

app.py

@@ -0,0 +1,118 @@
+import json
+import random
+from pathlib import Path
+import gradio as gr
+import numpy as np
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
+
+# Constants
+MIN_WORDS = 50
+MAX_WORDS = 500
+SAMPLE_JSON_PATH = Path('samples.json')
+
+# Load models
+def load_model(model_name):
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForSequenceClassification.from_pretrained(model_name)
+    return pipeline('text-classification', model=model, tokenizer=tokenizer, truncation=True, max_length=512, top_k=4)
+
+classifier = load_model("ziadmostafa/MGT-Detection_deberta-base")
+
+# Load sample essays
+with open(SAMPLE_JSON_PATH, 'r') as f:
+    demo_essays = json.load(f)
+
+# Global variable to store the current essay index
+current_essay_index = None
+
+TEXT_CLASS_MAPPING = {
+    'LABEL_0': 'Human-Written',
+    'LABEL_2': 'Machine-Generated'
+}
+
+def process_result(text): 
+    result = classifier(text)[0]
+
+    labels = [TEXT_CLASS_MAPPING[x['label']] for x in result if x['label'] in TEXT_CLASS_MAPPING]
+    scores = list(np.array([x['score'] for x in result if x['label'] in TEXT_CLASS_MAPPING]))
+
+    final_results = dict(zip(labels, scores))
+
+    # Return only the label with the highest score
+    return max(final_results, key=final_results.get)
+
+def update_result(name):
+    if name == '':
+        return "" 
+    return process_result(name)
+   
+def active_button(input_text):
+    if not (50 <= len(input_text.split()) <= 500):
+        return gr.Button("Check Origin", variant="primary", interactive=False) 
+    return gr.Button("Check Origin", variant="primary", interactive=True)
+
+def clear_inputs():
+    return "", gr.Button("Check Origin", variant="primary", interactive=False)
+
+def count_words(text): 
+    return f'{len(text.split())}/500 words (Minimum 50 words)'
+
+css = """
+body, .gradio-container {
+    font-family: Arial, sans-serif;
+}
+.gr-input, .gr-textarea {
+}
+.class-intro {
+    padding: 15px;
+    margin-bottom: 20px;
+    border-radius: 5px;
+}
+.class-intro h2 {
+    margin-top: 0;
+}
+.class-intro p {
+    margin-bottom: 5px;
+}
+"""
+
+class_intro_html = """
+<div class="class-intro">
+    <h2>Text Classes</h2>
+    <p><strong>Human-Written:</strong> Original text created by humans.</p>
+    <p><strong>Machine-Generated:</strong> Text created by AI from basic prompts, without style instructions.</p>
+</div>
+"""
+
+with gr.Blocks(css=css) as demo:
+    gr.Markdown("""<h1><centre>Machine Generated Text Detection</center></h1>""")
+    gr.HTML(class_intro_html)
+
+    with gr.Row():
+        input_text = gr.Textbox(placeholder="Paste your text here...", label="Text", lines=10, max_lines=15)
+
+    with gr.Row(): 
+        wc = gr.Markdown("0/500 words (Minimum 50 words)")
+    with gr.Row():
+        check_button = gr.Button("Check Origin", variant="primary", interactive=False)
+        clear_button = gr.ClearButton([input_text], variant="stop")
+
+    out = gr.Label(label='Result')
+    clear_button.add(out)
+
+    check_button.click(fn=update_result, inputs=[input_text], outputs=out)
+
+    input_text.change(count_words, input_text, wc, show_progress=False)
+    input_text.input(
+        active_button,
+        [input_text],
+        [check_button],
+    )
+
+    clear_button.click(
+        clear_inputs,
+        inputs=[],
+        outputs=[input_text, check_button],
+    )
+
+demo.launch(share=False)

pipeline/dataset.py

@@ -0,0 +1,38 @@
+import json
+import pandas as pd
+from datasets import Dataset, DatasetDict
+from sklearn.model_selection import train_test_split
+
+
+def read_json(file_name):
+    with open(file_name, 'r') as file:
+        return [json.loads(line) for line in file]
+
+def json_dataset_parser(jsons_list, labels_dict):
+    data_dict = {"text": [], "labels": []}
+    for obj in jsons_list:
+        data_dict["text"].append(obj["text"])
+        data_dict["labels"].append(labels_dict[obj["label"]])
+    return pd.DataFrame(data_dict)
+
+def prepare_dataset(file_path, labels_dict, test_size=0.15, val_size=0.15, sample_frac=1.0):
+    jsons_list = read_json(file_path)
+    df = json_dataset_parser(jsons_list, labels_dict)
+    df = df.sample(frac=sample_frac).reset_index(drop=True)
+
+    train_val, test = train_test_split(df, test_size=test_size, stratify=df['labels'])
+    train, val = train_test_split(train_val, test_size=val_size/(1-test_size), stratify=train_val['labels'])
+
+    dataset = DatasetDict({
+        'train': Dataset.from_pandas(train),
+        'val': Dataset.from_pandas(val),
+        'test': Dataset.from_pandas(test)
+    })
+    return dataset
+
+
+def save_tokenized_dataset(tokenized_datasets, save_path):
+    tokenized_datasets.save_to_disk(save_path)
+
+def load_tokenized_dataset(load_path):
+    return DatasetDict.load_from_disk(load_path)

pipeline/main.py

@@ -0,0 +1,35 @@
+import argparse
+from model_pipeline import run_training_pipeline 
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run the training pipeline for the model.")
+
+    parser.add_argument('--file_path', type=str, required=True, help='Path to the input dataset file.')
+    parser.add_argument('--out_path', type=str,  default=".", help='Path to the saving model, tokenizer and dataset.')
+    parser.add_argument('--model_name', type=str, required=True, help='Name of the model to be trained.')
+    parser.add_argument('--num_labels', type=int, default=4, help='Number of labels for the classification task.')
+    parser.add_argument('--sample_frac', type=float, default=1.0, help='Fraction of the dataset to sample for training.')
+    parser.add_argument('--num_trials', type=int, default=5, help='Number of trials for hyperparameter search.')
+    parser.add_argument('--num_epochs', type=int, default=5, help='Number of epochs for training.')
+
+    args = parser.parse_args()
+
+    labels_dict = {
+        "human_text": 0,
+        "machine_text": 1,
+    }
+
+    run_training_pipeline(
+        file_path=args.file_path,
+        labels_dict=labels_dict,
+        model_name=args.model_name,
+        num_labels=args.num_labels,
+        sample_frac=args.sample_frac,
+        num_trials=args.num_trials,
+        num_epochs=args.num_epochs,
+        save_dir=args.out_path
+    )
+
+if __name__ == "__main__":
+    main()

pipeline/model_pipeline.py

@@ -0,0 +1,169 @@
+import torch
+import optuna
+import numpy as np
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+from transformers import (
+    AutoTokenizer, AutoModelForSequenceClassification,
+    Trainer, TrainingArguments, EarlyStoppingCallback
+)
+
+from dataset import prepare_dataset, save_tokenized_dataset
+
+'''
+tokenization functions
+'''
+def tokenize_function(examples, tokenizer):
+    return tokenizer(examples['text'], padding='max_length', truncation=True, max_length=512)
+
+def tokenize_and_prepare_dataset(dataset, tokenizer):
+    tokenized_datasets = dataset.map(lambda examples: tokenize_function(examples, tokenizer), batched=True)
+    tokenized_datasets = tokenized_datasets.remove_columns(["text"])
+    tokenized_datasets.set_format("torch")
+    return tokenized_datasets
+
+'''
+training & hyperparamters optimization functions
+'''
+def get_model_and_tokenizer(model_name, num_labels):
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=num_labels)
+    return model, tokenizer
+
+def compute_metrics(eval_pred):
+    predictions, labels = eval_pred
+    predictions = np.argmax(predictions, axis=1)
+    accuracy = accuracy_score(labels, predictions)
+    precision, recall, f1, _ = precision_recall_fscore_support(labels, predictions, average='weighted', zero_division=0)
+    return {
+        'accuracy': accuracy,
+        'f1': f1,
+        'precision': precision,
+        'recall': recall
+    }
+
+def objective(trial, model, tokenized_datasets, max_epochs, metric='eval_f1'):
+    learning_rate = trial.suggest_float("learning_rate", 1e-6, 1e-4, log=True)
+    weight_decay = trial.suggest_float("weight_decay", 1e-7, 1e-1, log=True)
+    epoch = trial.suggest_int("epoch", 1, max_epochs)
+
+    training_args = TrainingArguments(
+        output_dir="./results",
+        eval_strategy="epoch",
+        save_strategy="epoch",
+        learning_rate=learning_rate,
+        num_train_epochs=epoch,
+        weight_decay=weight_decay,
+        per_device_train_batch_size=16,
+        per_device_eval_batch_size=64,
+        load_best_model_at_end=True,
+    )
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_datasets['train'],
+        eval_dataset=tokenized_datasets['val'],
+        compute_metrics=compute_metrics,
+    )
+
+    trainer.train()
+    eval_results = trainer.evaluate()
+    return eval_results[metric]
+
+def train_model(model_name, tokenized_datasets, num_labels, num_trials=5, max_epochs=5):
+    model, _ = get_model_and_tokenizer(model_name, num_labels)
+
+    study = optuna.create_study(direction='maximize')
+    study.optimize(lambda trial: objective(trial, model, tokenized_datasets, max_epochs), n_trials=num_trials)
+
+    print(f"Best hyperparameters for {model_name}:", study.best_params)
+    print(f"Best F1 score for {model_name}:", study.best_value)
+
+    # Train with best hyperparameters
+    best_training_args = TrainingArguments(
+        output_dir=f"./results_{model_name}",
+        num_train_epochs = study.best_params["epoch"],
+        eval_strategy="steps",
+        save_strategy="steps",
+        logging_strategy="steps",
+        learning_rate=study.best_params["learning_rate"],
+        weight_decay=study.best_params["weight_decay"],
+        per_device_train_batch_size=16,
+        per_device_eval_batch_size=64,
+        load_best_model_at_end=True,
+        eval_steps = 500,
+        logging_steps = 500
+    )
+
+    trainer = Trainer(
+        model=model,
+        args=best_training_args,
+        train_dataset=tokenized_datasets['train'],
+        eval_dataset=tokenized_datasets['val'],
+        compute_metrics=compute_metrics,
+    )
+
+    trainer.train()
+    return trainer, model
+
+
+
+'''
+Evaluation
+'''
+
+def evaluate_model(trainer, tokenized_datasets):
+    results = trainer.evaluate(tokenized_datasets['test'])
+    print("Test set results:", results)
+
+    predictions = trainer.predict(tokenized_datasets['test'])
+    preds = torch.argmax(torch.tensor(predictions.predictions), axis=-1).cpu().numpy()
+    true_labels = tokenized_datasets['test']['labels'].numpy()
+
+    accuracy = accuracy_score(true_labels, preds)
+    precision, recall, f1, _ = precision_recall_fscore_support(true_labels, preds, average='weighted')
+
+    print(f"Accuracy: {accuracy}")
+    print(f"F1 Score: {f1}")
+    print(f"Precision: {precision}")
+    print(f"Recall: {recall}")
+
+'''
+model and tokenizer save and load
+'''
+def save_model_and_tokenizer(model, tokenizer, save_path):
+    model.save_pretrained(save_path)
+    tokenizer.save_pretrained(save_path)
+
+def load_model_and_tokenizer(model_name, load_path, num_labels):
+    model = AutoModelForSequenceClassification.from_pretrained(load_path, num_labels=num_labels)
+    tokenizer = AutoTokenizer.from_pretrained(load_path)
+    return model, tokenizer
+
+
+'''
+Integrated pipeling
+'''
+def run_training_pipeline(file_path, labels_dict, model_name, num_labels, sample_frac=1.0, num_trials=5, num_epochs=5, save_dir = "."):
+    # Prepare dataset
+    dataset = prepare_dataset(file_path, labels_dict, sample_frac=sample_frac)
+
+    print(f"Training {model_name}...")
+
+    # Get model and tokenizer
+    model, tokenizer = get_model_and_tokenizer(model_name, num_labels)
+
+    # Tokenize dataset
+    tokenized_datasets = tokenize_and_prepare_dataset(dataset, tokenizer)
+
+    # Save tokenized dataset
+    save_tokenized_dataset(tokenized_datasets, f"{save_dir}/tokenized_{model_name}")
+
+    # Train model
+    trainer, trained_model = train_model(model_name, tokenized_datasets, num_labels, num_trials, num_epochs)
+
+    # Evaluate model
+    evaluate_model(trainer, tokenized_datasets)
+
+    # Save model and tokenizer
+    save_model_and_tokenizer(trained_model, tokenizer, f"{save_dir}/fine_tuned_{model_name}")

requirements.txt

@@ -0,0 +1,7 @@
+transformers==4.30.2
+safetensors==0.3.1
+gradio==3.6.0
+numpy==1.24.3
+httpx==0.23.0
+httpcore==0.15.0
+torch==2.0.1