You can deploy this model and start earning money today!

Views

No views yet

🌟 NeuroBERT-NER Model 🌟

Name: NeuroBERT-NER
Availability: InStock

🚀 Model Details

🌈 Description

The boltuix/NeuroBERT-NER model is a fine-tuned transformer for Named Entity Recognition (NER), built on the boltuix/NeuroBERT-Mini base model. It excels at identifying 36 entity types (e.g., people, places, organizations, dates, money) in English text, making it ideal for applications like information extraction, chatbots, and knowledge graph construction.

Dataset: boltuix/conll2025-ner (143,709 entries, 6.38 MB)
Entity Types: 36 NER tags (18 entity categories with B-/I- tags + O)
Training Examples: ~115,812 | Validation: ~15,680 | Test: ~12,217
Note: Split sizes are approximate and don’t sum to 143,709; verify with dataset analysis.
Domains: News, user-generated content, research corpora
Tasks: Sentence-level and document-level NER
Version: v1.1

Note: The dataset link is a placeholder. Replace with the correct Hugging Face repository URL once available.

🔧 Info

Developer: Boltuix 🧙‍♂️
License: Apache-2.0 📜
Language: English 🇬🇧
Type: Transformer-based Token Classification 🤖
Trained: Before May 28, 2025
Base Model: boltuix/NeuroBERT-Mini
Parameters: ~11M

🔗 Links

Model Repository: boltuix/NeuroBERT-NER (placeholder, update with correct URL)
Dataset: boltuix/conll2025-ner (placeholder, update with correct URL)
Hugging Face Docs: Transformers
Demo: Coming Soon

🎯 Use Cases for NER

🌟 Direct Applications

Information Extraction: Extract names (👤 PERSON), locations (🌍 GPE), and dates (🗓️ DATE) from news, blogs, and reports.
Chatbots & Virtual Assistants: Enhance contextual awareness by recognizing entities in user queries.
Search Enhancement: Power semantic search with entity-based indexing (e.g., “articles mentioning Tokyo in 2025”).
Knowledge Graphs: Build structured graphs linking entities like 🏢 ORG and 👤 PERSON.

🌱 Downstream Tasks

Domain Adaptation: Fine-tune for medical 🩺, legal 📜, or financial 💸 NER.
Multilingual Extensions: Retrain for non-English languages.
Custom Entities: Adapt for finance (e.g., stock tickers), e-commerce (e.g., product SKUs), or other specialized domains.

❌ Limitations

English-Only: Out-of-the-box support is limited to English text.
Domain Bias: Trained on boltuix/conll2025-ner, which may emphasize news and formal text, potentially underperforming on informal, social media, or code-mixed text.
Generalization: May struggle with low-resource or highly contextual entities not well-represented in the dataset.

🛠️ Getting Started

🧪 Inference Code

Use the model for NER with the following Python code:

python

from transformers import AutoTokenizer, AutoModelForTokenClassification
import torch

# Load model and tokenizer
tokenizer = AutoTokenizer.from_pretrained("boltuix/NeuroBERT-NER")
model = AutoModelForTokenClassification.from_pretrained("boltuix/NeuroBERT-NER")

# Input text
text = "Barack Obama visited Microsoft headquarters in Seattle on January 2025."
inputs = tokenizer(text, return_tensors="pt")

# Run inference
with torch.no_grad():
    outputs = model(**inputs)
predictions = outputs.logits.argmax(dim=-1)

# Map predictions to labels
tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
label_map = model.config.id2label
labels = [label_map[p.item()] for p in predictions[0]]

# Print results
for token, label in zip(tokens, labels):
    if token not in tokenizer.all_special_tokens:
        print(f"{token:15} → {label}")

✨ Example Output

Barack          → B-PERSON
Obama           → I-PERSON
visited         → O
Microsoft       → B-ORG
headquarters    → O
in              → O
Seattle         → B-GPE
on              → O
January         → B-DATE
2025            → I-DATE
.               → O

