Neurobert

🚀 NeuroBERT — The Brain of Lightweight NLP for Real-World Intelligence

NeuroBERT is an advanced lightweight NLP model. It's derived from google/bert - base - uncased and optimized for real - time inference on resource - constrained devices. With a quantized size of about 57MB and around 30M parameters, it offers powerful contextual language understanding for real - world applications in mobile apps, wearables, microcontrollers, and smart home devices. It's suitable for privacy - first applications with limited connectivity, providing robust intent detection, classification, and semantic understanding.

🚀 Quick Start

Installation

Install the required dependencies:

pip install transformers torch

Ensure your environment supports Python 3.6+ and has about 57MB of storage for model weights.

Download the Model

Via Hugging Face

• Access the model at boltuix/NeuroBERT.
• Download the model files (about 57MB) or clone the repository:

git clone https://huggingface.co/boltuix/NeuroBERT

Via Transformers Library

Load the model directly in Python:

from transformers import AutoModelForMaskedLM, AutoTokenizer
model = AutoModelForMaskedLM.from_pretrained("boltuix/NeuroBERT")
tokenizer = AutoTokenizer.from_pretrained("boltuix/NeuroBERT")

Manual Download

Download quantized model weights from the Hugging Face model hub. Extract and integrate into your edge/IoT application.

Quickstart Examples

Masked Language Modeling

Predict missing words in IoT - related sentences with masked language modeling:

from transformers import pipeline

# Unleash the power
mlm_pipeline = pipeline("fill - mask", model="boltuix/NeuroBERT")

# Test the magic
result = mlm_pipeline("Please [MASK] the door before leaving.")
print(result[0]["sequence"])  # Output: "Please open the door before leaving."

Text Classification

Perform intent detection or text classification for IoT commands:

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load tokenizer and classification model
model_name = "boltuix/NeuroBERT"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name)
model.eval()

# Example input
text = "Turn on the fan"

# Tokenize the input
inputs = tokenizer(text, return_tensors="pt")

# Get prediction
with torch.no_grad():
    outputs = model(**inputs)
    probs = torch.softmax(outputs.logits, dim=1)
    pred = torch.argmax(probs, dim=1).item()

# Define labels
labels = ["OFF", "ON"]

# Print result
print(f"Text: {text}")
print(f"Predicted intent: {labels[pred]} (Confidence: {probs[0][pred]:.4f})")

Output:

Text: Turn on the fan
Predicted intent: ON (Confidence: 0.7824)

Note: Fine - tune the model for specific classification tasks to improve accuracy.

✨ Features

• Lightweight Powerhouse: With a footprint of about 57MB, it fits devices with constrained storage while offering advanced NLP capabilities.
• Deep Contextual Understanding: Captures complex semantic relationships with an 8 - layer architecture.
• Offline Capability: Fully functional without internet access.
• Real - Time Inference: Optimized for CPUs, mobile NPUs, and microcontrollers.
• Versatile Applications: Excels in masked language modeling (MLM), intent detection, text classification, and named entity recognition (NER).

📚 Documentation

Evaluation

NeuroBERT was evaluated on a masked language modeling task using 10 IoT - related sentences. The model predicts the top - 5 tokens for each masked word, and a test passes if the expected word is in the top - 5 predictions.

Test Sentences

Evaluation Code

from transformers import AutoTokenizer, AutoModelForMaskedLM
import torch

# Load model and tokenizer
model_name = "boltuix/NeuroBERT"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForMaskedLM.from_pretrained(model_name)
model.eval()

# Test data
tests = [
    ("She is a [MASK] at the local hospital.", "nurse"),
    ("Please [MASK] the door before leaving.", "shut"),
    ("The drone collects data using onboard [MASK].", "sensors"),
    ("The fan will turn [MASK] when the room is empty.", "off"),
    ("Turn [MASK] the coffee machine at 7 AM.", "on"),
    ("The hallway light switches on during the [MASK].", "night"),
    ("The air purifier turns on due to poor [MASK] quality.", "air"),
    ("The AC will not run if the door is [MASK].", "open"),
    ("Turn off the lights after [MASK] minutes.", "five"),
    ("The music pauses when someone [MASK] the room.", "enters")
]

results = []

