Upload 55 files

.gitattributes

@@ -58,3 +58,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/raw/jigsaw_train_hate_annotationprob.csv filter=lfs diff=lfs merge=lfs -text
+data/raw/News_Category_Dataset_v2.json filter=lfs diff=lfs merge=lfs -text

data/.gitignore

@@ -0,0 +1 @@
+processed/

data/finetune_distilbert.py

@@ -0,0 +1,186 @@
+import os
+import json
+import torch
+import pandas as pd
+import numpy as np
+from datasets import Dataset
+from transformers import (
+    DistilBertTokenizer,
+    DistilBertForSequenceClassification,
+    Trainer,
+    TrainingArguments,
+    DataCollatorWithPadding
+)
+from sklearn.preprocessing import LabelEncoder
+import warnings
+warnings.filterwarnings('ignore')
+
+# Set random seeds for reproducibility
+np.random.seed(42)
+torch.manual_seed(42)
+
+print("=" * 60)
+print("DistilBERT Fine-tuning on News Category Data")
+print("=" * 60)
+
+# Step 1: Load data from local JSON file
+print("\n[1/5] Loading dataset from local file...")
+data_path = './backend/data/raw/News_Category_Dataset_v2.json'
+
+try:
+    # Load JSON file
+    articles = []
+    with open(data_path, 'r') as f:
+        for line in f:
+            articles.append(json.loads(line))
+    
+    df = pd.DataFrame(articles)
+    print(f"✓ Loaded from {data_path}")
+    print(f"  Columns: {list(df.columns)}")
+except FileNotFoundError:
+    print(f"✗ File not found: {data_path}")
+    raise
+except Exception as e:
+    print(f"✗ Error loading file: {e}")
+    raise
+
+# Prepare data
+print(f"  Dataset size: {len(df)} samples")
+
+# Identify text and category columns
+if 'headline' in df.columns:
+    text_col = 'headline'
+else:
+    text_col = df.columns[0]
+
+if 'category' in df.columns:
+    category_col = 'category'
+elif 'Category' in df.columns:
+    category_col = 'Category'
+else:
+    category_col = df.columns[-1]
+
+# Create text column combining headline and description if available
+if 'short_description' in df.columns:
+    df['text'] = df[text_col].fillna('') + " " + df['short_description'].fillna('')
+elif 'description' in df.columns:
+    df['text'] = df[text_col].fillna('') + " " + df['description'].fillna('')
+else:
+    df['text'] = df[text_col].fillna('')
+
+# Use category column
+df['category'] = df[category_col]
+print(f"  Categories found: {df['category'].nunique()}")
+
+# Clean data
+print("\n[2/5] Cleaning data...")
+df = df.dropna(subset=['text', 'category'])
+df = df[df['text'].str.len() > 10]  # Remove very short texts
+df = df[df['category'].str.len() > 0]  # Remove empty categories
+
+# Limit to top categories for faster training (optional)
+top_categories = df['category'].value_counts().head(10).index
+df = df[df['category'].isin(top_categories)]
+
+# Sample data for faster training
+if len(df) > 5000:
+    df = df.sample(n=5000, random_state=42)
+    print(f"  Sampled to 5000 articles")
+
+print(f"✓ Cleaned dataset: {len(df)} samples")
+
+# Encode labels
+print("\n[3/5] Encoding labels...")
+le = LabelEncoder()
+df['label'] = le.fit_transform(df['category'])
+# id2label: index -> category name (string keys for id)
+id2label = {str(i): label for i, label in enumerate(le.classes_)}
+# label2id: category name -> index (string keys for label)
+label2id = {label: i for i, label in enumerate(le.classes_)}
+num_labels = len(le.classes_)
+print(f"✓ {num_labels} categories: {list(le.classes_[:5])}{'...' if num_labels > 5 else ''}")
+
+# Step 2: Split data
+print("\n[4/5] Splitting data (80/20 train/test)...")
+train_size = int(0.8 * len(df))
+train_df = df[:train_size]
+test_df = df[train_size:]
+print(f"✓ Train: {len(train_df)} samples")
+print(f"✓ Test:  {len(test_df)} samples")
+
+# Step 3: Create Hugging Face datasets and tokenize
+print("\n[5/5] Preparing datasets and tokenizing...")
+train_dataset = Dataset.from_pandas(train_df[['text', 'label']])
+test_dataset = Dataset.from_pandas(test_df[['text', 'label']])
+
+tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased')
+
+def tokenize_function(examples):
+    return tokenizer(
+        examples['text'],
+        padding='max_length',
+        truncation=True,
+        max_length=128
+    )
+
+train_tokenized = train_dataset.map(tokenize_function, batched=True, remove_columns=['text'])
+test_tokenized = test_dataset.map(tokenize_function, batched=True, remove_columns=['text'])
+print(f"✓ Tokenization complete")
+
+# Step 4: Fine-tune the model
+print("\n" + "=" * 60)
+print("Fine-tuning DistilBERT...")
+print("=" * 60)
+model = DistilBertForSequenceClassification.from_pretrained(
+    'distilbert-base-uncased',
+    num_labels=num_labels,
+    id2label=id2label,
+    label2id=label2id
+)
+
+training_args = TrainingArguments(
+    output_dir='./models/distilbert_huffpost',
+    num_train_epochs=3,
+    per_device_train_batch_size=16,
+    per_device_eval_batch_size=16,
+    warmup_steps=500,
+    weight_decay=0.01,
+    logging_dir='./logs',
+    logging_steps=100,
+    eval_strategy='epoch',
+    save_strategy='epoch',
+    load_best_model_at_end=True,
+    metric_for_best_model='loss',
+)
+
+data_collator = DataCollatorWithPadding(tokenizer)
+
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_tokenized,
+    eval_dataset=test_tokenized,
+    data_collator=data_collator,
+)
+
+trainer.train()
+
+# Step 5: Save the model
+print("\n" + "=" * 60)
+print("Saving fine-tuned model...")
+model_save_path = './models/distilbert_huffpost_final'
+os.makedirs(model_save_path, exist_ok=True)
+model.save_pretrained(model_save_path)
+tokenizer.save_pretrained(model_save_path)
+print(f"✓ Model saved to: {model_save_path}")
+
+# Save label encoding for later use
+import json
+with open(os.path.join(model_save_path, 'label_mapping.json'), 'w') as f:
+    json.dump({'id2label': {str(k): v for k, v in id2label.items()},
+               'label2id': {k: v for k, v in label2id.items()}}, f)
+print(f"✓ Label mapping saved")
+
+print("\n" + "=" * 60)
+print("Fine-tuning completed successfully!")
+print("=" * 60)

