Overview

BCILattice ships a curated set of deep learning model classes under the nm_models namespace. These are available as drag-and-drop blocks inside the ML Suite canvas and can be wired into any training pipeline. Each class is documented here with its full constructor signature, parameter table, and available methods.

All models accept EEG / BCI signal tensors as input and return a model object that can be connected to training, evaluation, and export blocks.

Edge Models

Lightweight EEG classification architectures optimised for edge deployment, low-latency inference, and quantization. Available in the nm_models.edge module.

MobileEEGNet

from nm_models.edge import MobileEEGNet

MobileEEGNet(n_channels=16, n_classes=4, width_mult=0.5, dropout=0.3)

Constructor Parameters

Output: model_obj: Any

Methods

QuantizedEEGNet

from nm_models.edge import QuantizedEEGNet

QuantizedEEGNet()

Output: model_obj: Any

Methods

TinyEEGNet

from nm_models.edge import TinyEEGNet

TinyEEGNet()

Output: model_obj: Any

Methods

GPT Models

Transformer-based language-style architectures adapted for BCI signal classification and generation tasks. Available in nm_models.gpt_models.

TinyGPT

from nm_models.gpt_models import TinyGPT

TinyGPT()

Output: model_obj: Any

Methods

MiniGPT

from nm_models.gpt_models import MiniGPT

MiniGPT()

Output: model_obj: Any

Methods

LargeGPT

from nm_models.gpt_models import LargeGPT

LargeGPT()

Output: model_obj: Any

Methods

GPT2BCI

from nm_models.gpt_models import GPT2BCI

GPT2BCI()

Constructor Parameters

Output: model_obj: Any

Methods

BioGPTBCI

from nm_models.gpt_models import BioGPTBCI

BioGPTBCI()

Output: model_obj: Any

Methods

LaBraMBCI

from nm_models.gpt_models import LaBraMBCI

LaBraMBCI()

Output: model_obj: Any

Methods

Sequence Models

Recurrent and temporal convolutional architectures for sequential BCI decoding. Available in nm_models.sequence.

LSTMClassifier

from nm_models.sequence import LSTMClassifier

LSTMClassifier()

Output: model_obj: Any

Methods

BiLSTMClassifier

from nm_models.sequence import BiLSTMClassifier

BiLSTMClassifier()

Output: model_obj: Any

Methods

GRUClassifier

from nm_models.sequence import GRUClassifier

GRUClassifier()

Output: model_obj: Any

Methods

TCNClassifier

from nm_models.sequence import TCNClassifier

TCNClassifier()

Output: model_obj: Any

Methods

MambaSSM

from nm_models.sequence import MambaSSM

MambaSSM()

Output: model_obj: Any

Methods

Transformer Models

Patch-based transformer architectures for time-series BCI classification. Available in nm_models.transformers.

PatchTST

from nm_models.transformers import PatchTST

PatchTST()

Output: model_obj: Any

Methods

HuggingFace Integration

BCILattice integrates the full HuggingFace ecosystem as drag-and-drop blocks in the ML Suite and Workflow canvases. Every transformers, peft, datasets, evaluate, and huggingface_hub component is available with its complete parameter set:no coding required.

HF Models

All model classes live in the HuggingFace Models palette category. Each block exposes a from_pretrained method block plus save_pretrained and push_to_hub. Key constructor parameters (model_name_or_path, torch_dtype, device_map, num_labels) are editable in the Property Inspector.

Auto Classes

Auto classes select the correct architecture from the checkpoint name automatically.

BERT Family

from transformers import BertForSequenceClassification
model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=4)

Also available: BertModel, BertForTokenClassification, BertForQuestionAnswering, BertForMaskedLM, RobertaModel/ForSequenceClassification/ForTokenClassification, DistilBertModel/For*, AlbertModel/For*, ElectraModel/For*, XLNetModel/For*.

GPT-2

from transformers import GPT2LMHeadModel, GenerationConfig
model = GPT2LMHeadModel.from_pretrained('gpt2')
gen_cfg = GenerationConfig(max_new_tokens=256, do_sample=True, temperature=0.8, top_p=0.95)

T5

from transformers import T5ForConditionalGeneration, T5TokenizerFast
model = T5ForConditionalGeneration.from_pretrained('t5-small')
tokenizer = T5TokenizerFast.from_pretrained('t5-small')

Llama / Mistral / Qwen

Large language models for causal generation:typically used with 4-bit or 8-bit quantization.

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
import torch

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
    bnb_4bit_compute_dtype="bfloat16",
)
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Meta-Llama-3-8B-Instruct",
    quantization_config=bnb_config,
    device_map="auto",
)

Supported: LlamaForCausalLM, Llama3ForCausalLM, MistralForCausalLM, MixtralForCausalLM, Qwen2ForCausalLM, Gemma2ForCausalLM, Phi3ForCausalLM, FalconForCausalLM.

