Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

Ты знаешь модель modern bert base ?

  1. User

    Ты знаешь модель modern bert base ?

  2. Assistant

    Да, модель Modern BERT Base – это улучшенная версия оригинальной модели BERT (Bidirectional Encoder Representations from Transformers). Модель BERT была представлена Google в 2018 году и оказала значительное влияние на задачи обработки естественного языка (NLP).

    Modern BERT Base может включать различные оптимизации и улучшения, такие как более эффективные способы обучения, архитектурные изменения или предобучение на более обширных и разнообразных данных. Такие улучшения могут повысить качество работы модели на задачах, таких как классификация текстов, извлечение информации и другие.

    Если у тебя есть более конкретные вопросы относительно этой модели или ее применения, не стесняйся спрашивать!

  3. User

    Я хочу в своём коде использовать modern bert base. Правильно ли я понимаю, что мне в моём коде нужно всего лишь заменить строку MODEL_NAME? !python -m pip install spacy # в данном примере нужен только displacy для красивых визуализаций

    !python -m pip install datasets # чтобы загружать датасеты с HF

    !python -m pip install transformers # чтобы работать с трансформерными нейросетями и загружать их с HF

    !python -m pip install evaluate # библиотека из экосистемы HF для интеграции метрик качества в Trainer

    !python -m pip install seqeval # нужно для расчёта F1 по сущностям, а не по токенам

    !python -m pip install tensorboard # чтобы выводить графики обучения

    import os import random from typing import Dict, List, Tuple, Union # эмуляция статической типизации

    import matplotlib.colors as mcolors # красиво раскрасим наши именованные сущности from nltk.tokenize.treebank import TreebankWordDetokenizer from spacy import displacy import evaluate import numpy as np from datasets import load_dataset import torch from transformers import AutoTokenizer, AutoModelForTokenClassification from transformers import DataCollatorForTokenClassification, TrainingArguments, Trainer from transformers import pipeline

    Хороший датасет для NER по текстам на тему астрофизики.

    Этой задаче в 2022 году была посвящена статья https://aclanthology.org/2022.wiesp-1.1.pdf

    и даже целый воркшоп https://ui.adsabs.harvard.edu/WIESP/

    DATASET_NAME = 'adsabs/WIESP2022-NER'

    Фиксируем все рандом сиды, которые только можем

    RANDOM_SEED = 42 random.seed(RANDOM_SEED) torch.manual_seed(RANDOM_SEED) torch.cuda.manual_seed(RANDOM_SEED) np.random.seed(RANDOM_SEED)

    trainset = load_dataset(DATASET_NAME, split='train')

    for k in sorted(trainset[0].keys()): print(f'{k}\t{trainset[0][k]}')

    label_set = set() for it in trainset['ner_tags']: label_set |= set(it) label_list = ['O'] + sorted(list(label_set - {'O'}))

    for it in label_list: print(it)

    print(f'Size of the entity tag dictionary is {len(label_list)}.')

    entity_classes = sorted(list(set( map( lambda it2: it2[2:], filter( lambda it1: it1 != 'O', label_list ) ) )))

    for it in entity_classes: print(it)

    print(f'Number of entity classes is {len(entity_classes)}.')

    entity_colors = [mcolors.rgb2hex((0.5 + random.random() / 2, 0.5 +random.random() / 2, 0.5 +random.random() / 2)) for _ in range(len(entity_classes))]

    len(entity_classes) == len(entity_colors)

    def bio_to_spans(bio: List[str]) -> List[Dict[str, Union[int, str]]]: # Функция нужна для красивого изображения текста с именованными сущностями # с использованием displacy https://spacy.io/usage/visualizers в стиле "span". ne_tag = '' start_pos = -1 bounds = [] for idx, val in enumerate(bio): if val.upper() == 'O': if start_pos >= 0: bounds.append({ 'start_token': start_pos, 'end_token': idx, 'label': ne_tag }) start_pos = -1 ne_tag = '' elif val.upper().startswith('B-'): if start_pos >= 0: bounds.append({ 'start_token': start_pos, 'end_token': idx, 'label': ne_tag }) start_pos = idx ne_tag = val[2:] if start_pos >= 0: bounds.append({ 'start_token': start_pos, 'end_token': len(bio), 'label': ne_tag }) return bounds

    sample_for_rendering = { 'text': TreebankWordDetokenizer().detokenize(trainset[0]['tokens']), 'spans': bio_to_spans(trainset[0]['ner_tags']), 'tokens': trainset[0]['tokens'], }

    rendered = displacy.render( sample_for_rendering, style='span', options={'ents': entity_classes, 'colors': dict(zip(entity_classes, entity_colors))}, manual=True, jupyter=True )

    def bio_to_ent(tokens: List[str], bio: List[str]) -> Tuple[str, List[Dict[str, Union[int, str]]]]: # Функция нужна для ещё более красивого изображения текста с именованными сущностями # с использованием displacy https://spacy.io/usage/visualizers в стиле "ent". if len(tokens) != len(bio): err_msg = f'Tokens do not correspond to their labels: {len(tokens)} != {len(bio)}!' raise RuntimeError(err_msg) full_text = TreebankWordDetokenizer().detokenize(tokens) token_bounds = [] previous_pos = 0 for cur in tokens: found_idx = full_text[previous_pos:].find(cur) if found_idx < 0: err_msg = f'The token {cur} is not found in the text "{full_text}".' raise RuntimeError(err_msg) token_start = found_idx + previous_pos token_end = token_start + len(cur) token_bounds.append((token_start, token_end)) previous_pos = token_end entity_spans = bio_to_spans(bio) entity_bounds = [] for cur in entity_spans: entity_class = cur['label'] entity_start = token_bounds[cur['start_token']][0] entity_end = token_bounds[cur['end_token'] - 1][1] entity_bounds.append({ 'start': entity_start, 'end': entity_end, 'label': entity_class }) del token_bounds, entity_spans return full_text, entity_bounds

    sample_for_rendering_2 = dict(zip( ('text', 'ents'), bio_to_ent(trainset[0]['tokens'], trainset[0]['ner_tags']) ))

    rendered_2 = displacy.render( sample_for_rendering_2, style='ent', options={'ents': entity_classes, 'colors': dict(zip(entity_classes, entity_colors))}, manual=True, jupyter=True )

    MODEL_NAME = 'FacebookAI/xlm-roberta-base' # бертоподобный языконезависимый трансформер-энкодер

    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)

    example = trainset[0] tokenized_input = tokenizer(example['tokens'], is_split_into_words=True) tokens = tokenizer.convert_ids_to_tokens(tokenized_input['input_ids']) print(tokens)

    def tokenize_and_align_labels(examples): 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) # Map tokens to their respective word. previous_word_idx = None label_ids = [] for word_idx in word_ids: # Set the special tokens to -100. if word_idx is None: label_ids.append(-100) elif word_idx != previous_word_idx: # Only label the first token of a given word. label_ids.append(label_list.index(label[word_idx])) else: label_ids.append(-100) previous_word_idx = word_idx labels.append(label_ids)

    tokenized_inputs['labels'] = labels
    return tokenized_inputs
    

    tokenized_trainset = trainset.map(tokenize_and_align_labels, batched=True)

    for k in sorted(tokenized_trainset[0].keys()): print(f'{k}\t{tokenized_trainset[0][k]}')

    valset = load_dataset(DATASET_NAME, split='validation')

    tokenized_valset = valset.map(tokenize_and_align_labels, batched=True)

    data_collator = DataCollatorForTokenClassification(tokenizer=tokenizer)

    seqeval = evaluate.load('seqeval')

    def compute_metrics(p): predictions, labels = p predictions = np.argmax(predictions, axis=2)

    true_predictions = [
        [label_list[p] for (p, l) in zip(prediction, label) if l != -100]
        for prediction, label in zip(predictions, labels)
    ]
    true_labels = [
        [label_list[l] for (p, l) in zip(prediction, label) if l != -100]
        for prediction, label in zip(predictions, labels)
    ]
    
    results = seqeval.compute(predictions=true_predictions, references=true_labels)
    return {
        'precision': results['overall_precision'],
        'recall': results['overall_recall'],
        'f1': results['overall_f1'],
        'accuracy': results['overall_accuracy'],
    }
    

    id2label = dict(enumerate(label_list))

    print(id2label)

    label2id = dict((val, idx) for idx, val in enumerate(label_list))

    print(label2id)

    model = AutoModelForTokenClassification.from_pretrained( MODEL_NAME, num_labels=len(label_list), id2label=id2label, label2id=label2id )

    MODEL_NAME_ON_DISK = os.path.abspath('astro_ner')

    training_args = TrainingArguments( output_dir=MODEL_NAME_ON_DISK, logging_dir=os.path.join(MODEL_NAME_ON_DISK, 'logs'), learning_rate=5e-5, # NEW: 1e-4 -> 5e-5 warmup_ratio=0.5, # делаем "прогрев": начинаем с околонулевого lr и до середины обучения (то есть до пятой эпохи, если у нас их 10) линейно увеличиваем до 1e-4 per_device_train_batch_size=8, per_device_eval_batch_size=16, # при тестировании не считаются градиенты, поэтому мини-батч можно и побольше num_train_epochs=10, # NEW weight_decay=0.01, # для регуляризации обновлений весов eval_strategy='epoch', save_strategy='epoch', save_total_limit=2, # чтобы не забивать жёсткий диск, будем сохранять только 2 чекпойнта: лучший и последний logging_strategy='epoch', report_to='tensorboard', # хотим красиво нарисовать графики обучения в tensorboard metric_for_best_model='f1', greater_is_better=True, # чем больше f1, тем лучше load_best_model_at_end=True, seed=RANDOM_SEED, data_seed=RANDOM_SEED, warmup_steps=500, # NEW

    )

    NEW

    from transformers import get_linear_schedule_with_warmup from transformers import EarlyStoppingCallback from transformers import AdamW

    NEW

    Define your model and get its parameters

    #model = AutoModelForTokenClassification.from_pretrained(MODEL_NAME)

    Create the optimizer

    optimizer = AdamW(model.parameters(), lr=5e-5, weight_decay=0.01)

    trainer = Trainer( model=model, args=training_args, train_dataset=tokenized_trainset, eval_dataset=tokenized_valset, tokenizer=tokenizer, data_collator=data_collator, compute_metrics=compute_metrics, #callbacks=[EarlyStoppingCallback(early_stopping_patience=2, early_stopping_threshold=0.01)], # NEW #optimizers=(optimizer, None), # NEW optimizers=(optimizer, get_linear_schedule_with_warmup(optimizer, num_warmup_steps=100, num_training_steps=len(tokenized_trainset))), # NEW )

    trainer.train()

    Commented out IPython magic to ensure Python compatibility.

    %load_ext tensorboard

    %tensorboard --logdir '{MODEL_NAME_ON_DISK}'/logs

    for it in os.listdir(MODEL_NAME_ON_DISK): print(it)

    possible_checkpoints = sorted( list(map( lambda it2: os.path.join(MODEL_NAME_ON_DISK, it2), filter( lambda it1: it1.startswith('checkpoint-'), os.listdir(MODEL_NAME_ON_DISK) ) )), key=lambda it3: -len(os.listdir(it3)) )

    for it in possible_checkpoints: print(it)

    import gc gc.collect() torch.cuda.empty_cache()

    classifier = pipeline('ner', model=possible_checkpoints[0], device=0)

    original_text = 'The authors would like to thank Adam Burgasser, Brendan Bowler, Kelle Cruz, Mike Cushing, Michael Liu, and Emily Rice for useful discussions on benchmark systems, data treatment, and various data-model comparison approaches. The authors thank Richard Freedman and Roxana Lupu for providing gas opacities and Caroline Morley for radiative transfer code comparisons and helpful discussions. We thank Jacob Lustig-Yeager and Kyle Luther for rewriting portions of the code in python and C for significant speed improvements and also Dan Foreman-Mackey for making EMCEE available to the community. Finally, we thank the anonymous referee and statistics consultant for useful and insightful comments.'

    original_res = classifier(original_text) for it in original_res: print(it)

    original_res_2 = classifier(original_text, aggregation_strategy='first') for it in original_res_2: print(it)

    sample_for_rendering_3 = { 'text': original_text, 'ents': [{'start': it['start'], 'end': it['end'], 'label': it['entity_group']} for it in original_res_2] }

    rendered_3 = displacy.render( sample_for_rendering_3, style='ent', options={'ents': entity_classes, 'colors': dict(zip(entity_classes, entity_colors))}, manual=True, jupyter=True )

    ru_text = 'Авторы хотели бы поблагодарить Адама Бургассера, Брендана Боулера, Келли Круз, Майка Кушинга, Майкла Лю и Эмили Райс за полезные обсуждения систем бенчмарков, обработки данных и различных подходов к сравнению моделей данных. Авторы благодарят Ричарда Фридмана и Роксану Лупу за предоставление непрозрачности газа и Кэролайн Морли за сравнения кодов переноса излучения и полезные обсуждения. Мы благодарим Джейкоба Люстига-Йегера и Кайла Лютера за переписывание частей кода на Python и C для значительного улучшения скорости, а также Дэна Формана-Макки за предоставление EMCEE сообществу. Наконец, мы благодарим анонимного рецензента и консультанта по статистике за полезные и проницательные комментарии.'

    ru_res = classifier(ru_text, aggregation_strategy='first') for it in ru_res: print(it)

    sample_for_rendering_4 = { 'text': ru_text, 'ents': [{'start': it['start'], 'end': it['end'], 'label': it['entity_group']} for it in ru_res] }

    rendered_4 = displacy.render( sample_for_rendering_4, style='ent', options={'ents': entity_classes, 'colors': dict(zip(entity_classes, entity_colors))}, manual=True, jupyter=True )

    testset = load_dataset(DATASET_NAME, split='test')

    def find_token(token_bounds: List[Tuple[int, int]], char_idx: int) -> int: res = -1 for token_idx, (token_start, token_end) in enumerate(token_bounds): if (char_idx >= token_start) and (char_idx < token_end): res = token_idx break return res

    def predictions_to_bio(text: str, tokens: List[str], predictions: List[Tuple[int, int, str]]) -> List[str]: token_bounds = [] token_labels = [] start_pos = 0 for cur_token in tokens: found_idx = text[start_pos:].find(cur_token) if found_idx < 0: err_msg = f'The token {cur_token} is not found in the text {text}' raise RuntimeError(err_msg) token_start = found_idx + start_pos token_end = token_start + len(cur_token) start_pos = token_end token_bounds.append((token_start, token_end)) token_labels.append('O') for span_start, span_end, span_label in predictions: start_token = find_token(token_bounds, span_start) end_token = find_token(token_bounds, span_end - 1) if (start_token >= 0) and (end_token >= 0): for token_idx in range(start_token, end_token + 1): token_labels[token_idx] = span_label elif start_token >= 0: token_labels[start_token] = span_label elif end_token >= 0: token_labels[end_token] = span_label corrected_token_labels = [] previous_label = 'O' for cur_label in token_labels: if cur_label == previous_label: corrected_token_labels.append(cur_label) else: if (cur_label == 'O') or cur_label.startswith('B-'): corrected_token_labels.append(cur_label) else: if previous_label == 'O': corrected_token_labels.append('B-' + cur_label[2:]) elif previous_label[2:] != cur_label[2:]: corrected_token_labels.append('B-' + cur_label[2:]) else: corrected_token_labels.append(cur_label) previous_label = cur_label return corrected_token_labels

    from tqdm.notebook import tqdm

    y_true = [] y_pred = [] for tokens, reference_tags in tqdm(zip(testset['tokens'], testset['ner_tags']), total=len(testset)): y_true.append(reference_tags) cur_text = TreebankWordDetokenizer().detokenize(tokens) cur_res = classifier(cur_text) y_pred.append( predictions_to_bio( cur_text, tokens, [(it['start'], it['end'], it['entity']) for it in cur_res] ) )

    for true_label, predicted_label in zip(y_true[0], y_pred[0]): print('{0:>25} {1:>25}'.format(true_label, predicted_label))

    from seqeval.scheme import IOB2 from seqeval.metrics import classification_report

    print(classification_report(y_true, y_pred, digits=4))

    print(classification_report(y_true, y_pred, digits=4, mode='strict', scheme=IOB2))

  4. Assistant

    Да, вы правы! Чтобы использовать другую модель, вам достаточно заменить строку с MODEL_NAME. Например, если вы хотите использовать modern bert base, вы можете заменить её на что-то вроде:

    MODEL_NAME = 'bert-base-uncased'  # или другая подходящая модель, которая вам нужна
    

    Просто убедитесь, что выбранная вами модель подходит для задачи, которую вы решаете, и что она поддерживает требуемый вами функционал (если вы используете токенизацию, модель для токенальной классификации и т. д.).

    Не забудьте также проверить, есть ли у новой модели различные специальные токены или другие настройки, которые могут повлиять на вашу обработку данных, такие как id2label и label2id. Например, если ваша новая модель уже предобучена на ваших метках, это может упростить вашу работу.

    Если вы выбираете другую версию BERT, попробуйте взглянуть на документацию Hugging Face и другие ресурсы, чтобы убедиться, что вы используете правильные параметры и методологии в вашем коде.

  5. User

    Что мне делать? Я заменил название модели и получил ошибку: MODEL_NAME = 'modern-bert-base' tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME) HTTPError Traceback (most recent call last) /usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_http.py in hf_raise_for_status(response, endpoint_name) 405 try: --> 406 response.raise_for_status() 407 except HTTPError as e:

    15 frames HTTPError: 401 Client Error: Unauthorized for url: https://huggingface.co/modern-bert-base/resolve/main/tokenizer_config.json

    The above exception was the direct cause of the following exception:

    RepositoryNotFoundError Traceback (most recent call last) RepositoryNotFoundError: 401 Client Error. (Request ID: Root=1-6767c5ba-1878528b4beaade333c9934d;68fa3d8d-a25d-4da6-a86f-0994e1d97af0)

    Repository Not Found for url: https://huggingface.co/modern-bert-base/resolve/main/tokenizer_config.json. Please make sure you specified the correct repo_id and repo_type. If you are trying to access a private or gated repo, make sure you are authenticated. Invalid username or password.

    The above exception was the direct cause of the following exception:

    OSError Traceback (most recent call last) /usr/local/lib/python3.10/dist-packages/transformers/utils/hub.py in cached_file(path_or_repo_id, filename, cache_dir, force_download, resume_download, proxies, token, revision, local_files_only, subfolder, repo_type, user_agent, _raise_exceptions_for_gated_repo, _raise_exceptions_for_missing_entries, _raise_exceptions_for_connection_errors, _commit_hash, **deprecated_kwargs) 424 ) from e 425 except RepositoryNotFoundError as e: --> 426 raise EnvironmentError( 427 f"{path_or_repo_id} is not a local folder and is not a valid model identifier " 428 "listed on 'https://huggingface.co/models'\nIf this is a private repository, make sure to pass a token "

    OSError: modern-bert-base is not a local folder and is not a valid model identifier listed on 'https://huggingface.co/models' If this is a private repository, make sure to pass a token having permission to this repo either by logging in with huggingface-cli login or by passing token=<your_token>

  6. Assistant

    Ошибка, которую вы получили, указывает на то, что модель с именем modern-bert-base не найдена на Hugging Face Model Hub. Вот некоторые шаги, которые вы можете предпринять, чтобы решить эту проблему:

    1. Проверьте название модели: Убедитесь, что вы используете правильное название модели. Вы можете посетить Hugging Face Model Hub и выполнить поиск по терминам, связанным с "modern bert" или просто "bert", чтобы найти доступные модели. Возможно, модель, которую вы хотите использовать, имеет другое имя.

    2. Используйте публичную модель: Если вы хотите использовать модель, основанную на BERT, можно попробовать такие варианты, как:

      MODEL_NAME = 'bert-base-uncased'  # или другой вариант, например, 'bert-large-uncased'
      
    3. Подписка и доступ: Если модель, которую вы пытаетесь использовать, действительно существует, но является приватной или требует специального доступа, вам необходимо будет авторизоваться. Для этого вы можете использовать следующую команду в терминале:

      huggingface-cli login
      

      Когда вы выполните эту команду, вам будет предложено ввести ваш токен (вы можете получить его на своей странице в Hugging Face).

    4. Замена на другую модель: Если вы не можете найти нужную модель, возможно, стоит рассмотреть возможность использования одной из хорошо зарекомендовавших себя моделей BERT, таких как bert-base-cased, bert-base-uncased, bert-large-uncased и т. д. Эти модели популярны и хорошо документированы.

    5. Работа с локальными моделями: Если у вас есть собственная версия модели, вы можете указать путь к ней в MODEL_NAME.

      MODEL_NAME = 'path/to/your/local/model'
      

    Проверьте эти моменты, и, вероятно, вы сможете решить проблему! Если возникнут другие вопросы, дайте знать.

  7. User

    Да, действительно. Название модели - answerdotai/ModernBERT-base. и теперь tokenizer у меня не ругается. Вот только я получил новую ошибку: model = AutoModelForTokenClassification.from_pretrained( MODEL_NAME, num_labels=len(label_list), id2label=id2label, label2id=label2id ) KeyError Traceback (most recent call last) /usr/local/lib/python3.10/dist-packages/transformers/models/auto/configuration_auto.py in from_pretrained(cls, pretrained_model_name_or_path, **kwargs) 1037 try: -> 1038 config_class = CONFIG_MAPPING[config_dict["model_type"]] 1039 except KeyError:

    3 frames KeyError: 'modernbert'

    During handling of the above exception, another exception occurred:

    ValueError Traceback (most recent call last) /usr/local/lib/python3.10/dist-packages/transformers/models/auto/configuration_auto.py in from_pretrained(cls, pretrained_model_name_or_path, **kwargs) 1038 config_class = CONFIG_MAPPING[config_dict["model_type"]] 1039 except KeyError: -> 1040 raise ValueError( 1041 f"The checkpoint you are trying to load has model type {config_dict['model_type']} " 1042 "but Transformers does not recognize this architecture. This could be because of an "

    ValueError: The checkpoint you are trying to load has model type modernbert but Transformers does not recognize this architecture. This could be because of an issue with the checkpoint, or because your version of Transformers is out of date.

  8. Assistant

    Ошибки, связанные с KeyError и ValueError, указывают на то, что библиотека Transformers не распознает тип модели, указанной в конфигурации загружаемой из Hugging Face. Это может произойти по нескольким причинам:

    1. Необновленная версия Transformers: Возможно, вы используете устаревшую версию библиотеки Transformers, которая не поддерживает новую архитектуру модели. Попробуйте обновить библиотеку до последней версии с помощью следующей команды:

      !pip install --upgrade transformers
      
    2. Конфигурация модели: Проверьте, правильно ли настроена модель на Hugging Face. Иногда разработчики моделей могут использовать нестандартные архитектуры, которые не совсем вписываются в ожидания библиотеки Transformers. Если модель не поддерживается, возможно, вам нужно будет обратиться к документации на странице модели или к её репозиторию, чтобы узнать, как правильно инициализировать её.

    3. Использование правильной модели: Если модель не поддерживает AutoModelForTokenClassification, возможно, вам нужно будет ручным образом загрузить класс модели, которая поддерживает вашу конкретную архитектуру. Для этого вам нужно будет посмотреть документацию к этой модели. Возможно, есть доступный специализированный класс, похожий на ModernBERT, который можно использовать.

    Чтобы это сделать, потратите немного времени на изучение страницы модели answerdotai/ModernBERT-base и посмотрите, есть ли рекомендация по использованию в коде или упоминания о классе, который поддерживает токенальную классификацию.

    Если вы не найдете решения, предоставьте дополнительную информацию о модели, и я постараюсь помочь вам точнее.

  9. User

    Это информация со страницы модели. Что мне нужно делать? (я использую google-colab, если это важно): Usage You can use these models directly with the transformers library. Until the next transformers release, doing so requires installing transformers from main:

    pip install git+https://github.com/huggingface/transformers.git

    Since ModernBERT is a Masked Language Model (MLM), you can use the fill-mask pipeline or load it via AutoModelForMaskedLM. To use ModernBERT for downstream tasks like classification, retrieval, or QA, fine-tune it following standard BERT fine-tuning recipes.

    ⚠️ If your GPU supports it, we recommend using ModernBERT with Flash Attention 2 to reach the highest efficiency. To do so, install Flash Attention as follows, then use the model as normal:

    pip install flash-attn

    Using AutoModelForMaskedLM:

    from transformers import AutoTokenizer, AutoModelForMaskedLM

    model_id = "answerdotai/ModernBERT-base" tokenizer = AutoTokenizer.from_pretrained(model_id) model = AutoModelForMaskedLM.from_pretrained(model_id)

    text = "The capital of France is [MASK]." inputs = tokenizer(text, return_tensors="pt") outputs = model(**inputs)

    To get predictions for the mask:

    masked_index = inputs["input_ids"][0].tolist().index(tokenizer.mask_token_id) predicted_token_id = outputs.logits[0, masked_index].argmax(axis=-1) predicted_token = tokenizer.decode(predicted_token_id) print("Predicted token:", predicted_token)

    Predicted token: Paris

    Using a pipeline:

    import torch from transformers import pipeline from pprint import pprint

    pipe = pipeline( "fill-mask", model="answerdotai/ModernBERT-base", torch_dtype=torch.bfloat16, )

    input_text = "He walked to the [MASK]." results = pipe(input_text) pprint(results)

    Note: ModernBERT does not use token type IDs, unlike some earlier BERT models. Most downstream usage is identical to standard BERT models on the Hugging Face Hub, except you can omit the token_type_ids parameter.

  10. Assistant

    Благодарю за предоставленную информацию! Учитывая, что модель ModernBERT является моделью для замещения (Masked Language Model, MLM), и в документации подчеркивается, что для задач классификации и других приложений вам необходимо будет ее дообучить, используйте подход, описанный в документации.

    Применение ModernBERT:

    1. Загрузка модели и токенизатора:

      Вам нужно загружать модель и токенизатор с использованием AutoModelForMaskedLM, так как модель предназначена для задач, связанных с заделкой масок:

      from transformers import AutoTokenizer, AutoModelForMaskedLM
      
      MODEL_NAME = "answerdotai/ModernBERT-base"
      tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
      model = AutoModelForMaskedLM.from_pretrained(MODEL_NAME)
      
    2. Использование трубопроводов для заполнения маски:

      Также вы можете использовать функцию pipeline для выполнения заполнения маски:

      from transformers import pipeline
      
      pipe = pipeline(
          "fill-mask",
          model=MODEL_NAME,
          torch_dtype=torch.bfloat16  # Или просто удалить этот параметр, если он не нужен
      )
      
      input_text = "He walked to the [MASK]."
      results = pipe(input_text)
      print(results)
      
    3. При дообучении на вашей задаче:

      Чтобы использовать ModernBERT для задач классификации, таких как токенальная классификация (например, NER), вам нужно будет дообучить модель. Для этого вы можете начать с обычных подходов, используемых для BERT, но понадобится настроить модель под вашу задачу.

      В случае, если вы хотите использовать токенальную классификацию, вам может потребоваться использовать AutoModelForTokenClassification, если вы хотите дополнять модель под конкретную задачу. Однако, как упоминалось в документации, вам, возможно, тоже нужно будет сначала адаптировать эту модель, так как ее конфигурация может не поддерживать прямую инициализацию для задаче токенальной классификации.

    4. Работа с Flash Attention (по желанию):

      Если вы планируете использовать Flash Attention для вашей модели, вы можете установить его с помощью:

      !pip install flash-attn
      

    Что делать дальше:

    • Если вы хотите, чтобы ModernBERT работал для вашего конкретного задания (такого как NER или другая задача классификации), начните с того, чтобы собрать данные и использовать подход, используемый для дообучения стандартных BERT моделей. Возможно, вам будет нужно создать свой собственный класс, который будет адаптировать модель.

    • Убедитесь, что вы будете дообучать модель, используя обычные методы механизма дообучения BERT.

    Если у вас есть конкретная задача, для которой вы хотите настроить ModernBERT, пожалуйста, дайте знать – я постараюсь помочь с более детальными инструкциями!

  11. User

    Так, я теперь запутался. Помоги мне в мой код добавить всё необходимое, чтобы у меня всё работало, пожалуйста. Покажи мне мой код с теми изменениями, которые я должен добавить в свой код, чтобы использовать эту модель

  12. Assistant

    Понял вас! Давайте адаптируем ваш код для работы с моделью ModernBERT. Основные изменения будут заключаться в использовании AutoModelForMaskedLM для инициализации модели. Если вы хотите использовать эту модель для задач токенальной классификации, она должна быть обучена или дообучена на ваших данных.

    Вот основные изменения, которые необходимо внести в ваш код:

    Обновленный код:

    !python -m pip install spacy
    !python -m pip install datasets
    !python -m pip install git+https://github.com/huggingface/transformers.git  # Устанавливаем последнюю версию Transformers
    !python -m pip install evaluate
    !python -m pip install seqeval
    !python -m pip install tensorboard
    !pip install flash-attn  # Устанавливаем Flash Attention (необязательно)
    
    import os
    import random
    from typing import Dict, List, Tuple, Union
    import matplotlib.colors as mcolors  
    from nltk.tokenize.treebank import TreebankWordDetokenizer
    from spacy import displacy
    import evaluate
    import numpy as np
    from datasets import load_dataset
    import torch
    from transformers import AutoTokenizer, AutoModelForMaskedLM  # Изменено здесь
    from transformers import DataCollatorForTokenClassification, TrainingArguments, Trainer
    from transformers import pipeline
    
    # Фиксируем все рандом сиды
    RANDOM_SEED = 42
    random.seed(RANDOM_SEED)
    torch.manual_seed(RANDOM_SEED)
    torch.cuda.manual_seed(RANDOM_SEED)
    np.random.seed(RANDOM_SEED)
    
    # Датасет и метки (оставьте ваши ранее заданные переменные)
    DATASET_NAME = 'adsabs/WIESP2022-NER'
    
    trainset = load_dataset(DATASET_NAME, split='train')
    
    # Ваше текущее определение меток и другие части кода остались неизменными...
    
    MODEL_NAME = 'answerdotai/ModernBERT-base'
    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
    
    # Модель для Masked LM
    model = AutoModelForMaskedLM.from_pretrained(MODEL_NAME)
    
    # Для примера, покажем, как использовать модель
    text = "The capital of France is [MASK]."
    inputs = tokenizer(text, return_tensors="pt")
    outputs = model(**inputs)
    
    # Получение предсказанного токена
    masked_index = inputs["input_ids"][0].tolist().index(tokenizer.mask_token_id)
    predicted_token_id = outputs.logits[0, masked_index].argmax(axis=-1)
    predicted_token = tokenizer.decode(predicted_token_id)
    print("Predicted token:", predicted_token)
    
    # Или используем pipeline для заполнения маски
    pipe = pipeline(
        "fill-mask",
        model=MODEL_NAME,
        torch_dtype=torch.bfloat16,  # Если не поддерживается, попробуйте удалить эта строку
    )
    
    input_text = "He walked to the [MASK]."
    results = pipe(input_text)
    print(results)
    
    # Теперь, в том случае, если вы хотите использовать ModernBERT для NER или других задач, вам нужно будет дообучить модель. 
    # Пример ниже показывает только загрузку и использование Masked LM. Для подготовки к дообучению (если необходимо), используйте обычные шаги BERT.
    
    # Ваш остальной код для предобработки данных, обучения и оценки остался без изменений,
    # но вам, возможно, придется адаптировать его под новый подход и механизм дообучения.
    

    Основные моменты:

    1. Загрузка модели и токенизатора: Мы используем AutoModelForMaskedLM, так как ModernBERT является моделью для маскирования.
    2. Использование pipeline: Вы можете воспользоваться функциональностью pipeline для заполнения маски.
    3. Подготовка к дообучению: Если вы хотите дообучить модель на своей задаче, вам нужно будет использовать класс Trainer, как и раньше, но будьте внимательны с настройками, так как архитектура модели может отличаться.

    Если вы все же хотите использовать эту модель для токенальной классификации, вам придется создать адаптацию этой модели для выполнения этой задачи. Не стесняйтесь задавать вопросы, если вам потребуется помощь в этом!

  13. User

    Ты ничего не забыл добавить? Потому что я получаю туже ошибку в model = AutoModelForMaskedLM.from_pretrained(MODEL_NAME): KeyError Traceback (most recent call last) /usr/local/lib/python3.10/dist-packages/transformers/models/auto/configuration_auto.py in from_pretrained(cls, pretrained_model_name_or_path, **kwargs) 1037 trust_remote_code = kwargs.pop("trust_remote_code", None) -> 1038 code_revision = kwargs.pop("code_revision", None) 1039

    3 frames KeyError: 'modernbert'

    During handling of the above exception, another exception occurred:

    ValueError Traceback (most recent call last) /usr/local/lib/python3.10/dist-packages/transformers/models/auto/configuration_auto.py in from_pretrained(cls, pretrained_model_name_or_path, **kwargs) 1038 code_revision = kwargs.pop("code_revision", None) 1039 -> 1040 config_dict, unused_kwargs = PretrainedConfig.get_config_dict(pretrained_model_name_or_path, **kwargs) 1041 has_remote_code = "auto_map" in config_dict and "AutoConfig" in config_dict["auto_map"] 1042 has_local_code = "model_type" in config_dict and config_dict["model_type"] in CONFIG_MAPPING

    ValueError: The checkpoint you are trying to load has model type modernbert but Transformers does not recognize this architecture. This could be because of an issue with the checkpoint, or because your version of Transformers is out of date.

  14. Assistant

    Ошибки, которые вы получаете, указывают на то, что библиотека Transformers не распознает тип модели modernbert, используемый в конфигурации модели ModernBERT. Это может быть связано с тем, что текущая версия библиотеки Transformers не поддерживает эту архитектуру или с тем, что модель была неправильно настроена.

    Шаги, которые вы можете предпринять:

    1. Обновите библиотеку Transformers: Убедитесь, что у вас установлена последняя версия библиотеки. Для этого выполните следующую команду в Google Colab:

      !pip install --upgrade transformers
      
    2. Проверка поддержки модели: Убедитесь, что модель действительно поддерживается. Чтобы узнать подробнее о том, как использовать модель, может имеет смысл проверить репозиторий модели на GitHub или документацию на Hugging Face.

    3. Используйте кастомный конфиг (если необходимо): Если модель ModernBERT была создана с использованием кастомного кода, вам, возможно, придется загрузить и использовать пользовательский класс конфигурации.

    4. Пробуйте различные подходы: Если вы хотите использовать ModernBERT для задач токенальной классификации, попробуйте другую модель из стандартного набора BERT, если такая имеется, или следуйте альтернативным подходам, упомянутым на странице модели.

    Попробуйте следующий альтернативный подход:

    Чтобы использовать ModernBERT для заполнения масок (Masked Language Model) и адаптировать его для последующих задач, можно попробовать следующее:

    Шаг 1: Загрузка Tokenizer и модели:

    from transformers import AutoTokenizer, AutoModelForMaskedLM
    
    MODEL_NAME = "answerdotai/ModernBERT-base"
    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
    model = AutoModelForMaskedLM.from_pretrained(MODEL_NAME)
    

    Шаг 2: Использование Masked LM:

    Это основной код для проверки, работает ли ваша модель с Masked LM. Важно, чтобы все зависимости были установлены корректно.

    text = "The capital of France is [MASK]."
    inputs = tokenizer(text, return_tensors="pt")
    outputs = model(**inputs)
    
    masked_index = inputs["input_ids"][0].tolist().index(tokenizer.mask_token_id)
    predicted_token_id = outputs.logits[0, masked_index].argmax(axis=-1)
    predicted_token = tokenizer.decode(predicted_token_id)
    print("Predicted token:", predicted_token)
    

    Конкретно под ваши задачи:

    Если вам нужно использовать эту модель для задач классификации (например, Named Entity Recognition), после выполнения всех необходимых шагов вам может понадобиться дообучение на ваших данных. Это потребует адаптации вашего кода, чтобы он соответствовал вашим меткам данных.

    Обновленная структура всего кода:

    Попробуйте следующий полный код с исправлениями:

    !pip install -q transformers datasets evaluate seqeval tensorboard flash-attn
    !pip install git+https://github.com/huggingface/transformers.git
    
    import os
    import random
    from typing import Dict, List, Tuple, Union
    import numpy as np
    import matplotlib.colors as mcolors
    from datasets import load_dataset
    import torch
    from transformers import AutoTokenizer, AutoModelForMaskedLM, pipeline
    
    # Загрузка датасета
    DATASET_NAME = 'adsabs/WIESP2022-NER'
    trainset = load_dataset(DATASET_NAME, split='train')
    
    # Установка сидов
    RANDOM_SEED = 42
    random.seed(RANDOM_SEED)
    torch.manual_seed(RANDOM_SEED)
    np.random.seed(RANDOM_SEED)
    
    # Загрузка токенизатора и модели
    MODEL_NAME = "answerdotai/ModernBERT-base"
    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
    model = AutoModelForMaskedLM.from_pretrained(MODEL_NAME)
    
    # Пример использования Masked LM
    text = "The capital of France is [MASK]."
    inputs = tokenizer(text, return_tensors="pt")
    outputs = model(**inputs)
    
    masked_index = inputs["input_ids"][0].tolist().index(tokenizer.mask_token_id)
    predicted_token_id = outputs.logits[0, masked_index].argmax(axis=-1)
    predicted_token = tokenizer.decode(predicted_token_id)
    print("Predicted token:", predicted_token)
    
    # Начинаем работу с pipeline
    pipe = pipeline(
        "fill-mask",
        model=MODEL_NAME,
    )
    
    input_text = "He walked to the [MASK]."
    results = pipe(input_text)
    print(results)
    

    Заключение:

    Если проблема не решается, возможно, модель имеет несовместимость с текущей версией библиотеки Transformers. В таком случае советую проверить страницу GitHub модели на наличие инструкций и требований по использованию. Если еще есть вопросы, дайте знать!