data/load_huffpost.py

@@ -0,0 +1,15 @@
+from datasets import load_dataset
+import pandas as pd
+
+# Load the test split specifically
+ds = load_dataset("khalidalt/HuffPost", split="test", trust_remote_code=True)
+df = ds.to_pandas()
+
+# Garder seulement les colonnes utiles
+df = df[["headline","short_description","category","date"]].dropna()
+df["text"] = df["headline"] + " " + df["short_description"]
+
+print(f"Loaded: {len(df)} articles, {df['category'].nunique()} categories")
+print(df["category"].value_counts().head(10))
+
+df.to_parquet("data/raw/huffpost.parquet", index=False)

data/load_jigsaw.py

@@ -0,0 +1,55 @@
+import os
+
+import pandas as pd
+from datasets import load_dataset
+
+RAW_CSV_PATH = "data/raw/jigsaw_train_hate_annotationprob.csv"
+PARQUET_PATH = "data/raw/jigsaw.parquet"
+HF_COLS = [
+	"comment_text",
+	"toxic",
+	"severe_toxic",
+	"obscene",
+	"threat",
+	"insult",
+	"identity_hate",
+]
+CSV_COLS = [
+	"text",
+	"toxic",
+	"severe_toxic",
+	"obscene",
+	"threat",
+	"insult",
+	"identity_hate",
+]
+
+
+def _load_from_csv() -> pd.DataFrame:
+	df = pd.read_csv(RAW_CSV_PATH)
+	df = df[CSV_COLS].dropna()
+	return df.rename(columns={"text": "comment_text"})
+
+
+def _load_from_hf() -> pd.DataFrame:
+	dataset = load_dataset("jigsaw_toxicity_pred", split="train")
+	dataset = dataset.select_columns(HF_COLS)
+	return dataset.to_pandas().dropna()
+
+
+def main() -> None:
+	if os.path.exists(RAW_CSV_PATH):
+		df = _load_from_csv()
+		source = RAW_CSV_PATH
+	else:
+		df = _load_from_hf()
+		source = "jigsaw_toxicity_pred"
+
+	print(f"Loaded: {len(df)} comments from {source}")
+	print(f"Toxic rate: {df['toxic'].mean():.1%}")
+
+	df.to_parquet(PARQUET_PATH, index=False)
+
+
+if __name__ == "__main__":
+	main()