🛠️ Requirements

pip install transformers torch pandas pyarrow

Python: 3.8+
Storage: ~50 MB for model weights
Optional: seqeval for evaluation, cuda for GPU acceleration

🧠 Entity Labels

The model supports 36 NER tags from the boltuix/conll2025-ner dataset, using the BIO tagging scheme:

B-: Beginning of an entity
I-: Inside of an entity
O: Outside of any entity

Tag Name	Purpose	Emoji
O	Outside of any named entity (e.g., "the", "is")	🚫
B-CARDINAL	Beginning of a cardinal number (e.g., "1000")	🔢
B-DATE	Beginning of a date (e.g., "January")	🗓️
B-EVENT	Beginning of an event (e.g., "Olympics")	🎉
B-FAC	Beginning of a facility (e.g., "Eiffel Tower")	🏛️
B-GPE	Beginning of a geopolitical entity (e.g., "Tokyo")	🌍
B-LANGUAGE	Beginning of a language (e.g., "Spanish")	🗣️
B-LAW	Beginning of a law or legal document (e.g., "Constitution")	📜
B-LOC	Beginning of a non-GPE location (e.g., "Pacific Ocean")	🗺️
B-MONEY	Beginning of a monetary value (e.g., "$100")	💸
B-NORP	Beginning of a nationality/religious/political group (e.g., "Democrat")	🏳️
B-ORDINAL	Beginning of an ordinal number (e.g., "first")	🥇
B-ORG	Beginning of an organization (e.g., "Microsoft")	🏢
B-PERCENT	Beginning of a percentage (e.g., "50%")	📊
B-PERSON	Beginning of a person’s name (e.g., "Elon Musk")	👤
B-PRODUCT	Beginning of a product (e.g., "iPhone")	📱
B-QUANTITY	Beginning of a quantity (e.g., "two liters")	⚖️
B-TIME	Beginning of a time (e.g., "noon")	⏰
B-WORK_OF_ART	Beginning of a work of art (e.g., "Mona Lisa")	🎨
I-CARDINAL	Inside of a cardinal number (e.g., "000" in "1000")	🔢
I-DATE	Inside of a date (e.g., "2025" in "January 2025")	🗓️
I-EVENT	Inside of an event name	🎉
I-FAC	Inside of a facility name	🏛️
I-GPE	Inside of a geopolitical entity	🌍
I-LANGUAGE	Inside of a language name	🗣️
I-LAW	Inside of a legal document title	📜
I-LOC	Inside of a location	🗺️
I-MONEY	Inside of a monetary value	💸
I-NORP	Inside of a NORP entity	🏳️
I-ORDINAL	Inside of an ordinal number	🥇
I-ORG	Inside of an organization name	🏢
I-PERCENT	Inside of a percentage	📊
I-PERSON	Inside of a person’s name	👤
I-PRODUCT	Inside of a product name	📱
I-QUANTITY	Inside of a quantity	⚖️
I-TIME	Inside of a time phrase	⏰
I-WORK_OF_ART	Inside of a work of art title	🎨

Example:
Text: "Microsoft opened in Tokyo on January 2025"
Tags: [B-ORG, O, O, B-GPE, O, B-DATE, I-DATE]

📈 Performance

Evaluated on the boltuix/conll2025-ner test split using seqeval:

Metric	Score
🎯 Precision	0.85
🕸️ Recall	0.87
🎶 F1 Score	0.86
✅ Accuracy	0.92

Note: Scores are based on the test split (~12,217 examples). Performance may vary with different domains or text types.

⚙️ Training Setup

Hardware: NVIDIA GPU
Training Time: ~2 hours
Parameters: ~11M
Optimizer: AdamW (default settings)
Precision: FP32 (no mixed precision)
Batch Size: Not specified (assumed default for transformers)
Learning Rate: Not specified (assumed default for transformers)