# Run tests
for text, answer in tests:
    inputs = tokenizer(text, return_tensors="pt")
    mask_pos = (inputs.input_ids == tokenizer.mask_token_id).nonzero(as_tuple=True)[1]
    with torch.no_grad():
        outputs = model(**inputs)
    logits = outputs.logits[0, mask_pos, :]
    topk = logits.topk(5, dim=1)
    top_ids = topk.indices[0]
    top_scores = torch.softmax(topk.values, dim=1)[0]
    guesses = [(tokenizer.decode([i]).strip().lower(), float(score)) for i, score in zip(top_ids, top_scores)]
    results.append({
        "sentence": text,
        "expected": answer,
        "predictions": guesses,
        "pass": answer.lower() in [g[0] for g in guesses]
    })

# Print results
for r in results:
    status = "PASS" if r["pass"] else "FAIL"
    print(f"\n{r['sentence']}")
    print(f"Expected: {r['expected']}")
    print("Top - 5 Predictions (word : confidence):")
    for word, score in r['predictions']:
        print(f"   - {word:12} | {score:.4f}")
    print(status)

# Summary
pass_count = sum(r["pass"] for r in results)
print(f"\nTotal Passed: {pass_count}/{len(tests)}")

Sample Results (Hypothetical)

• Sentence: She is a [MASK] at the local hospital.
  Expected: nurse
  Top - 5: [nurse (0.45), doctor (0.25), surgeon (0.15), technician (0.10), assistant (0.05)]
  Result: PASS
• Sentence: Turn off the lights after [MASK] minutes.
  Expected: five
  Top - 5: [five (0.35), ten (0.30), three (0.15), fifteen (0.15), two (0.05)]
  Result: PASS
• Total Passed: ~9/10 (depends on fine - tuning).

NeuroBERT excels in IoT contexts (e.g., "sensors", "off", "open") and demonstrates strong performance on challenging terms like "five", benefiting from its deeper 8 - layer architecture. Fine - tuning can further enhance accuracy.

Evaluation Metrics

Note: Metrics vary based on hardware (e.g., Raspberry Pi 4, Android devices) and fine - tuning. Test on your target device for accurate results.

Use Cases

NeuroBERT is designed for real - world intelligence in edge and IoT scenarios, delivering advanced NLP on resource - constrained devices. Key applications include:

• Smart Home Devices: Parse nuanced commands like "Turn [MASK] the coffee machine" (predicts "on") or "The fan will turn [MASK]" (predicts "off").
• IoT Sensors: Interpret complex sensor contexts, e.g., "The drone collects data using onboard [MASK]" (predicts "sensors").
• Wearables: Real - time intent detection, e.g., "The music pauses when someone [MASK] the room" (predicts "enters").
• Mobile Apps: Offline chatbots or semantic search, e.g., "She is a [MASK] at the hospital" (predicts "nurse").
• Voice Assistants: Local command parsing with high accuracy, e.g., "Please [MASK] the door" (predicts "shut").
• Toy Robotics: Advanced command understanding for interactive toys.
• Fitness Trackers: Local text feedback processing, e.g., sentiment analysis or personalized workout commands.
• Car Assistants: Offline command disambiguation for in - vehicle systems, enhancing driver safety without cloud reliance.

Hardware Requirements

• Processors: CPUs, mobile NPUs, or microcontrollers (e.g., Raspberry Pi, ESP32 - S3)
• Storage: About 57MB for model weights (quantized for reduced footprint)
• Memory: About 120MB RAM for inference
• Environment: Offline or low - connectivity settings

Quantization ensures efficient memory usage, making it suitable for resource - constrained devices.

Trained On

• Custom IoT Dataset: Curated data focused on IoT terminology, smart home commands, and sensor - related contexts (sourced from chatgpt - datasets). This enhances performance on tasks like intent detection, command parsing, and device control.

Fine - tuning on domain - specific data is recommended for optimal results.

Fine - Tuning Guide

To adapt NeuroBERT for custom IoT tasks (e.g., specific smart home commands):

1. Prepare Dataset: Collect labeled data (e.g., commands with intents or masked sentences).
2. Fine - Tune with Hugging Face:

#!pip uninstall -y transformers torch datasets
#!pip install transformers==4.44.2 torch==2.4.1 datasets==3.0.1

import torch
from transformers import BertTokenizer, BertForSequenceClassification, Trainer, TrainingArguments
from datasets import Dataset
import pandas as pd

# 1. Prepare the sample IoT dataset
data = {
    "text": [
        "Turn on the fan",
        "Switch off the light",
        "Invalid command",
        "Activate the air condit"

🔧 Technical Details

• Model Name: NeuroBERT
• Size: ~57MB (quantized)
• Parameters: ~30M
• Architecture: Advanced BERT (8 layers, hidden size 256, 4 attention heads)
• Description: Advanced 8 - layer, 256 - hidden
• License: MIT — free for commercial and personal use

📄 License

This project is licensed under the MIT License.