data/load_reddit.py

@@ -0,0 +1,49 @@
+from datasets import load_dataset
+import pandas as pd
+
+
+def _resolve_score_column(df: pd.DataFrame) -> str | None:
+    for name in ["score", "upvotes", "ups", "upvote_ratio"]:
+        if name in df.columns:
+            return name
+    return None
+
+
+def main() -> None:
+    dataset = load_dataset(
+        "reddit_tifu",
+        "short",
+        split="train",
+        trust_remote_code=True,
+    )
+    df = dataset.to_pandas()
+
+    if "title" not in df.columns:
+        raise ValueError("Missing required column: title")
+
+    if "tldr" not in df.columns:
+        df["tldr"] = ""
+
+    df["text"] = (df["title"].fillna("") + " " + df["tldr"].fillna("")).str.strip()
+    if "subreddit" in df.columns:
+        df["category"] = df["subreddit"]
+    elif "subreddit_name_prefixed" in df.columns:
+        df["category"] = df["subreddit_name_prefixed"]
+    else:
+        df["category"] = "tifu"
+
+    score_col = _resolve_score_column(df)
+    if score_col is None:
+        df["score"] = 0
+    else:
+        df["score"] = df[score_col]
+
+    df = df[df["text"].str.len() >= 20].copy()
+    out_df = df[["text", "category", "score"]]
+
+    out_df.to_parquet("data/raw/reddit.parquet", index=False)
+    print(f"Loaded {len(out_df)} rows, {out_df['category'].nunique()} subreddits")
+
+
+if __name__ == "__main__":
+    main()

data/load_social_media.py

@@ -0,0 +1,9 @@
+import pandas as pd
+
+df = pd.read_csv("data/raw/sentimentdataset.csv")
+# Normaliser les colonnes
+df.columns = [c.strip().lower().replace(" ","_") for c in df.columns]
+print(df.columns.tolist())
+print(df.head(2))
+
+df.to_parquet("data/raw/social_media.parquet", index=False)

data/processed/combined_meta.parquet

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

data/processed/faiss_index.bin

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

data/processed/faiss_index_v2.bin

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

data/processed/faiss_v2_manifest.json

@@ -0,0 +1,8 @@
+{
+  "n_huffpost": 200853,
+  "n_reddit": 74459,
+  "n_total": 275312,
+  "dim": 384,
+  "nlist": 100,
+  "nprobe": 10
+}

data/processed/huffpost_embeddings.npy

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

data/processed/huffpost_with_meta.parquet

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

data/processed/reddit_embeddings.npy

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

data/processed/reddit_meta.parquet

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

data/raw/HuffPost.py