🧠 Training the Model

Fine-tune the boltuix/NeuroBERT-Mini model on the boltuix/conll2025-ner dataset to replicate or extend the NeuroBERT-NER model. Below is a step-by-step guide with code.

python

# 🛠️ Step 1: Install required libraries quietly
!pip install transformers datasets tokenizers seqeval pandas pyarrow -q

# 🚫 Step 2: Disable Weights & Biases (WandB)
import os
os.environ["WANDB_MODE"] = "disabled"

# 📚 Step 2: Import necessary libraries
import pandas as pd
import datasets
import numpy as np
from transformers import BertTokenizerFast
from transformers import DataCollatorForTokenClassification
from transformers import AutoModelForTokenClassification
from transformers import TrainingArguments, Trainer
import evaluate
from transformers import pipeline
from collections import defaultdict
import json

# 📥 Step 3: Load the CoNLL-2025 NER dataset from Parquet
parquet_file = "/content/conll2025-ner.parquet"
df = pd.read_parquet(parquet_file)

# 🔍 Step 4: Convert pandas DataFrame to Hugging Face Dataset
conll2025 = datasets.Dataset.from_pandas(df)

# 🔎 Step 5: Inspect the dataset structure
print("Dataset structure:", conll2025)
print("Dataset features:", conll2025.features)
print("First example:", conll2025[0])

# 🏷️ Step 6: Extract unique tags and create mappings
# Since ner_tags are strings, collect all unique tags
all_tags = set()
for example in conll2025:
    all_tags.update(example["ner_tags"])
unique_tags = sorted(list(all_tags))  # Sort for consistency
num_tags = len(unique_tags)
tag2id = {tag: i for i, tag in enumerate(unique_tags)}
id2tag = {i: tag for i, tag in enumerate(unique_tags)}
print("Number of unique tags:", num_tags)
print("Unique tags:", unique_tags)

# 🔧 Step 7: Convert string ner_tags to indices
def convert_tags_to_ids(example):
    example["ner_tags"] = [tag2id[tag] for tag in example["ner_tags"]]
    return example

conll2025 = conll2025.map(convert_tags_to_ids)

# 📊 Step 8: Split dataset based on 'split' column
dataset_dict = {
    "train": conll2025.filter(lambda x: x["split"] == "train"),
    "validation": conll2025.filter(lambda x: x["split"] == "validation"),
    "test": conll2025.filter(lambda x: x["split"] == "test")
}
conll2025 = datasets.DatasetDict(dataset_dict)
print("Split dataset structure:", conll2025)

# 🪙 Step 9: Initialize the tokenizer
tokenizer = BertTokenizerFast.from_pretrained("boltuix/NeuroBERT-Mini")

# 📝 Step 10: Tokenize an example text and inspect
example_text = conll2025["train"][0]
tokenized_input = tokenizer(example_text["tokens"], is_split_into_words=True)
tokens = tokenizer.convert_ids_to_tokens(tokenized_input["input_ids"])
word_ids = tokenized_input.word_ids()
print("Word IDs:", word_ids)
print("Tokenized input:", tokenized_input)
print("Length of ner_tags vs input IDs:", len(example_text["ner_tags"]), len(tokenized_input["input_ids"]))

# 🔄 Step 11: Define function to tokenize and align labels
def tokenize_and_align_labels(examples, label_all_tokens=True):
    """
    Tokenize inputs and align labels for NER tasks.

    Args:
        examples (dict): Dictionary with tokens and ner_tags.
        label_all_tokens (bool): Whether to label all subword tokens.

    Returns:
        dict: Tokenized inputs with aligned labels.
    """
    tokenized_inputs = tokenizer(examples["tokens"], truncation=True, is_split_into_words=True)
    labels = []
    for i, label in enumerate(examples["ner_tags"]):
        word_ids = tokenized_inputs.word_ids(batch_index=i)
        previous_word_idx = None
        label_ids = []
        for word_idx in word_ids:
            if word_idx is None:
                label_ids.append(-100)  # Special tokens get -100
            elif word_idx != previous_word_idx:
                label_ids.append(label[word_idx])  # First token of word gets label
            else:
                label_ids.append(label[word_idx] if label_all_tokens else -100)  # Subwords get label or -100
            previous_word_idx = word_idx
        labels.append(label_ids)
    tokenized_inputs["labels"] = labels
    return tokenized_inputs

