Initial model upload

.gitattributes

@@ -1,35 +1,4 @@
-*.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
+*.safetensors 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

eval_ner.py

@@ -0,0 +1,153 @@
+import argparse
+import os
+from typing import List, Tuple
+
+import torch
+import numpy as np
+from datasets import Dataset
+from transformers import AutoTokenizer, AutoModelForTokenClassification
+from seqeval.metrics import precision_score, recall_score, f1_score, classification_report
+
+
+def read_conll_2col(path: str) -> Tuple[List[List[str]], List[List[str]]]:
+    """Reads 2-column CoNLL (TOKEN TAG) with blank lines between sentences."""
+    toks, labs = [], []
+    all_toks, all_labs = [], []
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.rstrip("\n")
+            if not line:
+                if toks:
+                    all_toks.append(toks)
+                    all_labs.append(labs)
+                    toks, labs = [], []
+                continue
+            parts = line.split()
+            if len(parts) < 2:
+                # tolerate malformed lines
+                continue
+            tok, tag = parts[0], parts[-1]
+            toks.append(tok)
+            labs.append(tag)
+    if toks:
+        all_toks.append(toks)
+        all_labs.append(labs)
+    return all_toks, all_labs
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_dir", type=str, default="outputs/bert-base-cased-timeNER",
+                        help="Path to the fine-tuned model directory (with config.json, tokenizer files, weights).")
+    parser.add_argument("--test_path", type=str, default="data/test.conll",
+                        help="Path to 2-column CoNLL test file.")
+    parser.add_argument("--batch_size", type=int, default=16)
+    parser.add_argument("--max_length", type=int, default=256)
+    args = parser.parse_args()
+
+    assert os.path.exists(args.model_dir), f"Model dir not found: {args.model_dir}"
+    assert os.path.exists(args.test_path), f"Test file not found: {args.test_path}"
+
+    # Load tokenizer & model
+    print(f"Loading model from: {args.model_dir}")
+    tokenizer = AutoTokenizer.from_pretrained(args.model_dir, use_fast=True)
+    model = AutoModelForTokenClassification.from_pretrained(args.model_dir)
+    model.eval()
+
+    # Labels
+    id2label = model.config.id2label
+    label2id = model.config.label2id
+    labels_sorted = [id2label[i] for i in range(len(id2label))]
+    print(f"Model labels: {labels_sorted}")
+
+    # Read test set
+    print(f"Reading test set: {args.test_path}")
+    tokens_list, tags_list = read_conll_2col(args.test_path)
+    num_sents = len(tokens_list)
+    num_tokens = sum(len(s) for s in tokens_list)
+    print(f"Loaded {num_sents} sentences / {num_tokens} tokens")
+
+    # Sanity check: test labels should be subset of model labels
+    uniq_test_labels = sorted({t for seq in tags_list for t in seq})
+    missing = [t for t in uniq_test_labels if t not in label2id]
+    if missing:
+        print(f"⚠️  Warning: test labels not in model: {missing}")
+
+    # Build a simple dataset for batching convenience
+    ds = Dataset.from_dict({"tokens": tokens_list, "ner_tags": tags_list})
+
+    # Device
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device)
+    
+
+    # Evaluation loop (word-piece alignment; label only first subword)
+    all_preds: List[List[str]] = []
+    all_refs: List[List[str]] = []
+
+    # iterate in batches
+    for start in range(0, len(ds), args.batch_size):
+        batch = ds[start : start + args.batch_size]
+        batch_tokens = batch["tokens"]  # List[List[str]]
+        batch_refs = batch["ner_tags"]  # List[List[str]]
+
+        # Tokenize as split words so we can map back using fast tokenizer encodings
+        encodings = tokenizer(
+            batch_tokens,
+            is_split_into_words=True,
+            truncation=True,
+            max_length=args.max_length,
+            return_tensors="pt",
+            padding=True,
+        )
+
+        with torch.no_grad():
+            logits = model(
+                input_ids=encodings["input_ids"].to(device),
+                attention_mask=encodings["attention_mask"].to(device),
+                token_type_ids=encodings.get("token_type_ids", None).to(device) if "token_type_ids" in encodings else None,
+            ).logits  # (bsz, seq_len, num_labels)
+
+        pred_ids = logits.argmax(dim=-1).cpu().numpy()  # (bsz, seq_len)
+
+        # Recover word-level predictions using encodings.word_ids()
+        for i, word_labels in enumerate(batch_refs):
+            encoding = encodings.encodings[i]  # fast tokenizer encoding
+            word_ids = encoding.word_ids  # list[Optional[int]] aligned to tokens
+            seq_pred_ids = pred_ids[i]
+
+            word_level_preds: List[str] = []
+            seen_word = None
+            for tok_idx, wid in enumerate(word_ids):
+                if wid is None:
+                    continue
+                if wid != seen_word:
+                    # first subword of this word → take prediction
+                    label_id = int(seq_pred_ids[tok_idx])
+                    word_level_preds.append(id2label[label_id])
+                    seen_word = wid
+                else:
+                    # subsequent subwords → skip (standard NER eval)
+                    continue
+
+            # Trim to same length as references (in case of truncation)
+            L = min(len(word_labels), len(word_level_preds))
+            all_refs.append(word_labels[:L])
+            all_preds.append(word_level_preds[:L])
+
+    # Metrics
+    p = precision_score(all_refs, all_preds)
+    r = recall_score(all_refs, all_preds)
+    f1 = f1_score(all_refs, all_preds)
+
+    print("\n Results on test set")
+    print(f"Precision: {p:.4f}")
+    print(f"Recall   : {r:.4f}")
+    print(f"F1       : {f1:.4f}")
+
+    print("\nSeqeval classification report")
+    print(classification_report(all_refs, all_preds, digits=4))
+
+
+if __name__ == "__main__":
+    main()

