Entitybert

🚀 🌟EntityBERTモデル🌟

EntityBERTモデルは、軽量で微調整されたトランスフォーマーモデルで、英語テキストの固有表現認識（NER）に特化しています。情報抽出やチャットボット、検索機能の強化などのアプリケーションに最適です。

🚀 クイックスタート

推論コード

以下のPythonコードを使用して、NERを実行できます。

from transformers import AutoTokenizer, AutoModelForTokenClassification
import torch

# モデルとトークナイザーをロード
tokenizer = AutoTokenizer.from_pretrained("boltuix/EntityBERT")
model = AutoModelForTokenClassification.from_pretrained("boltuix/EntityBERT")

# 入力テキスト
text = "Elon Musk launched Tesla in California on March 2025."
inputs = tokenizer(text, return_tensors="pt")

# 推論を実行
with torch.no_grad():
    outputs = model(**inputs)
predictions = outputs.logits.argmax(dim=-1)

# 予測をラベルにマッピング
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]]

# 結果を表示
for token, label in zip(tokens, labels):
    if token not in tokenizer.all_special_tokens:
        print(f"{token:15} → {label}")

サンプル出力

Elon            → B-PERSON
Musk            → I-PERSON
launched        → O
Tesla           → B-ORG
in              → O
California      → B-GPE
on              → O
March           → B-DATE
2025            → I-DATE
.               → O

必要条件

pip install transformers torch pandas pyarrow

• Python: 3.8以上
• ストレージ: モデルの重みに約15MB
• オプション: 評価にseqeval、GPUアクセラレーションにcuda

✨ 主な機能

モデルの詳細

説明

boltuix/EntityBERTモデルは、boltuix/bert-miniベースモデルをベースに構築された、固有表現認識（NER） 用の軽量で微調整されたトランスフォーマーモデルです。効率性を重視して最適化されており、英語テキスト内の36種類のエンティティタイプ（人物、組織、場所、日付など）を識別できます。情報抽出、チャットボット、検索機能の強化などのアプリケーションに最適です。

• データセット: boltuix/conll2025-ner (143,709エントリ、6.38MB)
• エンティティタイプ: 36種類のNERタグ（18種類のエンティティカテゴリとB-/I-タグ + O）
• 学習例: 約115,812 | 検証: 約15,680 | テスト: 約12,217
• ドメイン: ニュース、ユーザー生成コンテンツ、研究コーパス
• タスク: 文レベルとドキュメントレベルのNER
• バージョン: v1.0

情報

• 開発者: Boltuix
• ライセンス: Apache-2.0
• 言語: 英語
• タイプ: トランスフォーマーベースのトークン分類
• 学習日: 2025年6月11日以前
• ベースモデル: boltuix/bert-mini
• パラメータ: 約440万
• サイズ: 約15MB

リンク

• モデルリポジトリ: boltuix/EntityBERT (プレースホルダー、正しいURLで更新してください)
• データセット: boltuix/conll2025-ner (プレースホルダー、正しいURLで更新してください)
• Hugging Faceドキュメント: Transformers
• デモ: 近日公開

NERのユースケース

直接的なアプリケーション

• 情報抽出: 記事、ブログ、レポートから名前（👤 PERSON）、場所（🌍 GPE）、日付（🗓️ DATE）を識別します。
• チャットボットとバーチャルアシスタント: エンティティを認識することで、ユーザーのクエリ理解を向上させます。
• 検索機能の強化: エンティティベースの意味検索を可能にします（例: “2025年のパリに関するニュース”）。
• 知識グラフ: 🏢 ORGや👤 PERSONなどのエンティティを接続する構造化グラフを構築します。

下流タスク

• ドメイン適応: 医療 🩺、法律 📜、金融 💸 などの専門分野のNER用に微調整します。
• 多言語拡張: 英語以外の言語用に再学習します。
• カスタムエンティティ: ニッチなドメイン（例: 製品ID、株価銘柄）に適応させます。

制限事項

• 英語のみ: デフォルトでは英語テキストに限定されます。
• ドメインバイアス: boltuix/conll2025-nerで学習されており、ニュースや正式なテキストに有利な傾向があり、非公式またはソーシャルメディアのコンテンツでは性能が低下する可能性があります。
• 汎化能力: データセットに含まれていないまれなまたは高度に文脈依存するエンティティの識別に苦労する可能性があります。

📦 インストール

pip install transformers torch pandas pyarrow seqeval

• Python: 3.8以上
• ストレージ: モデルに約15MB、データセットに約6.38MB
• オプション: GPUアクセラレーションにNVIDIA CUDA

ダウンロード手順 📥

• モデル: boltuix/EntityBERT

💻 使用例

基本的な使用法

from transformers import AutoTokenizer, AutoModelForTokenClassification
import torch

# モデルとトークナイザーをロード
tokenizer = AutoTokenizer.from_pretrained("boltuix/EntityBERT")
model = AutoModelForTokenClassification.from_pretrained("boltuix/EntityBERT")

# 入力テキスト
text = "Elon Musk launched Tesla in California on March 2025."
inputs = tokenizer(text, return_tensors="pt")

# 推論を実行
with torch.no_grad():
    outputs = model(**inputs)
predictions = outputs.logits.argmax(dim=-1)

# 予測をラベルにマッピング
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]]

# 結果を表示
for token, label in zip(tokens, labels):
    if token not in tokenizer.all_special_tokens:
        print(f"{token:15} → {label}")

📚 ドキュメント

エンティティラベル

このモデルは、boltuix/conll2025-nerデータセットの36種類のNERタグをサポートしており、BIOタグ付け方式 を使用しています。

• B-: エンティティの開始
• I-: エンティティの内部
• O: エンティティ外

例:
テキスト: "Tesla opened in Shanghai on April 2025"
タグ: [B-ORG, O, O, B-GPE, O, B-DATE, I-DATE]

パフォーマンス

seqevalを使用して、boltuix/conll2025-nerのテスト分割（約12,217例）で評価されました。

注: パフォーマンスは、異なるドメインまたはテキストタイプで異なる場合があります。

学習設定

• ハードウェア: NVIDIA GPU
• 学習時間: 約1.5時間
• パラメータ: 約440万
• オプティマイザー: AdamW
• 精度: FP32
• バッチサイズ: 16
• 学習率: 2e-5

モデルの学習

boltuix/bert-miniをboltuix/conll2025-nerデータセットで微調整して、EntityBERTを再現または拡張できます。以下は簡略化された学習スクリプトです。

# 🛠️ Step 1: Install required libraries quietly
!pip install evaluate 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
# Download : https://huggingface.co/datasets/boltuix/conll2025-ner/blob/main/conll2025_ner.parquet
parquet_file = "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/bert-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/bert-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))

ヒント

• ハイパーパラメータ: learning_rate（1e-5から5e-5）またはnum_train_epochs（2 - 5）を実験してみてください。
• GPU: より高速な学習にfp16=Trueを使用してください。
• カスタムデータ: カスタムNERデータセット用にスクリプトを修正してください。

予想される学習時間

• NVIDIA GPU（例: T4）で約115,812例、3エポック、バッチサイズ16で約1.5時間。

二酸化炭素排出量

• 排出量: 約40g CO₂eq（GPUで1.5時間の場合、ML Impactツールで推定）

📄 ライセンス

このプロジェクトは、Apache-2.0ライセンスの下でライセンスされています。