# 🧪 Step 12: Test the tokenization and label alignment
q = tokenize_and_align_labels(conll2025["train"][0:1])
print("Tokenized and aligned example:", q)

# 📋 Step 13: Print tokens and their corresponding labels
for token, label in zip(tokenizer.convert_ids_to_tokens(q["input_ids"][0]), q["labels"][0]):
    print(f"{token:_<40} {label}")

# 🔧 Step 14: Apply tokenization to the entire dataset
tokenized_datasets = conll2025.map(tokenize_and_align_labels, batched=True)

# 🤖 Step 15: Initialize the model with the correct number of labels
model = AutoModelForTokenClassification.from_pretrained("boltuix/NeuroBERT-Mini", num_labels=num_tags)

# ⚙️ Step 16: Set up training arguments
args = TrainingArguments(
    "boltuix/bert-ner",
    eval_strategy="epoch", # Changed evaluation_strategy to eval_strategy
    learning_rate=2e-5,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    num_train_epochs=1,
    weight_decay=0.01,
    report_to="none"
)
# 📊 Step 17: Initialize data collator for dynamic padding
data_collator = DataCollatorForTokenClassification(tokenizer)

# 📈 Step 18: Load evaluation metric
metric = evaluate.load("seqeval")

# 🏷️ Step 19: Set label list and test metric computation
label_list = unique_tags
print("Label list:", label_list)
example = conll2025["train"][0]
labels = [label_list[i] for i in example["ner_tags"]]
print("Metric test:", metric.compute(predictions=[labels], references=[labels]))

# 📉 Step 20: Define function to compute evaluation metrics
def compute_metrics(eval_preds):
    """
    Compute precision, recall, F1, and accuracy for NER.

    Args:
        eval_preds (tuple): Predicted logits and true labels.

    Returns:
        dict: Evaluation metrics.
    """
    pred_logits, labels = eval_preds
    pred_logits = np.argmax(pred_logits, axis=2)
    predictions = [
        [label_list[p] for (p, l) in zip(prediction, label) if l != -100]
        for prediction, label in zip(pred_logits, labels)
    ]
    true_labels = [
        [label_list[l] for (p, l) in zip(prediction, label) if l != -100]
        for prediction, label in zip(pred_logits, labels)
    ]
    results = metric.compute(predictions=predictions, references=true_labels)
    return {
        "precision": results["overall_precision"],
        "recall": results["overall_recall"],
        "f1": results["overall_f1"],
        "accuracy": results["overall_accuracy"],
    }

# 🚀 Step 21: Initialize and train the trainer
trainer = Trainer(
    model,
    args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["validation"],
    data_collator=data_collator,
    tokenizer=tokenizer,
    compute_metrics=compute_metrics
)
trainer.train()

# 💾 Step 22: Save the fine-tuned model
model.save_pretrained("boltuix/bert-ner")
tokenizer.save_pretrained("tokenizer")

# 🔗 Step 23: Update model configuration with label mappings
id2label = {str(i): label for i, label in enumerate(label_list)}
label2id = {label: str(i) for i, label in enumerate(label_list)}
config = json.load(open("boltuix/bert-ner/config.json"))
config["id2label"] = id2label
config["label2id"] = label2id
json.dump(config, open("boltuix/bert-ner/config.json", "w"))