outputs/bert-base-cased-timeNER/$null

@@ -0,0 +1 @@
+Could Not Find C:\Users\ASUS_GAMER\Desktop\time-ner\outputs\bert-base-cased-timeNER\scheduler.pt

outputs/bert-base-cased-timeNER/.gitattributes

@@ -0,0 +1,3 @@
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text

outputs/bert-base-cased-timeNER/config.json

@@ -0,0 +1,35 @@
+{
+  "architectures": [
+    "BertForTokenClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "O",
+    "1": "B-T",
+    "2": "I-T"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "B-T": 1,
+    "I-T": 2,
+    "O": 0
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "torch_dtype": "float32",
+  "transformers_version": "4.55.2",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 28996
+}

outputs/bert-base-cased-timeNER/model.safetensors

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

outputs/bert-base-cased-timeNER/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

outputs/bert-base-cased-timeNER/tokenizer_config.json

@@ -0,0 +1,56 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "[CLS]",
+  "do_lower_case": false,
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}

outputs/bert-base-cased-timeNER/training_args.bin

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

requirements.txt

@@ -0,0 +1,4 @@
+transformers>=4.42.0
+datasets>=2.19.0
+torch>=2.1.0
+accelerate>=0.31.0

train.py

@@ -0,0 +1,175 @@
+import os
+import argparse
+import random
+from typing import List, Tuple
+
+import numpy as np
+import torch
+from datasets import Dataset
+from transformers import (
+    AutoTokenizer,
+    AutoModelForTokenClassification,
+    DataCollatorForTokenClassification,
+    TrainingArguments,
+    Trainer,
+)
+
+
+def set_seed(seed: int = 42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+def read_conll_2col(path: str) -> Tuple[List[List[str]], List[List[str]]]:
+    """
+    Reads a 2-column CoNLL file:
+        TOKEN TAG
+    Blank line separates sentences.
+    Returns (tokens_per_sentence, tags_per_sentence).
+    """
+    toks, labs = [], []
+    all_toks, all_labs = [], []
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.rstrip("\n")
+            if not line:
+                if toks:
+                    all_toks.append(toks)
+                    all_labs.append(labs)
+                    toks, labs = [], []
+                continue
+            parts = line.split()
+            if len(parts) < 2:
+                # tolerate malformed lines
+                continue
+            tok, tag = parts[0], parts[-1]
+            toks.append(tok)
+            labs.append(tag)
+    if toks:
+        all_toks.append(toks)
+        all_labs.append(labs)
+    return all_toks, all_labs
+
+def build_label_maps(tags: List[List[str]]):
+    """
+    Build label list & maps from training tags only.
+    Ensures 'O' is index 0 for convenience.
+    """
+    uniq = set()
+    for seq in tags:
+        uniq.update(seq)
+    labels = ["O"] + sorted([x for x in uniq if x != "O"])
+    label2id = {l: i for i, l in enumerate(labels)}
+    id2label = {i: l for l, i in label2id.items()}
+    return labels, label2id, id2label
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--train_path", type=str, default="data/train.conll")
+    parser.add_argument("--output_dir", type=str, default="outputs/bert-base-cased-timeNER")
+    parser.add_argument("--model_name", type=str, default="bert-base-cased",
+                        help="Backbone (paper used BERT base cased).")
+    parser.add_argument("--epochs", type=int, default=3)
+    parser.add_argument("--lr", type=float, default=5e-5)
+    parser.add_argument("--batch_size", type=int, default=16)
+    parser.add_argument("--max_length", type=int, default=256,
+                        help="Increase to 512 for longer sentences if needed.")
+    parser.add_argument("--label_all_tokens", action="store_true",
+                        help="If set, label all wordpieces; default labels only first subword.")
+    parser.add_argument("--seed", type=int, default=42)
+    args = parser.parse_args()
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    set_seed(args.seed)
+
+    # 1) Load training data
+    tokens, tags = read_conll_2col(args.train_path)
+    labels, label2id, id2label = build_label_maps(tags)
+    print(f"Labels: {labels}")
+
+    # 2) Hugging Face tokenizer/model
+    tokenizer = AutoTokenizer.from_pretrained(args.model_name, use_fast=True)
+    model = AutoModelForTokenClassification.from_pretrained(
+        args.model_name,
+        num_labels=len(labels),
+        id2label=id2label,
+        label2id=label2id,
+    )
+
+    # 3) Build Dataset
+    ds_train = Dataset.from_dict({"tokens": tokens, "ner_tags": tags})
+
+    def encode_batch(batch):
+        tokenized = tokenizer(
+            batch["tokens"],
+            is_split_into_words=True,
+            truncation=True,
+            max_length=args.max_length,
+        )
+        aligned_labels = []
+        for i, word_labels in enumerate(batch["ner_tags"]):
+            word_ids = tokenized.word_ids(batch_index=i)
+            prev_word = None
+            label_ids = []
+            for wid in word_ids:
+                if wid is None:
+                    label_ids.append(-100)  # ignore in loss
+                elif wid != prev_word:
+                    label_ids.append(label2id[word_labels[wid]])
+                else:
+                    # subword piece
+                    if args.label_all_tokens:
+                        # Optional: convert B- to I- for subsequent pieces if using BIO
+                        lab = word_labels[wid]
+                        if lab.startswith("B-"):
+                            lab = "I-" + lab[2:]
+                        label_ids.append(label2id.get(lab, label2id[word_labels[wid]]))
+                    else:
+                        label_ids.append(-100)
+                prev_word = wid
+            aligned_labels.append(label_ids)
+        tokenized["labels"] = aligned_labels
+        return tokenized
+
+    ds_train = ds_train.map(encode_batch, batched=True, remove_columns=["tokens", "ner_tags"])
+
+    # 4) TrainingArguments (no eval)
+    training_args = TrainingArguments(
+        output_dir=args.output_dir,
+        num_train_epochs=args.epochs,
+        learning_rate=args.lr,
+        per_device_train_batch_size=args.batch_size,
+        per_device_eval_batch_size=args.batch_size,
+        warmup_ratio=0.06,
+        weight_decay=0.01,
+        logging_steps=50,
+        save_steps=1000,                 # adjust to your dataset size
+        save_total_limit=2,
+        fp16=torch.cuda.is_available(),
+        report_to="none",
+        gradient_accumulation_steps=1,
+        seed=args.seed,
+    )
+
+    data_collator = DataCollatorForTokenClassification(tokenizer)
+
+    # 5) Train
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=ds_train,
+        tokenizer=tokenizer,
+        data_collator=data_collator,
+    )
+
+    trainer.train()
+
+    # 6) Save final model (for reuse in attacks)
+    trainer.save_model(args.output_dir)
+    tokenizer.save_pretrained(args.output_dir)
+    
+
+if __name__ == "__main__":
+    main()