Vision & Multimodal

from transformers import ViTForImageClassification, CLIPModel
vit   = ViTForImageClassification.from_pretrained('google/vit-base-patch16-224')
clip  = CLIPModel.from_pretrained('openai/clip-vit-base-patch32')

Also: DeiTForImageClassification, SwinModel, CLIPTextModel.

Audio (Whisper)

from transformers import WhisperForConditionalGeneration, WhisperProcessor
model     = WhisperForConditionalGeneration.from_pretrained("openai/whisper-small")
processor = WhisperProcessor.from_pretrained("openai/whisper-small")

Quantization & Generation

Tokenizers & Processors

All tokenizers expose a unified set of methods: __call__, encode, decode, batch_encode_plus, tokenize, convert_tokens_to_ids, convert_ids_to_tokens, save_pretrained, and from_pretrained.

from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
encoded   = tokenizer(
    "EEG signal classification",
    padding="max_length",
    truncation=True,
    max_length=128,
    return_tensors="pt",
)

28 tokenizers available including AutoProcessor, AutoFeatureExtractor, AutoImageProcessor, WhisperProcessor, CLIPProcessor.

Training

TrainingArguments

Controls every aspect of the training loop:learning rate, batch size, checkpointing, logging, and mixed precision.

from transformers import TrainingArguments
args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    learning_rate=5e-5,
    fp16=True,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
    report_to="none",
)

Trainer

The Trainer block orchestrates training, evaluation, and prediction. Wire it to a model, tokenizer, datasets, and collator.

from transformers import Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_ds,
    eval_dataset=eval_ds,
    tokenizer=tokenizer,
    data_collator=collator,
    compute_metrics=compute_metrics,
)
trainer.train()

Methods: train(), evaluate(), predict(), save_model(), push_to_hub(), get_train_dataloader().

Seq2Seq variant: Seq2SeqTrainer with Seq2SeqTrainingArguments.

Data Collators

Callbacks

EarlyStoppingCallback(early_stopping_patience=3):stops training when metric_for_best_model stops improving. PrinterCallback and ProgressCallback for logging.

Pipelines

The pipeline() block wraps a model and tokenizer into a single callable inference object. BCILattice exposes 25 task-specific variants as ready-made blocks.

from transformers import pipeline
clf = pipeline("text-classification", model="distilbert-base-uncased-finetuned-sst-2-english")
asr = pipeline("automatic-speech-recognition", model="openai/whisper-small", device=0)

Datasets

The datasets library provides fast, memory-mapped dataset loading with built-in transforms and Hub integration.

from datasets import load_dataset
ds = load_dataset("imdb", split="train")          # HuggingFace Hub
ds = load_dataset("csv", data_files="data.csv")  # local CSV
ds = ds.train_test_split(test_size=0.1, seed=42)

Dataset Methods

Feature types: Value, ClassLabel, Sequence, Array2D, Array3D.

PEFT / LoRA

Parameter-Efficient Fine-Tuning methods let you fine-tune large models by training only a small fraction of parameters. BCILattice exposes all PEFT methods as canvas blocks.

LoraConfig

from peft import LoraConfig, TaskType
config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=8,
    lora_alpha=32,
    lora_dropout=0.1,
    target_modules=["q_proj", "v_proj"],
    bias="none",
)

PeftModel

from peft import get_peft_model, PeftModel
# Wrap a base model
peft_model = get_peft_model(model, lora_config)
peft_model.print_trainable_parameters()

# Load saved adapter
loaded = PeftModel.from_pretrained(model, "path/to/adapter")
merged = loaded.merge_and_unload()   # merge LoRA weights into base

Methods: print_trainable_parameters(), merge_adapter(), unmerge_adapter(), merge_and_unload(), save_pretrained(), load_adapter(), enable/disable_adapter_layers(), set_adapter().

Other PEFT Methods

Evaluate

evaluate.load() returns a metric module with compute(predictions, references), add(), add_batch(), and reset() methods.

import evaluate
accuracy = evaluate.load("accuracy")
f1       = evaluate.load("f1")
rouge    = evaluate.load("rouge")
combined = evaluate.combine(["accuracy", "f1"])

results = accuracy.compute(predictions=[1, 0, 1], references=[1, 1, 0])

Available metrics: accuracy, f1, precision, recall, bleu, rouge, meteor, bertscore, perplexity, seqeval, glue, squad, squad_v2.

HuggingFace Hub

Upload models, datasets, and adapters:or download checkpoints:directly from canvas blocks.

from huggingface_hub import login, hf_hub_download, HfApi
login(token="hf_...")

# Download a single file
path = hf_hub_download(repo_id="bert-base-uncased", filename="config.json")

# Upload via HfApi
api = HfApi(token="hf_...")
api.upload_file(
    path_or_fileobj="./model.pt",
    path_in_repo="model.pt",
    repo_id="my-org/my-model",
)

HfApi Methods