# 🔄 Step 24: Load the fine-tuned model
model_fine_tuned = AutoModelForTokenClassification.from_pretrained("boltuix/bert-ner")

# 🛠️ Step 25: Create a pipeline for NER inference
nlp = pipeline("token-classification", model=model_fine_tuned, tokenizer=tokenizer)

# 📝 Step 26: Perform NER on an example sentence
example = "On July 4th, 2023, President Joe Biden visited the United Nations headquarters in New York to deliver a speech about international law and donated $5 million to relief efforts."
ner_results = nlp(example)
print("NER results for first example:", ner_results)

# 📍 Step 27: Perform NER on a property address and format output
example = "This page contains information about the property located at 1275 Kinnear Rd, Columbus, OH, 43212."
ner_results = nlp(example)

# 🧹 Step 28: Process NER results into structured entities
entities = defaultdict(list)
current_entity = ""
current_type = ""

for item in ner_results:
    entity = item["entity"]
    word = item["word"]
    if word.startswith("##"):
        current_entity += word[2:]  # Handle subword tokens
    elif entity.startswith("B-"):
        if current_entity and current_type:
            entities[current_type].append(current_entity.strip())
        current_type = entity[2:].lower()
        current_entity = word
    elif entity.startswith("I-") and entity[2:].lower() == current_type:
        current_entity += " " + word  # Continue same entity
    else:
        if current_entity and current_type:
            entities[current_type].append(current_entity.strip())
        current_entity = ""
        current_type = ""

# Append final entity if exists
if current_entity and current_type:
    entities[current_type].append(current_entity.strip())

# 📤 Step 29: Output the final JSON
final_json = dict(entities)
print("Structured NER output:")
print(json.dumps(final_json, indent=2))

🛠️ Tips

Hyperparameters: Adjust learning_rate (e.g., 1e-5 to 5e-5), batch_size (8-32), or num_train_epochs (2-5) based on performance.
GPU Usage: Enable fp16=True for faster training on NVIDIA GPUs.
Dataset Splits: Verify split sizes with dataset.num_rows to ensure accuracy.
Custom Data: Adapt the preprocessing script for custom NER datasets by updating label_list.

⏱️ Expected Training Time

~2 hours on an NVIDIA GPU (e.g., V100 or A100) for ~115,812 training examples, 3 epochs, batch size 16.
CPU training is possible but may take significantly longer (e.g., 6-12 hours).

🌍 Carbon Impact

Training on a single GPU for ~2 hours emits ~50g CO₂eq (based on ML Impact tool). Use efficient hardware or cloud regions with renewable energy to minimize impact.

🌍 Carbon Impact

Training Location: Local (Boltuix’s base)
Region: Not specified
Emissions: ~50g CO₂eq
Measurement: ML Impact tool

🛠️ Installation

Install dependencies:

pip install transformers torch pandas pyarrow seqeval

Python: 3.8+
Storage: ~50 MB for model, ~6.38 MB for dataset
Optional: NVIDIA CUDA for GPU acceleration

Download Instructions 📥

Model: Access from boltuix/NeuroBERT-NER (placeholder, update with correct URL).
Dataset: Access from boltuix/conll2025-ner (placeholder, update with correct URL).
Load with Hugging Face datasets or pandas.

Note: Model and dataset links are placeholders. Replace with correct Hugging Face URLs once available.

🧪 Evaluation Code

Evaluate the model on your own data:

python

from transformers import AutoTokenizer, AutoModelForTokenClassification
from seqeval.metrics import classification_report
import torch

# Load model and tokenizer
tokenizer = AutoTokenizer.from_pretrained("boltuix/NeuroBERT-NER")
model = AutoModelForTokenClassification.from_pretrained("boltuix/NeuroBERT-NER")

# Sample test data
texts = ["Barack Obama visited Microsoft in Seattle on January 2025."]
true_labels = [["B-PERSON", "I-PERSON", "O", "B-ORG", "O", "B-GPE", "O", "B-DATE", "I-DATE", "O"]]