upload_model.py

@@ -0,0 +1,45 @@
+# pip install --upgrade huggingface_hub
+from huggingface_hub import login, create_repo, upload_folder, HfApi
+
+# === EDIT THESE IF NEEDED ===
+REPO_ID = "mdg-nlp/updated-time-ner-bert-base-cased"  # target HF repo
+LOCAL_OUTPUTS = r"C:\Users\ASUS_GAMER\Desktop\time-ner\updated-time-ner-bert-base-cased\outputs"  # local folder to upload
+USE_DATASETS_SECTION = False  # set True if this repo should be under "Datasets"
+# ============================
+
+repo_type = "dataset" if USE_DATASETS_SECTION else "model"
+
+# 1) Auth (or use: login(token="hf_..."))
+login()
+
+# 2) Ensure repo exists
+create_repo(repo_id=REPO_ID, repo_type=repo_type, exist_ok=True)
+
+# 3) Force re-upload LOCAL_OUTPUTS -> repo path "outputs"
+#    delete=True removes remote /outputs first so it exactly mirrors your local folder.
+print("Uploading. This may take a while for large .safetensors/.bin files...")
+upload_folder(
+    folder_path=LOCAL_OUTPUTS,
+    repo_id=REPO_ID,
+    repo_type=repo_type,
+    path_in_repo="outputs",
+    commit_message="Force re-upload of outputs (weights + tokenizer)",
+    delete=True,
+    # If you want to limit what gets uploaded, uncomment:
+    # allow_patterns=["*.safetensors", "*.bin", "*.json", "*.txt", "*.model", "*.vocab", "*.merges"],
+    # ignore_patterns=["checkpoint*/", "runs/", "logs/", "*.tmp"],
+)
+
+print("✅ Upload complete.")
+
+# 4) Verify by listing files now on the repo under /outputs
+api = HfApi()
+files = api.list_repo_files(REPO_ID, repo_type=repo_type, revision="main")
+outputs_files = [f for f in files if f.startswith("outputs/")]
+
+print("\nRemote files under /outputs:")
+for f in outputs_files:
+    print(" -", f)
+
+if not outputs_files:
+    print("⚠️ No files found under /outputs on the remote. Double-check LOCAL_OUTPUTS path and permissions.")