@@ -0,0 +1,129 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""HuffPost Dataset."""
+
+
+import csv
+import json
+import os
+
+import datasets
+
+
+
+_CITATION = """\
+@book{book,
+  author = {Misra, Rishabh and Grover, Jigyasa},
+  year = {2021},
+  month = {01},
+  pages = {},
+  title = {Sculpting Data for ML: The first act of Machine Learning},
+  isbn = {978-0-578-83125-1}
+}
+
+@dataset{dataset,
+  author = {Misra, Rishabh},
+  year = {2018},
+  month = {06},
+  pages = {},
+  title = {News Category Dataset},
+  doi = {10.13140/RG.2.2.20331.18729}
+}
+"""
+
+
+_DESCRIPTION = """\
+A dataset of approximately 200K news headlines from the year 2012 to 2018 collected from HuffPost."""
+
+_HOMEPAGE = "https://www.kaggle.com/datasets/rmisra/news-category-dataset"
+
+_LICENSE = "CC0: Public Domain"
+
+_URLS = "https://huggingface.co/datasets/khalidalt/HuffPost/resolve/main/News_Category_Dataset_v2.json"
+
+
+
+class HuffPost(datasets.GeneratorBasedBuilder):
+    """HuffPost Dataset."""
+
+    VERSION = datasets.Version("1.1.0")
+
+    # This is an example of a dataset with multiple configurations.
+    # If you don't want/need to define several sub-sets in your dataset,
+    # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.
+
+    # If you need to make complex sub-parts in the datasets with configurable options
+    # You can create your own builder configuration class to store attribute, inheriting from datasets.BuilderConfig
+    # BUILDER_CONFIG_CLASS = MyBuilderConfig
+
+    # You will be able to load one or the other configurations in the following list with
+    # data = datasets.load_dataset('my_dataset', 'first_domain')
+    # data = datasets.load_dataset('my_dataset', 'second_domain')
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(name="default", version=VERSION, description="Default config"),
+    ]
+    
+    DEFAULT_CONFIG_NAME = "default"
+
+    def _info(self):
+        
+        features = datasets.Features(
+            {
+                "category": datasets.Value("string"),
+                "headline": datasets.Value("string"),
+                "authors": datasets.Value("string"),
+                "link": datasets.Value("string"),
+                "short_description": datasets.Value("string"),
+                "date": datasets.Value("string"),
+                "label": datasets.ClassLabel(names=["POLITICS","WELLNESS","ENTERTAINMENT","TRAVEL","STYLE & BEAUTY",
+                                                    "PARENTING","HEALTHY LIVING","QUEER VOICES","FOOD & DRINK",
+                                                    "BUSINESS","COMEDY","SPORTS","BLACK VOICES","HOME & LIVING","PARENTS",
+                                                    "THE WORLDPOST","WEDDINGS","WOMEN","IMPACT","DIVORCE","CRIME","MEDIA",
+                                                    "WEIRD NEWS","GREEN","WORLDPOST","RELIGION","STYLE","SCIENCE",
+                                                    "WORLD NEWS","TASTE","TECH","MONEY","ARTS","FIFTY","GOOD NEWS",
+                                                    "ARTS & CULTURE","ENVIRONMENT","COLLEGE","LATINO VOICES","CULTURE & ARTS",
+                                                    "EDUCATION"]),
+            }
+            )
+
+        return datasets.DatasetInfo(
+
+            description=_DESCRIPTION,
+            features=features,  
+            homepage=_HOMEPAGE,
+            # License for the dataset if available
+            license=_LICENSE,
+            # Citation for the dataset
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+
+        data_dir = dl_manager.download_and_extract(_URLS)
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={"filepath": data_dir},
+            ),
+        ]
+
+    # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
+    def _generate_examples(self, filepath):
+        with open(filepath, encoding="utf-8") as f:
+            for key, row in enumerate(f):
+                data = json.loads(row)
+                data['label'] = data['category'] 
+                # Yields examples as (key, example) tuples
+                yield key, data

data/raw/News_Category_Dataset_v2.json

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

data/raw/huffpost.parquet

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

data/raw/jigsaw.parquet

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

data/raw/jigsaw_train_hate_annotationprob.csv

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

data/raw/reddit.parquet

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

data/raw/social_media.parquet

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

data/run_inference_demo.py

@@ -0,0 +1,71 @@
+import json
+from pathlib import Path
+
+import torch
+from torch.nn.functional import softmax
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+
+def load_id2label(model_dir: Path, model: AutoModelForSequenceClassification) -> dict:
+    label_map_path = model_dir / "label_mapping.json"
+    if label_map_path.exists():
+        with label_map_path.open("r", encoding="utf-8") as f:
+            mapping = json.load(f)
+        return {int(k): v for k, v in mapping.get("id2label", {}).items()}
+
+    # Fallback to the model config if a separate mapping is missing.
+    config_map = getattr(model.config, "id2label", {})
+    return {int(k): v for k, v in config_map.items()}
+
+
+def main() -> None:
+    repo_root = Path(__file__).resolve().parents[2]
+    model_dir = repo_root / "models" / "distilbert_huffpost_final"
+
+    if not model_dir.exists():
+        raise FileNotFoundError(f"Model directory not found: {model_dir}")
+
+    tokenizer = AutoTokenizer.from_pretrained(model_dir)
+    model = AutoModelForSequenceClassification.from_pretrained(model_dir)
+    model.eval()
+
+    id2label = load_id2label(model_dir, model)
+
+    texts = [
+        "Just booked a weekend trip to Lisbon and need food recommendations.",
+        "Homemade pasta night with fresh basil and garlic was a win.",
+        "Our kid starts kindergarten next week and we are excited and nervous.",
+        "The new skincare routine finally cleared up my dry patches.",
+        "Company earnings beat expectations and the stock jumped this morning.",
+        "The election debate last night felt chaotic and unproductive.",
+        "Trying to build a healthier sleep routine and cut screen time.",
+        "Weekend hike with friends was refreshing and low key.",
+        "Just watched a hilarious stand-up special and laughed nonstop.",
+        "Looking for tips on keeping a travel budget under control.",
+    ]
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device)
+
+    with torch.no_grad():
+        inputs = tokenizer(
+            texts,
+            return_tensors="pt",
+            padding=True,
+            truncation=True,
+            max_length=128,
+        )
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        logits = model(**inputs).logits
+        probs = softmax(logits, dim=-1)
+
+    for text, prob in zip(texts, probs):
+        topk = torch.topk(prob, k=min(3, prob.numel()))
+        print("\nText:", text)
+        for score, idx in zip(topk.values.tolist(), topk.indices.tolist()):
+            label = id2label.get(idx, f"LABEL_{idx}")
+            print(f"  {label}: {score:.3f}")
+
+
+if __name__ == "__main__":
+    main()

models/distilbert_huffpost/checkpoint-250/config.json

@@ -0,0 +1,52 @@
+{
+  "activation": "gelu",
+  "architectures": [
+    "DistilBertForSequenceClassification"
+  ],
+  "attention_dropout": 0.1,
+  "bos_token_id": null,
+  "dim": 768,
+  "dropout": 0.1,
+  "dtype": "float32",
+  "eos_token_id": null,
+  "hidden_dim": 3072,
+  "id2label": {
+    "0": "BUSINESS",
+    "1": "ENTERTAINMENT",
+    "2": "FOOD & DRINK",
+    "3": "HEALTHY LIVING",
+    "4": "PARENTING",
+    "5": "POLITICS",
+    "6": "QUEER VOICES",
+    "7": "STYLE & BEAUTY",
+    "8": "TRAVEL",
+    "9": "WELLNESS"
+  },
+  "initializer_range": 0.02,
+  "label2id": {
+    "BUSINESS": 0,
+    "ENTERTAINMENT": 1,
+    "FOOD & DRINK": 2,
+    "HEALTHY LIVING": 3,
+    "PARENTING": 4,
+    "POLITICS": 5,
+    "QUEER VOICES": 6,
+    "STYLE & BEAUTY": 7,
+    "TRAVEL": 8,
+    "WELLNESS": 9
+  },
+  "max_position_embeddings": 512,
+  "model_type": "distilbert",
+  "n_heads": 12,
+  "n_layers": 6,
+  "pad_token_id": 0,
+  "problem_type": "single_label_classification",
+  "qa_dropout": 0.1,
+  "seq_classif_dropout": 0.2,
+  "sinusoidal_pos_embds": false,
+  "tie_weights_": true,
+  "tie_word_embeddings": true,
+  "transformers_version": "5.6.2",
+  "use_cache": false,
+  "vocab_size": 30522
+}

models/distilbert_huffpost/checkpoint-250/model.safetensors

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

models/distilbert_huffpost/checkpoint-250/optimizer.pt

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

models/distilbert_huffpost/checkpoint-250/rng_state.pth

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

models/distilbert_huffpost/checkpoint-250/scheduler.pt

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

models/distilbert_huffpost/checkpoint-250/tokenizer_config.json

@@ -0,0 +1,15 @@
+{
+  "backend": "tokenizers",
+  "cls_token": "[CLS]",
+  "do_lower_case": true,
+  "is_local": false,
+  "local_files_only": false,
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "DistilBertTokenizer",
+  "unk_token": "[UNK]"
+}

models/distilbert_huffpost/checkpoint-250/trainer_state.json

@@ -0,0 +1,56 @@
+{
+  "best_global_step": 250,
+  "best_metric": 0.963435173034668,
+  "best_model_checkpoint": "./models/distilbert_huffpost/checkpoint-250",
+  "epoch": 1.0,
+  "eval_steps": 500,
+  "global_step": 250,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 0.4,
+      "grad_norm": 3.125596284866333,
+      "learning_rate": 9.900000000000002e-06,
+      "loss": 2.199267578125,
+      "step": 100
+    },
+    {
+      "epoch": 0.8,
+      "grad_norm": 7.727860450744629,
+      "learning_rate": 1.9900000000000003e-05,
+      "loss": 1.5030784606933594,
+      "step": 200
+    },
+    {
+      "epoch": 1.0,
+      "eval_loss": 0.963435173034668,
+      "eval_runtime": 67.1554,
+      "eval_samples_per_second": 14.891,
+      "eval_steps_per_second": 0.938,
+      "step": 250
+    }
+  ],
+  "logging_steps": 100,
+  "max_steps": 750,
+  "num_input_tokens_seen": 0,
+  "num_train_epochs": 3,
+  "save_steps": 500,
+  "stateful_callbacks": {
+    "TrainerControl": {
+      "args": {
+        "should_epoch_stop": false,
+        "should_evaluate": false,
+        "should_log": false,
+        "should_save": true,
+        "should_training_stop": false
+      },
+      "attributes": {}
+    }
+  },
+  "total_flos": 132486297600000.0,
+  "train_batch_size": 16,
+  "trial_name": null,
+  "trial_params": null
+}

models/distilbert_huffpost/checkpoint-250/training_args.bin

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

models/distilbert_huffpost/checkpoint-500/config.json

@@ -0,0 +1,52 @@
+{
+  "activation": "gelu",
+  "architectures": [
+    "DistilBertForSequenceClassification"
+  ],
+  "attention_dropout": 0.1,
+  "bos_token_id": null,
+  "dim": 768,
+  "dropout": 0.1,
+  "dtype": "float32",
+  "eos_token_id": null,
+  "hidden_dim": 3072,
+  "id2label": {
+    "0": "BUSINESS",
+    "1": "ENTERTAINMENT",
+    "2": "FOOD & DRINK",
+    "3": "HEALTHY LIVING",
+    "4": "PARENTING",
+    "5": "POLITICS",
+    "6": "QUEER VOICES",
+    "7": "STYLE & BEAUTY",
+    "8": "TRAVEL",
+    "9": "WELLNESS"
+  },
+  "initializer_range": 0.02,
+  "label2id": {
+    "BUSINESS": 0,
+    "ENTERTAINMENT": 1,
+    "FOOD & DRINK": 2,
+    "HEALTHY LIVING": 3,
+    "PARENTING": 4,
+    "POLITICS": 5,
+    "QUEER VOICES": 6,
+    "STYLE & BEAUTY": 7,
+    "TRAVEL": 8,
+    "WELLNESS": 9
+  },
+  "max_position_embeddings": 512,
+  "model_type": "distilbert",
+  "n_heads": 12,
+  "n_layers": 6,
+  "pad_token_id": 0,
+  "problem_type": "single_label_classification",
+  "qa_dropout": 0.1,
+  "seq_classif_dropout": 0.2,
+  "sinusoidal_pos_embds": false,
+  "tie_weights_": true,
+  "tie_word_embeddings": true,
+  "transformers_version": "5.6.2",
+  "use_cache": false,
+  "vocab_size": 30522
+}

models/distilbert_huffpost/checkpoint-500/model.safetensors

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

models/distilbert_huffpost/checkpoint-500/optimizer.pt

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

models/distilbert_huffpost/checkpoint-500/rng_state.pth

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

models/distilbert_huffpost/checkpoint-500/scheduler.pt

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

models/distilbert_huffpost/checkpoint-500/tokenizer_config.json

@@ -0,0 +1,15 @@
+{
+  "backend": "tokenizers",
+  "cls_token": "[CLS]",
+  "do_lower_case": true,
+  "is_local": false,
+  "local_files_only": false,
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "DistilBertTokenizer",
+  "unk_token": "[UNK]"
+}

models/distilbert_huffpost/checkpoint-500/trainer_state.json

@@ -0,0 +1,85 @@
+{
+  "best_global_step": 500,
+  "best_metric": 0.7529695630073547,
+  "best_model_checkpoint": "./models/distilbert_huffpost/checkpoint-500",
+  "epoch": 2.0,
+  "eval_steps": 500,
+  "global_step": 500,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 0.4,
+      "grad_norm": 3.125596284866333,
+      "learning_rate": 9.900000000000002e-06,
+      "loss": 2.199267578125,
+      "step": 100
+    },
+    {
+      "epoch": 0.8,
+      "grad_norm": 7.727860450744629,
+      "learning_rate": 1.9900000000000003e-05,
+      "loss": 1.5030784606933594,
+      "step": 200
+    },
+    {
+      "epoch": 1.0,
+      "eval_loss": 0.963435173034668,
+      "eval_runtime": 67.1554,
+      "eval_samples_per_second": 14.891,
+      "eval_steps_per_second": 0.938,
+      "step": 250
+    },
+    {
+      "epoch": 1.2,
+      "grad_norm": 10.762837409973145,
+      "learning_rate": 2.9900000000000002e-05,
+      "loss": 0.8936661529541016,
+      "step": 300
+    },
+    {
+      "epoch": 1.6,
+      "grad_norm": 12.36496353149414,
+      "learning_rate": 3.99e-05,
+      "loss": 0.7169620513916015,
+      "step": 400
+    },
+    {
+      "epoch": 2.0,
+      "grad_norm": 15.652347564697266,
+      "learning_rate": 4.99e-05,
+      "loss": 0.6252112197875976,
+      "step": 500
+    },
+    {
+      "epoch": 2.0,
+      "eval_loss": 0.7529695630073547,
+      "eval_runtime": 204.5829,
+      "eval_samples_per_second": 4.888,
+      "eval_steps_per_second": 0.308,
+      "step": 500
+    }
+  ],
+  "logging_steps": 100,
+  "max_steps": 750,
+  "num_input_tokens_seen": 0,
+  "num_train_epochs": 3,
+  "save_steps": 500,
+  "stateful_callbacks": {
+    "TrainerControl": {
+      "args": {
+        "should_epoch_stop": false,
+        "should_evaluate": false,
+        "should_log": false,
+        "should_save": true,
+        "should_training_stop": false
+      },
+      "attributes": {}
+    }
+  },
+  "total_flos": 264972595200000.0,
+  "train_batch_size": 16,
+  "trial_name": null,
+  "trial_params": null
+}

models/distilbert_huffpost/checkpoint-500/training_args.bin

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

models/distilbert_huffpost/checkpoint-750/config.json

@@ -0,0 +1,52 @@
+{
+  "activation": "gelu",
+  "architectures": [
+    "DistilBertForSequenceClassification"
+  ],
+  "attention_dropout": 0.1,
+  "bos_token_id": null,
+  "dim": 768,
+  "dropout": 0.1,
+  "dtype": "float32",
+  "eos_token_id": null,
+  "hidden_dim": 3072,
+  "id2label": {
+    "0": "BUSINESS",
+    "1": "ENTERTAINMENT",
+    "2": "FOOD & DRINK",
+    "3": "HEALTHY LIVING",
+    "4": "PARENTING",
+    "5": "POLITICS",
+    "6": "QUEER VOICES",
+    "7": "STYLE & BEAUTY",
+    "8": "TRAVEL",
+    "9": "WELLNESS"
+  },
+  "initializer_range": 0.02,
+  "label2id": {
+    "BUSINESS": 0,
+    "ENTERTAINMENT": 1,
+    "FOOD & DRINK": 2,
+    "HEALTHY LIVING": 3,
+    "PARENTING": 4,
+    "POLITICS": 5,
+    "QUEER VOICES": 6,
+    "STYLE & BEAUTY": 7,
+    "TRAVEL": 8,
+    "WELLNESS": 9
+  },
+  "max_position_embeddings": 512,
+  "model_type": "distilbert",
+  "n_heads": 12,
+  "n_layers": 6,
+  "pad_token_id": 0,
+  "problem_type": "single_label_classification",
+  "qa_dropout": 0.1,
+  "seq_classif_dropout": 0.2,
+  "sinusoidal_pos_embds": false,
+  "tie_weights_": true,
+  "tie_word_embeddings": true,
+  "transformers_version": "5.6.2",
+  "use_cache": false,
+  "vocab_size": 30522
+}

models/distilbert_huffpost/checkpoint-750/model.safetensors

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

models/distilbert_huffpost/checkpoint-750/optimizer.pt

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

models/distilbert_huffpost/checkpoint-750/rng_state.pth

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

models/distilbert_huffpost/checkpoint-750/scheduler.pt

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

models/distilbert_huffpost/checkpoint-750/tokenizer_config.json

@@ -0,0 +1,15 @@
+{
+  "backend": "tokenizers",
+  "cls_token": "[CLS]",
+  "do_lower_case": true,
+  "is_local": false,
+  "local_files_only": false,
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "DistilBertTokenizer",
+  "unk_token": "[UNK]"
+}

models/distilbert_huffpost/checkpoint-750/trainer_state.json

@@ -0,0 +1,107 @@
+{
+  "best_global_step": 750,
+  "best_metric": 0.7524415254592896,
+  "best_model_checkpoint": "./models/distilbert_huffpost/checkpoint-750",
+  "epoch": 3.0,
+  "eval_steps": 500,
+  "global_step": 750,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 0.4,
+      "grad_norm": 3.125596284866333,
+      "learning_rate": 9.900000000000002e-06,
+      "loss": 2.199267578125,
+      "step": 100
+    },
+    {
+      "epoch": 0.8,
+      "grad_norm": 7.727860450744629,
+      "learning_rate": 1.9900000000000003e-05,
+      "loss": 1.5030784606933594,
+      "step": 200
+    },
+    {
+      "epoch": 1.0,
+      "eval_loss": 0.963435173034668,
+      "eval_runtime": 67.1554,
+      "eval_samples_per_second": 14.891,
+      "eval_steps_per_second": 0.938,
+      "step": 250
+    },
+    {
+      "epoch": 1.2,
+      "grad_norm": 10.762837409973145,
+      "learning_rate": 2.9900000000000002e-05,
+      "loss": 0.8936661529541016,
+      "step": 300
+    },
+    {
+      "epoch": 1.6,
+      "grad_norm": 12.36496353149414,
+      "learning_rate": 3.99e-05,
+      "loss": 0.7169620513916015,
+      "step": 400
+    },
+    {
+      "epoch": 2.0,
+      "grad_norm": 15.652347564697266,
+      "learning_rate": 4.99e-05,
+      "loss": 0.6252112197875976,
+      "step": 500
+    },
+    {
+      "epoch": 2.0,
+      "eval_loss": 0.7529695630073547,
+      "eval_runtime": 204.5829,
+      "eval_samples_per_second": 4.888,
+      "eval_steps_per_second": 0.308,
+      "step": 500
+    },
+    {
+      "epoch": 2.4,
+      "grad_norm": 10.981303215026855,
+      "learning_rate": 3.02e-05,
+      "loss": 0.3609377670288086,
+      "step": 600
+    },
+    {
+      "epoch": 2.8,
+      "grad_norm": 9.517579078674316,
+      "learning_rate": 1.02e-05,
+      "loss": 0.35755828857421873,
+      "step": 700
+    },
+    {
+      "epoch": 3.0,
+      "eval_loss": 0.7524415254592896,
+      "eval_runtime": 88.3806,
+      "eval_samples_per_second": 11.315,
+      "eval_steps_per_second": 0.713,
+      "step": 750
+    }
+  ],
+  "logging_steps": 100,
+  "max_steps": 750,
+  "num_input_tokens_seen": 0,
+  "num_train_epochs": 3,
+  "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": 397458892800000.0,
+  "train_batch_size": 16,
+  "trial_name": null,
+  "trial_params": null
+}