pred_labels = []

for text in texts:
    inputs = tokenizer(text, return_tensors="pt", is_split_into_words=False, return_attention_mask=True)
    with torch.no_grad():
        outputs = model(**inputs)
    
    predictions = outputs.logits.argmax(dim=-1)[0].cpu().numpy()
    tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
    word_ids = inputs.word_ids(batch_index=0)

    # Align prediction to word level (first token of each word)
    word_preds = []
    previous_word_idx = None
    for idx, word_idx in enumerate(word_ids):
        if word_idx is None or word_idx == previous_word_idx:
            continue  # Skip special tokens and subwords
        label = model.config.id2label[predictions[idx]]
        word_preds.append(label)
        previous_word_idx = word_idx

    pred_labels.append(word_preds)

# Evaluate
print("Predicted:", pred_labels)
print("True     :", true_labels)
print("\n📊 Evaluation Report:\n")
print(classification_report(true_labels, pred_labels))

🌱 Dataset Details

The model was fine-tuned on the boltuix/conll2025-ner dataset:

Entries: 143,709
Size: 6.38 MB (Parquet format)
Columns: split, tokens, ner_tags
Splits: Train (~115,812)
NER Tags: 36 (18 entity types with B-/I- tags + O)
Source: Curated from news, user-generated content, and research corpora
Annotations: Expert-labeled for high accuracy

📊 Visualizing NER Tags

Visualize the tag distribution in boltuix/conll2025-ner. The chart below uses estimated counts, as exact counts are unavailable. Use the Python script to compute actual counts.

Python Script for Actual Counts:

python

import pandas as pd
from collections import Counter
import matplotlib.pyplot as plt

# Load dataset
df = pd.read_parquet("conll2025_ner.parquet")

# Flatten ner_tags
all_tags = [tag for tags in df["ner_tags"] for tag in tags]
tag_counts = Counter(all_tags)

# Plot
plt.figure(figsize=(12, 7))
plt.bar(tag_counts.keys(), tag_counts.values(), color="#36A2EB")
plt.title("CoNLL 2025 NER: Tag Distribution", fontsize=16)
plt.xlabel("NER Tag", fontsize=12)
plt.ylabel("Count", fontsize=12)
plt.xticks(rotation=45, ha="right", fontsize=10)
plt.grid(axis="y", linestyle="--", alpha=0.7)
plt.tight_layout()
plt.savefig("ner_tag_distribution.png")
plt.show()

⚖️ Comparison to Other Models

Model	Dataset	Parameters	F1 Score	Size
NeuroBERT-NER	conll2025-ner	~11M	0.86	~50 MB
BERT-base-NER	CoNLL-2003	~110M	~0.89	~400 MB
DistilBERT-NER	CoNLL-2003	~66M	~0.85	~200 MB
spaCy (en_core_web_lg)	OntoNotes	-	~0.83	~800 MB

Advantages:

Lightweight (~11M parameters, ~50 MB)
High F1 score (0.86) on conll2025-ner
Optimized for real-time inference

🌐 Community and Support

Join the NER community:

📍 Explore the model page (URL TBD, check Hugging Face community at https://huggingface.co/community) 🌟
🛠️ Report issues or contribute at the model repository (URL TBD) 🔧
💬 Discuss on Hugging Face forums: https://huggingface.co/discussions 🗣️
📚 Learn more via Hugging Face Transformers docs 📖
📧 Contact: Boltuix at boltuix@gmail.com

Note: Model and dataset repository URLs are placeholders. Update with correct URLs once available.

✍️ Contact

Author: Boltuix
Email: boltuix@gmail.com
Hugging Face: boltuix

📅 Last Updated

May 28, 2025 — Released v1.1 with fine-tuning on boltuix/conll2025-ner, updated performance metrics, and added training guide.

Get Started Now 🚀