ホーム » sales-info の投稿

作者アーカイブ: sales-info

TensorFlow 2.6.0 リリースノート

TensorFlow 2.6.0 リリースノート (翻訳)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 08/12/2021

* 本ページは、github TensorFlow の releases の TensorFlow 2.6.0 の Major Features and Improvements 他のセクションを翻訳したものです:

 

クラスキャット 人工知能 研究開発支援サービス 無料 Web セミナー開催中

◆ クラスキャットは人工知能・テレワークに関する各種サービスを提供しております。お気軽にご相談ください :

◆ 人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。スケジュール
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

 

Release 2.6.0

 

互換性を損なう変更

  • tf.train.experimental.enable_mixed_precision_graph_rewrite は削除されます、API はグラフモードのみで動作してカスタマイズ可能ではないからです。この関数は引き続き tf.compat.v1.mixed_precision.enable_mixed_precision_graph_rewrite 下でアクセス可能ですが、代わりに Keras 混合精度 API を使用することが推奨されます。

  • tf.lite:
    • experimental.nn.dynamic_rnn, experimental.nn.TfLiteRNNCell と experimental.nn.TfLiteLSTMCell を削除します、これらはもはやサポートされないからです。代わりに単に keras lstm を使用することが勧められます。

  • tf.keras:
    • Keras は個別の PIP パッケージ (keras) に分割されて、そのコードは GitHub レポジトリ keras-team/keras に移動されました。tf.keras のための API エンドポイントは変更されないままですが、今では keras PIP パッケージにより支援されます。tensorflow/python/keras の既存のコードは古いコピーで将来的なリリース (2.7) では削除されます。tensorflow.python.keras への任意のインポートは削除して代わりにそれらを public tf.keras API で置き換えてください。
    • メソッド Model.to_yaml() と keras.models.model_from_yaml は任意のコード実行を引き起こすように悪用できるので、RuntimeError を上げるように置き換えられました。YAML の代わりに JSON シリアリゼーションを使用するか、より良い代替 H5 にシリアライズすることを勧めます。

 

主要な特徴と改良

  • tf.keras:
    • Keras は個別の PIP パッケージ (keras) に分割されて、そのコードは GitHub レポジトリ keras-team/keras に移動されました。tf.keras のための API エンドポイントは変更されないままですが、今では keras PIP パッケージにより支援されます。総ての Keras-関連の PR と issues は今では GitHub レポジトリ keras-team/keras に向けられるべきです。
    • tf.keras.utils.experimental.DatasetCreator は分散で使用されるとき特定のオプションのためのオプション tf.distribute.InputOptions を今では取ります。
    • 評価器タスクで実行されることを目的とするプログラムのために tf.keras.experimental.SidecarEvaluator が今では利用可能です、これは tf.distribute.experimental.ParameterServerStrategy で動作する訓練クラスタを補完するために一般に使用されます (https://www.tensorflow.org/tutorials/distribute/parameter_server_training 参照)。それはまた単一ワーカー訓練や他のストラテジーでも使用できます。より詳細については docstring 参照。
    • 前処理層は experimental から core に移動しました。
      • import パスは tf.keras.layers.preprocessing.experimental から tf.keras.layers に移動しました。
    • 一貫性と明確さのための前処理層 API へのアップデート :
      • mask_token の StringLookup と IntegerLookup デフォルトが None に変更されました。これは Hashing と Embedding 層のデフォルトのマスキング動作に一致します。既存の動作を維持するには、層作成中に mask_token=”” を渡します。
      • CategoryEncoding, StringLookup, IntegerLookup と TextVectorization のための “binary” 出力モードを “multi_hot” に名前変更しました。multi-hot エンコーディングはもはや自動的には rank 1 入力を uprank しませんので、これらの層はバッチ処理されていない多次元サンプルを今では multi-hot エンコードできます。
      • CategoryEncoding, StringLookup, IntegerLookup のために新しい出力モード “one_hot” を追加しました、これは入力バッチの各要素を個別にエンコードして、必要に応じて新しい出力次元を自動的に追加します。スカラーのバッチを one-hot エンコードする古い “binary” 動作のために rank 1 入力でこのモードを使用します。
      • 正規化はもはや rank 1 入力を自動的には uprank しません、バッチ処理されていない多次元サンプルの正規化を可能にします。


  • tf.lite:
    • Tensorflow Lite をビルドするための推奨 Android NDK バージョンは r18b から r19c に変更されました。
    • mul のために int64 をサポートします。
    • ネイティブの variable な組込み ops – ReadVariable, AssignVariable をサポートします。
    • Converter :
      • TFLite の変数の実験的なサポート。変換を通して有効にするには、ユーザは tf.lite.TFLiteConverter の experimental_enable_resource_variables を True に設定する必要があります。
        Note : ミュータブルな変数はこのリリースでは from_saved_model を使用してのみ利用可能です。他のメソッドのサポートは間もなくです。

      • 古い Converter (TOCO) は次のリリースから削除されます。それは幾つかのリリースで既に deprecated となっています。


  • tf.saved_model:
    • SavedModels は今ではカスタム勾配をセーブできます。この機能を有効にするにはオプション tf.saved_model.SaveOption(experimental_custom_gradients=True) を使用してください。Advanced autodiff のドキュメントはアップデートされました。
    • オブジェクト metadata は今では deprecated で SavedModel にもはやセーブされません。


  • TF Core:
    • tf.config.experimental.get_memory_info により返される追跡された peak メモリをリセットするために tf.config.experimental.reset_memory_stats を追加しました。


  • tf.data:
    • data_service_ops.from_dataset_id と data_service_ops.distribute に target_workers param を追加しました。ユーザは “AUTO”, “ANY” または “LOCAL” (case insensitive) を指定できます。”AUTO” の場合、tf.data サービスランタイムがどのワーカーから読む取るかを決定します。”ANY” の場合、TF ワーカーは任意の tf.data サービスワーカーから読み取ります。”LOCAL” の場合、TF ワーカーはローカル in-processs tf.data サービスワーカーだけから読み取ります。”AUTO” は殆どの場合に上手く動作しますが、その一方でユーザは他のターゲットも指定できます。例えば、”LOCAL” は 、総ての TF ワーカーが tf.data サービスワーカーと同じ場所に配置される場合、RPC とデータコピーを回避する役に立ちます。現在、”AUTO” は既存の動作を保持するために任意の tf.data サービスワーカーから読み取ります。デフォルト値は “AUTO” です。

 
以上

「画像認識AI PoCスターターパック」の提供を開始

Press Release

cc_logo_square

2021年07月26日 
株式会社クラスキャット / 日本FLOW株式会社
「画像認識 AI PoC スターターパック」の提供を開始
 
~ 手軽にAI(人工知能)導入普及促進を支援 ~

 

株式会社クラスキャット(茨城県取手市:代表取締役社長 佐々木規行)と日本FLOW株式会社(東京都港区:代表取締役社長 半戸祐次)は、手軽にAI導入へチャレンジできるPoC環境を用意し、AI導入普及を促進させることを目的とした、「画像認識AI PoCスターターパック」を共同で開発し本日から提供を開始いたします。

AI化による業務効率の改善、精度向上などを目的としてAI導入を検討したいが、PoC(概念実証)だけでも高額な出費となるため、なかなか踏み出せない企業も少なくないという状況を本スターターパックで支援いたします。

本スターターパックの特徴は、画像認識AI導入に向けたPoC段階での出費を抑えながらも、アノテーション専門企業である日本FLOWが高精度なアノテーションを実施、またAIの研究開発支援を行っているクラスキャットがPoCの開発を担当し、本格稼働に向けたPoCを短期間でしかも適切なコストで実現させることが可能となります。

 
【販売概要】

サービス名:画像認識AI PoC スターターパック

サービス内容:

  • 画像データのクレンジングとアノテーション作業
  • 上記画像データを訓練データとした認識率の評価
  • アノテーション済画像データと評価レポートの提供

画像条件:

  • 画像枚数:100
  • 画像サイズ:512 x 512 x 24 (bit)
  • 画像フォーマット:jpg

アノテーション対象画像条件

  • 1画像内10オブジェクト以内

提供価格:938.000円(税別)~
実施期間:約1ヶ月~
提供方法:クラスキャット経由の直販またはディストリビュータ経由など

 


お問合せ
本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット
セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com

最新ウェビナー情報などを下記で配信してます。

WebSite: https://www.classcat.com/
Facebook: https://www.facebook.com/ClassCatJP/
Twitter: https://twitter.com/ClassCat_AI_Lab/

※ ClassCat は株式会社クラスキャットの登録商標です。
※ その他、記載されている会社名・製品名は各社の登録商標または商標です。

HuggingFace Transformers 4.6 : ノートブック : パイプラインの利用

HuggingFace Transformers 4.6 : ノートブック : パイプラインの利用 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/14/2021 (4.6.1)

* 本ページは、HuggingFace Transformers の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

ノートブック : パイプラインの利用

transformers v2.3.0 で新たに導入された、パイプライン は以下を含む様々な下流タスクに渡る推論を行なうための高位の、使いやすい、API を提供します :

  • センテンス分類 (センチメント分析) : センテンス全体がポジティブかネガティブかを示します、つまり二値分類タスクかロジスティック回帰タスクです。

  • トークン分類 (固有表現認識品詞タギング) : 入力の各サブエンティティ (トークン) について、ラベルを割当てます、つまり分類タスクです。

  • 質問応答 : タプル (質問, コンテキスト) が提供されたとき、モデルは質問に答えるコンテンツのテキストの範囲を見つける必要があります。

  • マスク Filling : 提供されたコンテキストに関してマスクされた入力を埋める可能性のある単語を提示します。

  • 要約 : 入力記事をより短い記事に要約します。

  • 翻訳 : 入力をある言語から別の言語に翻訳します。

  • 特徴抽出 : 入力をデータから学習された、高位の多次元空間にマップします。

パイプラインは総ての NLP プロセスのプロセス全体をカプセル化します :

  1. トークン化 : 初期入力を … プロパティを持つ複数のサブエンティティに分割します (i.e. トークン)。

  2. 推論 : 総てのトークンをより意味のある表現にマップします。

  3. デコード : 基礎となるタスクのために最終的な出力を生成 and/or 抽出するために上の表現を使用します。

API 全体が以下の構造を持つ pipeline() メソッドを通してエンドユーザに公開されます :

from transformers import pipeline

# Using default model and tokenizer for the task
pipeline("<task-name>")

# Using a user-specified model
pipeline("<task-name>", model="<model_name>")

# Using custom model/tokenizer as str
pipeline('<task-name>', model='<model name>', tokenizer='<tokenizer_name>')
!pip install -q transformers
from __future__ import print_function
import ipywidgets as widgets
from transformers import pipeline

 

1. センテンス分類 – センチメント分析

nlp_sentence_classif = pipeline('sentiment-analysis')
nlp_sentence_classif('Such a nice weather outside !')
[{'label': 'POSITIVE', 'score': 0.9997656}]

 

2. トークン分類 – 固有表現認識

nlp_token_class = pipeline('ner')
nlp_token_class('Hugging Face is a French company based in New-York.')
[{'entity': 'I-ORG', 'score': 0.9970937967300415, 'word': 'Hu'},
 {'entity': 'I-ORG', 'score': 0.9345749020576477, 'word': '##gging'},
 {'entity': 'I-ORG', 'score': 0.9787060022354126, 'word': 'Face'},
 {'entity': 'I-MISC', 'score': 0.9981995820999146, 'word': 'French'},
 {'entity': 'I-LOC', 'score': 0.9983047246932983, 'word': 'New'},
 {'entity': 'I-LOC', 'score': 0.8913459181785583, 'word': '-'},
 {'entity': 'I-LOC', 'score': 0.9979523420333862, 'word': 'York'}]

 

3. 質問応答

nlp_qa = pipeline('question-answering')
nlp_qa(context='Hugging Face is a French company based in New-York.', question='Where is based Hugging Face ?')
{'answer': 'New-York.', 'end': 50, 'score': 0.9632969241603995, 'start': 42}

 

4. テキスト生成 – マスク Filling

nlp_fill = pipeline('fill-mask')
nlp_fill('Hugging Face is a French company based in ' + nlp_fill.tokenizer.mask_token)
[{'score': 0.23106741905212402,
  'sequence': '<s> Hugging Face is a French company based in Paris',
  'token': 2201},
 {'score': 0.08198167383670807,
  'sequence': '<s> Hugging Face is a French company based in Lyon',
  'token': 12790},
 {'score': 0.04769487306475639,
  'sequence': '<s> Hugging Face is a French company based in Geneva',
  'token': 11559},
 {'score': 0.04762246832251549,
  'sequence': '<s> Hugging Face is a French company based in Brussels',
  'token': 6497},
 {'score': 0.041305847465991974,
  'sequence': '<s> Hugging Face is a French company based in France',
  'token': 1470}]

 

5. 要約

要約は現在 Bart と T5 でサポートされます。

TEXT_TO_SUMMARIZE = """ 
New York (CNN)When Liana Barrientos was 23 years old, she got married in Westchester County, New York. 
A year later, she got married again in Westchester County, but to a different man and without divorcing her first husband. 
Only 18 days after that marriage, she got hitched yet again. Then, Barrientos declared "I do" five more times, sometimes only within two weeks of each other. 
In 2010, she married once more, this time in the Bronx. In an application for a marriage license, she stated it was her "first and only" marriage. 
Barrientos, now 39, is facing two criminal counts of "offering a false instrument for filing in the first degree," referring to her false statements on the 
2010 marriage license application, according to court documents. 
Prosecutors said the marriages were part of an immigration scam. 
On Friday, she pleaded not guilty at State Supreme Court in the Bronx, according to her attorney, Christopher Wright, who declined to comment further. 
After leaving court, Barrientos was arrested and charged with theft of service and criminal trespass for allegedly sneaking into the New York subway through an emergency exit, said Detective 
Annette Markowski, a police spokeswoman. In total, Barrientos has been married 10 times, with nine of her marriages occurring between 1999 and 2002. 
All occurred either in Westchester County, Long Island, New Jersey or the Bronx. She is believed to still be married to four men, and at one time, she was married to eight men at once, prosecutors say. 
Prosecutors said the immigration scam involved some of her husbands, who filed for permanent residence status shortly after the marriages. 
Any divorces happened only after such filings were approved. It was unclear whether any of the men will be prosecuted. 
The case was referred to the Bronx District Attorney\'s Office by Immigration and Customs Enforcement and the Department of Homeland Security\'s 
Investigation Division. Seven of the men are from so-called "red-flagged" countries, including Egypt, Turkey, Georgia, Pakistan and Mali. 
Her eighth husband, Rashid Rajput, was deported in 2006 to his native Pakistan after an investigation by the Joint Terrorism Task Force. 
If convicted, Barrientos faces up to four years in prison.  Her next court appearance is scheduled for May 18.
"""

summarizer = pipeline('summarization')
summarizer(TEXT_TO_SUMMARIZE)
{'summary_text': 'Liana Barrientos has been married 10 times, sometimes within two weeks of each other. Prosecutors say the marriages were part of an immigration scam. She is believed to still be married to four men, and at one time, she was married to eight men at once. Her eighth husband was deported in 2006 to his native Pakistan.'}]

 

6. 翻訳

翻訳は言語マッピング – 英語-to-フランス語 (translation_en_to_fr)、英語-to-ドイツ語 (translation_en_to_de) そして英語-to-ルーマニア語 (translation_en_to_ro) のために T5 により現在サポートされています。

# English to French
translator = pipeline('translation_en_to_fr')
translator("HuggingFace is a French company that is based in New York City. HuggingFace's mission is to solve NLP one commit at a time")
[{'translation_text': 'HuggingFace est une entreprise française basée à New York et dont la mission est de résoudre les problèmes de NLP, un engagement à la fois.'}]

# English to German
translator = pipeline('translation_en_to_de')
translator("The history of natural language processing (NLP) generally started in the 1950s, although work can be found from earlier periods.")
[{'translation_text': 'Die Geschichte der natürlichen Sprachenverarbeitung (NLP) begann im Allgemeinen in den 1950er Jahren, obwohl die Arbeit aus früheren Zeiten zu finden ist.'}]

 

7. テキスト生成

テキスト生成は現在 GPT-2, OpenAi-GPT, TransfoXL, XLNet, CTRL と Reformer によりサポートされています。

text_generator = pipeline("text-generation")
text_generator("Today is a beautiful day and I will")
[{'generated_text': 'Today is a beautiful day and I will celebrate my birthday!"\n\nThe mother told CNN the two had planned their meal together. After dinner, she added that she and I walked down the street and stopped at a diner near her home. "He'}]

 

8. 射影 – 特徴抽出

import numpy as np
nlp_features = pipeline('feature-extraction')
output = nlp_features('Hugging Face is a French company based in Paris')
np.array(output).shape   # (Samples, Tokens, Vector Size)
(1, 12, 768)

 
◆ Alright ! 今では transformers のパイプラインを通して何が可能かの良いイメージを持ち、そして今後のリリースでは更に多くのものが装備されます。

その間、貴方自身の入力で様々なパイプラインを試すことができます。

task = widgets.Dropdown(
    options=['sentiment-analysis', 'ner', 'fill_mask'],
    value='ner',
    description='Task:',
    disabled=False
)

input = widgets.Text(
    value='',
    placeholder='Enter something',
    description='Your input:',
    disabled=False
)

def forward(_):
    if len(input.value) > 0: 
        if task.value == 'ner':
            output = nlp_token_class(input.value)
        elif task.value == 'sentiment-analysis':
            output = nlp_sentence_classif(input.value)
        else:
            if input.value.find('') == -1:
                output = nlp_fill(input.value + ' ')
            else:
                output = nlp_fill(input.value)                
        print(output)

input.on_submit(forward)
display(task, input)
Dropdown(description='Task:', index=1, options=('sentiment-analysis', 'ner', 'fill_mask'), value='ner')
Text(value='', description='Your input:', placeholder='Enter something')
[{'word': 'Peter', 'score': 0.9935821294784546, 'entity': 'I-PER'}, {'word': 'Pan', 'score': 0.9901397228240967, 'entity': 'I-PER'}, {'word': 'Marseille', 'score': 0.9984904527664185, 'entity': 'I-LOC'}, {'word': 'France', 'score': 0.9998687505722046, 'entity': 'I-LOC'}]
context = widgets.Textarea(
    value='Einstein is famous for the general theory of relativity',
    placeholder='Enter something',
    description='Context:',
    disabled=False
)

query = widgets.Text(
    value='Why is Einstein famous for ?',
    placeholder='Enter something',
    description='Question:',
    disabled=False
)

def forward(_):
    if len(context.value) > 0 and len(query.value) > 0: 
        output = nlp_qa(question=query.value, context=context.value)            
        print(output)

query.on_submit(forward)
display(context, query)
Textarea(value='Einstein is famous for the general theory of relativity', description='Context:', placeholder=…
Text(value='Why is Einstein famous for ?', description='Question:', placeholder='Enter something')
{'score': 0.40340594113729367, 'start': 27, 'end': 54, 'answer': 'general theory of relativity'}
 

以上



HuggingFace Transformers 4.6 : ノートブック : Getting Started Transformers

HuggingFace Transformers 4.6 : ノートブック : Getting Started Transformers (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/12/2021 (4.6.1)

* 本ページは、HuggingFace Transformers の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

 

ノートブック : Getting Started Transformers

イントロダクション

transformers ライブラリは、Bert (Devlin & al., 2018), Roberta (Liu & al., 2019), GPT2 (Radford & al., 2019), XLNet (Yang & al., 2019) 等のような Transformer アーキテクチャ (Vaswani & al., 2017) に基づくモデルを訓練し、利用して共有するためのオープンソース、コミュニティ・ベースのレポジトリです。

これらのモデルとともに、ライブラリは 固有表現認識 (NER)、センチメント分析言語モデリング質問応答 等のような多種多様な下流タスクのためにそれらの各々の複数のバリエーションを含みます。

 

Transformer 以前

2017 に戻ると、ニューラルネットワークを使用する人々の殆どは自然言語処理で作業するとき リカレント・ニューラルネットワーク (RNN) を通した入力のシーケンシャルな処理に依存していました。

RNN は入力シークエンスに渡るシーケンシャルな依存性を含む様々なタスク上で上手く遂行しました。けれども、シーケンシャルな依存プロセスは非常に長い範囲の依存性をモデル化する問題を持っていて、悪い並列化機能ゆえに現在活用している種類のハードウェアのためには上手く適合しませんでした。

双方向 RNN ( Schuster & Paliwal., 1997, Graves & al., 2005 ) のような、幾つかの拡張が学術的なコミュニティから提供されました、これは 2 つのシーケンシャルなプロセスの結合として見ることができて、シークエンス入力に対して一つは順方向に進み、他方は逆方向に進みます。

そしてまた、Attention メカニズムは、シークエンスの各要素に学習された、重み付けされた重要性を与えることにより “raw” RNN を越える良い改良を導入し、モデルが重要な要素にフォーカスすることを可能にしました。

 

そして Transformer の登場

Transformer の時代は元々は翻訳タスク上で リカレント・ニューラルネットワーク (RNN) を越える優位性を実演した ( Vaswani & al., 2017 ) のワークから始まりましたが、それは迅速に当時 RNN が最先端であった殆ど総てのタスクに拡張されました。

RNN のカウンターパートを越える Transformer の一つの優位点は非シーケンシャルな attention モデルでした。忘れないでください、RNN は入力シークエンスの各要素に渡り一つ一つ反復して各跳躍 (= hop) 間で「更新可能な状態」を持ち運ばなければなりませんでした。Transformer では、モデルはシークエンスの総ての位置を同時に、一つの演算で見ることができます。

Transformer アーキテクチャの詳細については、The Annotated Transformer が論文の総ての詳細に沿って貴方を導きます。

 

Getting started with transformers

このノートブックの残りについては、BERT (Devlin & al., 2018) アーキテクチャを使用します、それは最も単純でインターネット上にそれについて多くのコンテンツがあるので、貴方が望めばこのアーキテクチャについて更に掘り下げることは容易です。

transformers ライブラリは巨大でコストのかかる計算インフラを必要とすることなく、大規模な、事前訓練された言語モデルから恩恵を受けることを可能にします。殆どの最先端モデルがその author から直接提供され、透過的で交換可能な方法で PyTorch と TensorFlow のライブラリで利用可能です。

このノートブックを Colab で実行する場合、transformers ライブラリをインストールする必要があります。このコマンドでそれを行なうことができます :

# !pip install transformers
import torch
from transformers import AutoModel, AutoTokenizer, BertTokenizer

torch.set_grad_enabled(False)
<torch.autograd.grad_mode.set_grad_enabled at 0x7ff0cc2a2c50>
# Store the model we want to use
MODEL_NAME = "bert-base-cased"

# We need to create the model and tokenizer
model = AutoModel.from_pretrained(MODEL_NAME)
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)

上のコードの 2 行だけで、BERT 事前訓練モデルを利用する準備ができました。トークナイザーは raw テキスト入力を (モデルが操作できる方法でテキスト入力を表す) 整数のシークエンスにマップすることを可能にします。PyTorch モデルを使用しますので、トークナイザーに PyTorch tensor を返すように求めます。

tokens_pt = tokenizer("This is an input example", return_tensors="pt")
for key, value in tokens_pt.items():
    print("{}:\n\t{}".format(key, value))

input_ids:
	tensor([[ 101, 1188, 1110, 1126, 7758, 1859,  102]])
token_type_ids:
	tensor([[0, 0, 0, 0, 0, 0, 0]])
attention_mask:
	tensor([[1, 1, 1, 1, 1, 1, 1]])

トークナイザーは入力をモデルにより想定される総ての入力に自動的に変換しました。それは幾つかの追加の tensor を ID の上に生成しました。

  • token_type_ids : この tensor は総てのトークンを対応するセグメントにマップします (下参照)。

  • attention_mask: この tensor は異なる長さを持つシークエンスのバッチでパッドされた値を「マスク」するために使用されます (下参照)。

それらのキーの各々についてのより多くの情報のためには 用語集 を確認できます。

これをモデルに単に直接供給できます。

outputs = model(**tokens_pt)
last_hidden_state = outputs.last_hidden_state
pooler_output = outputs.pooler_output

print("Token wise output: {}, Pooled output: {}".format(last_hidden_state.shape, pooler_output.shape))
Token wise output: torch.Size([1, 7, 768]), Pooled output: torch.Size([1, 768])

ご覧のように、BERT は 2 つの tensor を出力します :

  • 一つは入力の総てのトークンのための生成された表現です (1, NB_TOKENS, REPRESENTATION_SIZE)。
  • 一つは入力全体のための集約表現です (1, REPRESENTATION_SIZE)。

タスクがシークエンス表現を保持することを必要としトークンレベルで操作することを望む場合、最初のトークンベースの表現が活用できます。これは固有表現認識と質問応答のために特に有用です。

シークエンスのコンテキスト全体を抽出する必要があり極め細かいトークンレベルを必要としない場合、2 番目の集約表現が特別に有用です。これはシークエンスのセンチメント分析や情報検索に当てはまります。


# Single segment input
single_seg_input = tokenizer("This is a sample input")

# Multiple segment input
multi_seg_input = tokenizer("This is segment A", "This is segment B")

print("Single segment token (str): {}".format(tokenizer.convert_ids_to_tokens(single_seg_input['input_ids'])))
print("Single segment token (int): {}".format(single_seg_input['input_ids']))
print("Single segment type       : {}".format(single_seg_input['token_type_ids']))

# Segments are concatened in the input to the model, with 
print()
print("Multi segment token (str): {}".format(tokenizer.convert_ids_to_tokens(multi_seg_input['input_ids'])))
print("Multi segment token (int): {}".format(multi_seg_input['input_ids']))
print("Multi segment type       : {}".format(multi_seg_input['token_type_ids']))
Single segment token (str): ['[CLS]', 'This', 'is', 'a', 'sample', 'input', '[SEP]']
Single segment token (int): [101, 1188, 1110, 170, 6876, 7758, 102]
Single segment type       : [0, 0, 0, 0, 0, 0, 0]

Multi segment token (str): ['[CLS]', 'This', 'is', 'segment', 'A', '[SEP]', 'This', 'is', 'segment', 'B', '[SEP]']
Multi segment token (int): [101, 1188, 1110, 6441, 138, 102, 1188, 1110, 6441, 139, 102]
Multi segment type       : [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1]
# Padding highlight
tokens = tokenizer(
    ["This is a sample", "This is another longer sample text"], 
    padding=True  # First sentence will have some PADDED tokens to match second sequence length
)

for i in range(2):
    print("Tokens (int)      : {}".format(tokens['input_ids'][i]))
    print("Tokens (str)      : {}".format([tokenizer.convert_ids_to_tokens(s) for s in tokens['input_ids'][i]]))
    print("Tokens (attn_mask): {}".format(tokens['attention_mask'][i]))
    print()
Tokens (int)      : [101, 1188, 1110, 170, 6876, 102, 0, 0]
Tokens (str)      : ['[CLS]', 'This', 'is', 'a', 'sample', '[SEP]', '[PAD]', '[PAD]']
Tokens (attn_mask): [1, 1, 1, 1, 1, 1, 0, 0]

Tokens (int)      : [101, 1188, 1110, 1330, 2039, 6876, 3087, 102]
Tokens (str)      : ['[CLS]', 'This', 'is', 'another', 'longer', 'sample', 'text', '[SEP]']
Tokens (attn_mask): [1, 1, 1, 1, 1, 1, 1, 1]

 

フレームワーク相互運用性

transformers の最もパワフルな特徴の一つはユーザの痛みなく PyTorch から TensorFlow にシームレスに移動できる能力です。

PyTorch モデル内に TensorFlow 事前訓練重みをロードする (そしてその反対の) ための幾つかの便利なメソッドを提供しています。

from transformers import TFBertModel, BertModel

# Let's load a BERT model for TensorFlow and PyTorch
model_tf = TFBertModel.from_pretrained('bert-base-cased')
model_pt = BertModel.from_pretrained('bert-base-cased')
# transformers generates a ready to use dictionary with all the required parameters for the specific framework.
input_tf = tokenizer("This is a sample input", return_tensors="tf")
input_pt = tokenizer("This is a sample input", return_tensors="pt")

# Let's compare the outputs
output_tf, output_pt = model_tf(input_tf), model_pt(**input_pt)

# Models outputs 2 values (The value for each tokens, the pooled representation of the input sentence)
# Here we compare the output differences between PyTorch and TensorFlow.
for name in ["last_hidden_state", "pooler_output"]:
    print("{} differences: {:.5}".format(name, (output_tf[name].numpy() - output_pt[name].numpy()).sum()))
last_hidden_state differences: 1.2933e-05
pooler_output differences: 2.9691e-06

 

より軽量であることを望みますか?より高速であることを?distillation について話しましょう!

これらの Transformer ベースのモデルを使用するときの主要な懸念の一つはそれらが必要とする計算パワーです。このノートブック全体に渡り BERT モデルを使用しています、それは一般的なマシン上で実行できるからですが、モデルの総てのために当てはまりません。

例えば、Google は数ヶ月前に Transformer ベースのエンコーダ/デコーダ・アーキテクチャ T5 をリリースしました、そして 110 億に過ぎないパラメータを持つ transformers で利用可能です。マイクロソフトはまた最近 170 億パラメータを使用して Turing-NLG によりゲームに参加しました。この種類のモデルは重みをストアするために数十 GB を必要としそして一般的な人のためには実行不可能とする、そのようなモデルを実行するために非常に膨大な計算インフラを必要とします。

Transformer ベースの NLP を総ての人にアクセス可能にする目標により、@huggingface は Distillation と呼ばれる訓練プロセスを活用するモデルを開発しました、これはパフォーマンスを殆ど落とすことなくそのようなモデルを実行するために必要なリソースを劇的に削減することを可能にします。

Distillation プロセス全体を調べることはこのノートブックの範囲外ですが、主題についてより多くの情報を望む場合には、DistilBERT 論文の著者である、私の同僚 Victor SANH により書かれたこの Medium の記事 を参照することができます、論文 ( Sanh & al., 2019 ) を直接見ることもまた望むかもしれません。

もちろん、transformers では幾つかのモデルを蒸留してライブラリで直接利用可能にしました!

from transformers import DistilBertModel

bert_distil = DistilBertModel.from_pretrained('distilbert-base-cased')
input_pt = tokenizer(
    'This is a sample input to demonstrate performance of distiled models especially inference time', 
    return_tensors="pt"
)


%time _ = bert_distil(input_pt['input_ids'])
%time _ = model_pt(input_pt['input_ids'])
HBox(children=(FloatProgress(value=0.0, description='Downloading', max=411.0, style=ProgressStyle(description_…
HBox(children=(FloatProgress(value=0.0, description='Downloading', max=263273408.0, style=ProgressStyle(descri…
CPU times: user 64.4 ms, sys: 0 ns, total: 64.4 ms
Wall time: 72.9 ms
CPU times: user 130 ms, sys: 124 µs, total: 130 ms
Wall time: 131 ms

 

コミュニティ提供モデル

最後になりましたが、このノートブックの前の方で Hugging Face transformers を NLP コミュニティが事前訓練モデルを交換するためのレポジトリとして紹介しました。この機能とそれがエンドユーザに供給する総ての可能性を強調することを望みました。

コミュニティの事前訓練モデルを活用するためには、組織名とモデルの名前を from_pretrained に単に提供するだけでそしてそれは総てのマジックを貴方のために行ないます!

現在コミュニティにより提供された 50 モデル以上を持ちそして更に多くが毎日追加されています、試すことを躊躇しないでください!

# Let's load German BERT from the Bavarian State Library
de_bert = BertModel.from_pretrained("dbmdz/bert-base-german-cased")
de_tokenizer = BertTokenizer.from_pretrained("dbmdz/bert-base-german-cased")

de_input = de_tokenizer(
    "Hugging Face ist eine französische Firma mit Sitz in New-York.",
    return_tensors="pt"
)
print("Tokens (int)      : {}".format(de_input['input_ids'].tolist()[0]))
print("Tokens (str)      : {}".format([de_tokenizer.convert_ids_to_tokens(s) for s in de_input['input_ids'].tolist()[0]]))
print("Tokens (attn_mask): {}".format(de_input['attention_mask'].tolist()[0]))
print()

outputs_de = de_bert(**de_input)
last_hidden_state_de = outputs_de.last_hidden_state
pooler_output_de = outputs_de.pooler_output

print("Token wise output: {}, Pooled output: {}".format(last_hidden_state_de.shape, pooler_output_de.shape))
Tokens (int)      : [102, 12272, 9355, 5746, 30881, 215, 261, 5945, 4118, 212, 2414, 153, 1942, 232, 3532, 566, 103]
Tokens (str)      : ['[CLS]', 'Hug', '##ging', 'Fac', '##e', 'ist', 'eine', 'französische', 'Firma', 'mit', 'Sitz', 'in', 'New', '-', 'York', '.', '[SEP]']
Tokens (attn_mask): [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

Token wise output: torch.Size([1, 17, 768]), Pooled output: torch.Size([1, 768])
 

以上



HuggingFace Transformers 4.6 : ノートブック : Getting Started トークナイザー

HuggingFace Transformers 4.6 : ノートブック : Getting Started トークナイザー (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/11/2021 (4.6.1)

* 本ページは、HuggingFace Transformers の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

 

ノートブック : Getting Started トークナイザー

Tokenization doesn’t have to be slow !

 

イントロダクション

機械学習や深層学習の自然言語処理モデルに深く潜る前に、総ての実践者は raw 入力文字列を訓練可能なモデルにより理解可能な表現にマップする方法を見つけるべきです。

一つの非常に単純なアプローチは総ての空白に渡り入力を分割して各単語に識別子を割り当てることです。このアプローチは Python の下のコードに類似して見えます。

s = "very long corpus..."
words = s.split(" ")  # Split over space
vocabulary = dict(enumerate(set(words)))  # Map storing the word to it's corresponding id

このアプローチは貴方の語彙が少ないままなら上手く動作するかもしれません、というのはそれは元の入力に存在する総ての単語 (or トークン) をストアするからです。更に、”cat” と “cats” のような単語のバリエーションはそれらの意味が非常に近い場合でさえも同じ識別子を共有しないでしょう。

 

サブトークンのトークン化

上で説明された問題を乗り越えるために、最近のワークは「サブトークン」トークン化を活用した、トークン化上で成されてきました。サブトークン は前の分割ストラテジーを単語を (データから学習された) 文法的にロジカルなサブコンポーネントに更に分解するように拡張します。

単語 catcats の前の例を取れば、単語 cats のサブトークン化は [cat, ##s] になります。ここで prefix “##” は初期入力のサブトークンを示します。そのような訓練アルゴリズムは英語コーパスに渡り “##ing”, “##ed” のようなサブトークンを抽出するかもしれません。

貴方が考えるかもしれないように、「ピース」全体の組合せを活用したこの種類のサブトークン構築は (機械学習モデルを訓練するために持ち運ばなければならない) 語彙のサイズを削減します。一方で、一つのトークンが複数のサブトークンに分解されるかもしれないので、モデルの入力が増加して入力シークエンスの長さにわたる非線形の複雑さを伴うモデルについて問題になるかもしれません。

総てのトークン化アルゴリズムの中で、Transformers ベースの SoTA モデルで利用された幾つかのサブトークン・アルゴリズムにハイライトを当てることができます :

それら総てを通り抜けることはこのノートブックの範囲外ですので、それをどのように利用できるかにだけハイライトします。

 

@huggingface/tokenizers ライブラリ

transformers ライブラリとともに、@huggingface は一般的なマルチコアマシン上で数十 Gb/s でテキストを訓練、トークン化そしてデコードできる非常に高速なトークン化ライブラリを提供しています。

ネイティブなメモリ-aware な方法でマルチコア並列計算を活用することを可能にするためにライブラリは Rust で書かれていて、その上に Python と NodeJS のためのバインディングを提供しています (より多くのバインディングが将来追加される可能性があります)。

ライブラリが取り替え可能な end-to-end なトークナイザーを作成するために必要な総てのブロックを提供するように設計しました。その意味で、これらの様々なコンポーネントを提供します :

  • Normalizer : 初期入力文字列に渡り初期変換の総てを実行します。例えばあるテキストを小文字化し、多分それを strip し、あるいは一般的な unicode 正規化プロセスの一つを適用することさえ必要である場合、Normalizer を追加します。

  • PreTokenizer : 初期入力文字列の分割を担当します。元の文字列をどこでどのように事前にセグメント化するかを決定するコンポーネントです。最も単純な例は前に見たように空白で単純に分割することです。

  • モデル : 総てのサブトークンの発見 (= discovery) と生成を処理します、この部分は訓練可能で実際には入力データに依存しています。

  • Post-Processor : Transformers ベースの SoTA モデルの幾つかと互換な進んだ構築機能を提供します。例えば、BERT についてそれはトークン化されたセンテンスを [CLS] と [SEP] トークンでラップします。

  • Decoder : トークン化された入力を元の文字列にマップし戻すことを担当します。デコーダは通常は前に使用した PreTokenizer に従って選択されます。

  • Trainer : 各モデルに訓練機能を提供します。

上のコンポーネントの各々のために複数の実装を提供します :

  • Normalizer : Lowercase, Unicode (NFD, NFKD, NFC, NFKC), Bert, Strip, …

  • PreTokenizer : ByteLevel, WhitespaceSplit, CharDelimiterSplit, Metaspace, …

  • Model : WordLevel, BPE, WordPiece

  • Post-Processor : BertProcessor, …

  • Decoder : WordLevel, BPE, WordPiece, …

動作するトークン化パイプラインを作成するためにこれらのビルディング・ブロックの総てを組み合わせることができます。次のセクションで最初のパイプラインを調べます。

Alright, 今では tokenizers を通して最初のトークン化パイプラインを実装する準備ができました。

このため、このノートブックの目的で Byte-Pair エンコーディング (BPE) トークナイザーを非常に小さい入力上で訓練します。Peter Norving からのファイル で作業します。このファイルはおよそ 130,000 行の raw テキストを含みます、これは動作するトークナイザーを生成するためにライブラリにより処理されます。

!pip install tokenizers
BIG_FILE_URL = 'https://raw.githubusercontent.com/dscape/spell/master/test/resources/big.txt'

# Let's download the file and save it somewhere
from requests import get
with open('big.txt', 'wb') as big_f:
    response = get(BIG_FILE_URL, )
    
    if response.status_code == 200:
        big_f.write(response.content)
    else:
        print("Unable to get the file: {}".format(response.reason))

訓練データを持った今、トークナイザーのためのパイプライン全体を作成する必要があります。

# For the user's convenience `tokenizers` provides some very high-level classes encapsulating
# the overall pipeline for various well-known tokenization algorithm. 
# Everything described below can be replaced by the ByteLevelBPETokenizer class. 

from tokenizers import Tokenizer
from tokenizers.decoders import ByteLevel as ByteLevelDecoder
from tokenizers.models import BPE
from tokenizers.normalizers import Lowercase, NFKC, Sequence
from tokenizers.pre_tokenizers import ByteLevel

# First we create an empty Byte-Pair Encoding model (i.e. not trained model)
tokenizer = Tokenizer(BPE())

# Then we enable lower-casing and unicode-normalization
# The Sequence normalizer allows us to combine multiple Normalizer that will be
# executed in order.
tokenizer.normalizer = Sequence([
    NFKC(),
    Lowercase()
])

# Our tokenizer also needs a pre-tokenizer responsible for converting the input to a ByteLevel representation.
tokenizer.pre_tokenizer = ByteLevel()

# And finally, let's plug a decoder so we can recover from a tokenized input to the original one
tokenizer.decoder = ByteLevelDecoder()

このノートブックで先にダウンロードしたコーパス上でパイプライン全体が訓練される準備が今は整いました。

from tokenizers.trainers import BpeTrainer

# We initialize our trainer, giving him the details about the vocabulary we want to generate
trainer = BpeTrainer(vocab_size=25000, show_progress=True, initial_alphabet=ByteLevel.alphabet())
tokenizer.train(files=["big.txt"], trainer=trainer)

print("Trained vocab size: {}".format(tokenizer.get_vocab_size()))
Trained vocab size: 25000

Et voilà ! tokenizers を使用して貴方の本当に最初のトークナイザーをスクラッチから訓練しました。もちろん、これは基本だけをカバーしており、そして貴方は Trainer クラスの add_special_tokens や special_tokens パラメータを見ることを望むかもしれませんが、プロセス全体は非常に類似しているはずです。

モデルの内容をそれを後で再利用するためにセーブできます。

# You will see the generated files in the output.
tokenizer.model.save('.')
['./vocab.json', './merges.txt']

今は、訓練モデルをロードして新たに訓練されたトークナイザーを利用し始めましょう。

# Let's tokenizer a simple input
tokenizer.model = BPE('vocab.json', 'merges.txt')
encoding = tokenizer.encode("This is a simple input to be tokenized")

print("Encoded string: {}".format(encoding.tokens))

decoded = tokenizer.decode(encoding.ids)
print("Decoded string: {}".format(decoded))
Encoded string: ['Ġthis', 'Ġis', 'Ġa', 'Ġsimple', 'Ġin', 'put', 'Ġto', 'Ġbe', 'Ġtoken', 'ized']
Decoded string:  this is a simple input to be tokenized

エンコーディング構造は複数のプロパティを公開しています、それらは transformers モデルで作業するときに有用です。

  • normalized_str: 正規化 (小文字化、unicode、stripping 等) 後の入力文字列
  • original_str: それが提供されたときの入力文字列
  • tokens: 文字列表現による生成されたトークン
  • input_ids: 整数表現による生成されたトークン
  • attention_mask: 入力がトークナイザーによりパディングされている場合、これは任意のパディングされていないトークンのために 1、パディングされているもののためには 0 のベクトルです。
  • special_token_mask: 入力が [CLS], [SEP], [MASK], [PAD] のような特殊トークンを含む場合、これは特殊トークンが追加された場所で 1 を持つベクトルになります。
  • type_ids: 入力が (質問、コンテキスト) のような複数の「パート」から成る場合、これは各トークンについてそれが属するセグメントのベクトルになります。
  • overflowing: 入力が長さ制限のために複数のサブパートに切り捨てられた場合 (例えば BERT についてはシークエンス長は 512 に制限されています)、これは総ての残りのオーバーフローしたパートを含みます。
 

以上



HuggingFace Tokenizers 0.10 : コンポーネント (python)

HuggingFace Tokenizers 0.10 : コンポーネント (python) (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/05/2021 (Python v0.10.2)

* 本ページは、HuggingFace Tokenizers の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

HuggingFace Tokenizers : コンポーネント (python)

トークナイザーを構築するとき、その動作をカスタマイズするためにこのトークナイザーに様々なタイプのコンポーネントをアタッチできます。このページは殆どの提供されるコンポーネントをリストアップします。

 

Normalizers

Normalizer は入力文字列を特定のユースケースに適するものとしてそれを正規化するための前処理を担当します。正規化の幾つかの一般的な例は Unicode 正規化アルゴリズム (NFD, NFKD, NFC & NFKC)、小文字化 etc… です。トークナイザーの特異性は正規化中にアラインメントを追跡することです。これは生成されたトークンを入力テキストにマップし戻すことを可能にするために必須です。

正規化はオプションです。

名前 説明
NFD NFD unicode 正規化
NFKD NFKD unicode 正規化
NFC NFC unicode 正規化
NKFC NKFC unicode 正規化
Lowercase 総ての大文字を小文字に置き換える 入力: HELLO ὈΔΥΣΣΕΎΣ
出力: hello ὀδυσσεύς
Strip 入力の指定されたサイド (左、右 or 両者) の総ての空白文字を除去します 入力: ” hi “
出力: “hi”
StripAccents ユニコードの総てのアクセント記号を除去します (一貫性のために NFD とともに利用されます) 入力: é
出力: e
Replace カスタム文字列 or regexp を置き換えてそれを与えれた内容で変更します Replace(“a”, “e”) はこのように動作します :
入力: “banana” 出力: “benene”
BertNormalizer オリジナル BERT で使用された Normalizer の実装を提供します。設定可能なオプションは :

  • clean_text
  • handle_chinese_chars
  • strip_accents
  • lowercase
Sequence 複数の normalizer を構成します、これは提供された順序で実行されます Sequence([NFKC(), Lowercase()])

 

事前トークナイザー

PreTokenizer はルールのセットに従って入力を分割する処理をします。この前処理は基礎的なモデルが複数の「分割」に渡りトークンを構築しないことを確実にさせます。例えばトークン内に空白を持つことを望まない場合、これらの空白上で分割する PreTokenizer を持つことができます。

Sequence を使用して複数の PreTokenizer を容易に一緒に組み合わせることができます (下参照)。PreTokenizer はまた丁度 Normalizer が行なうように、文字列を変更することを許容されています。これは正規化の前に分割することが必要な幾つかの複雑なアルゴリズム (e.g. ByteLevel) を可能にするために必要です。

名前 説明
ByteLevel 総てのバイトを可視な文字のセットに再マッピングしながら空白上で分割します。このテクニックは OpenAI により GPT-2 で導入されて幾つかの多かれ少なかれ良い特性を持ちます :

  • それはバイト上にマップしますので、130,000+ ユニコード文字とは対照的に、これを使用するトークナイザーは初期アルファベットとして 256 文字 (バイトが持てる値の数) を必要とするだけです。
  • 前のポイントの結果は、これを使用して未知のトークンを持つ必要がまったくないことです、何故ならば 256 トークンで任意のものを表せるからです (Youhou!! 🎉🎉)
  • 非アスキー文字については、それは完全に可読ではなくなりますが、それでもそれは動作します!
入力: “Hello my friend, how are you?”
出力: “Hello”, “Ġmy”, Ġfriend”, “,”, “Ġhow”, “Ġare”, “Ġyou”, “?”
Whitespace 単語境界上で分割する (次の正規表現を使用します: \w+|[^\w\s]+) 入力: “Hello there!”
出力: “Hello”, “there”, “!”
WhitespaceSplit 任意の空白文字上で分割する 入力: “Hello there!”
出力: “Hello”, “there!”
Punctuation 総ての句読点文字を分離します 入力: “Hello?”
出力: “Hello”, “?”
Metaspace 空白上で分割してそれらを特殊文字 “▁” (U+2581) で置き換えます 入力: “Hello there”
出力: “Hello”, “▁there”
CharDelimiterSplit 指定された文字上で分割します x による例:
入力: “Helloxthere”
出力: “Hello”, “there”
Digits 任意の他の文字から数字を分ける 入力: “Hello123there”
出力: `”Hello”, “123”, “there”`
Split 多目的な事前トークナイザーで、提供されたパターン上と提供された動作に従って分割します。パターンは必要であれば反対にできます。

  • pattern はカスタム文字列か regexp であるべきです。
  • behavior は次の一つであるべきです :
    • removed
    • isolated
    • merged_with_previous
    • merged_with_next
    • contiguous
  • invert はブーリアン・フラグであるべきです。
pattern = ” “, behavior = “isolated”, invert = False による例:
入力: “Hello, how are you?”
出力: `”Hello,”, ” “, “how”, ” “, “are”, ” “, “you?”
Sequence 指定された順序で実行される複数の PreTokenizer を組合せます Sequence([Punctuation(), WhitespaceSplit()])

 

モデル

モデルは実際にトークン化するために使用される中心的なアルゴリズムです、そして従って、それらはトークナイザーの唯一の必須ののコンポーネントです。

名前 説明
WordLevel これは「古典的な」トークン化アルゴリズムです。それはどのような創造 (= fancy) もなく単語を ID に単純にマップさせます。これは利用し理解するために実際に単純であるという優位点を持ちますが、良い被覆率 (= coverage) のためには非常に大規模な語彙を必要とします。
このモデルの利用は PreTokenizer の利用を必要とします。このモデルによりどのような選択も直接なされません、それは単純に入力トークンを ID にマップします。
BPE 最もポピュラーなサブワード・トークン化アルゴリズムの一つです。Byte-Pair-Encoding は文字から始めて、最も頻繁に一緒に見られるそれらをマージしながら新しいトークンを作成することにより動作します。そしてそれは語彙で見る最も頻度の高いペアから新しいトークンを構築するように反復的に動作します。
BPE は複数のサブワード・トークンを使用してそれが決して見ていない単語を構築することができるため、”unk” (unknown) トークンのより少ない機会とともに、より小さい語彙を必要とするだけです。
WordPiece これは BERT のようなモデルで Google により主として使用された、BPE に非常に類似したサブワード・トークン化アルゴリズムです。それは greedy アルゴリズムを使用します、これは最初に長い単語を構築しようとし、単語全体が語彙に存在しないとき複数のトークンに分割します。これは文字から始めて、できる限り大きいトークンを構築する、BPE とは異なります。
それは単語の一部である (i.e. 単語を開始しない) トークンを識別するために有名な ## prefix を使用します。
Unigram Unigram はまたサブワード・トークン化アルゴリズムで、指定されたセンテンスのための確率を最大化するようにサブワード・トークンの最善のセットを特定しようとすることで動作します。これは逐次的に適用されるルールのセットに基づく決定論的ではない方法で BPE とは異なります。代わりに Unigram は最も確率の高いものを選択しながら、トークン化の複数の方法を計算することができます。

 

PostProcessor

パイプライン全体の後、時にトークン化された文字列をモデルに供給する前に “[CLS] My horse is amazing [SEP]” のように幾つかの特殊なトークンを挿入することを望みます。PostProcessor は丁度それを行なうコンポーネントです。

名前 説明
TemplateProcessing 後処理を容易にテンプレート化し、特殊トークンを追加し、そして各シークエンス/特殊トークンのために type_id を指定させましょう。テンプレートは単一シークエンスとシークエンスのペアを表す 2 つの文字列、そして使用する特殊トークンのセットが与えられます。 これらの値を持つテンプレートを指定するときの例 :
single: “[CLS] $A [SEP]”
pair: “[CLS] $A [SEP] $B [SEP]”
特殊トークン:

  • “[CLS]”
  • “[SEP]”

入力: (“I like this”, “but not this”)
出力: “[CLS] I like this [SEP] but not this [SEP]”

 

デコーダ

デコーダはトークナイザーで使用された ID から、どのようにテキストの可読なピースに戻すかを知っています。幾つかの Normalizer と PreTokenizer は例えば戻されるべき特殊文字や識別子を使用します。

名前 説明
ByteLevel ByteLevel PreTokenizer を元に戻します。PreTokenizer は各バイトを表すために可視な Unicode 文字のセットを使用し、バイトレベルでエンコードしますので、このプロセスを反対にして可読なものを再度得るためにデコーダを必要とします。
Metaspace Metaspace PreTokenizer を元に戻します。この PreTokenizer は空白を識別するために特殊な識別子 ▁ を使用しますので、このデコーダはこれらをデコードするのに役立ちます。
WordPiece WordPiece モデルを元に戻します。このモデルはサブワードを続けるために特殊な識別子 ## を使用しますので、このデコーダはこれらをデコードするのに役立ちます。

 

以上



HuggingFace Tokenizers 0.10 : メモリから訓練 (python)

HuggingFace Tokenizers 0.10 : メモリから訓練 (python) (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/01/2021 (Python v0.10.2)

* 本ページは、HuggingFace Tokenizers の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

HuggingFace Tokenizers : メモリから訓練 (python)

クイックツアー では、テキストファイルを使用してトークナイザーをどのように構築して訓練するかを見ましたが、実際には任意の Python Iterator を利用できます。このセクションではトークナイザーを訓練する幾つかの異なる方法を見ます。

下でリストされる総てのサンプルについて、次のように構築される、同じ TokenizerTrainer を使用します :

from tokenizers import Tokenizer, models, normalizers, pre_tokenizers, decoders, trainers

tokenizer = Tokenizer(models.Unigram())
tokenizer.normalizer = normalizers.NFKC()
tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel()
tokenizer.decoders = decoders.ByteLevel()

trainer = trainers.UnigramTrainer(
    vocab_size=20000,
    initial_alphabet=pre_tokenizers.ByteLevel.alphabet(),
    special_tokens=["<PAD>", "<BOS>", "<EOS>"],
)

このトークナイザーは Unigram モデルに基づきます。それは NFKC Unicode 正規化メソッドを使用して入力を正規化する処理を行ない、そして対応するデコーダとともに ByteLevel 事前トークナイザーを使用します。

ここで使用されるコンポーネントのより多くの情報については、ここ を確認できます。

 

最も基本的な方法

既に多分推測したように、トークナイザーを訓練する最も簡単な方法はリストを使用することによります :

# First few lines of the "Zen of Python" https://www.python.org/dev/peps/pep-0020/
data = [
    "Beautiful is better than ugly."
    "Explicit is better than implicit."
    "Simple is better than complex."
    "Complex is better than complicated."
    "Flat is better than nested."
    "Sparse is better than dense."
    "Readability counts."
]
tokenizer.train_from_iterator(data, trainer=trainer)

Easy, right? ここで iterator として動作する任意のものを利用できます、それはリスト、タプル、あるいは np.Array です。それが文字列を提供する限りどんなものでも動作します。

 

データセット・ライブラリを使用する

世の中に存在する多くのデータセットの一つにアクセスする素晴らしい方法は データセット・ライブラリを利用することです。その詳細については、こちらの公式ドキュメント を確認するべきです。

データセットをロードすることから始めましょう :

import datasets

dataset = datasets.load_dataset(
    "wikitext", "wikitext-103-raw-v1", split="train+test+validation"
)

次のステップはこのデータセットに渡り iterator を構築することです。これを行なう最も簡単な方法は多分 generator を使用することです :

def batch_iterator(batch_size=1000):
    for i in range(0, len(dataset), batch_size):
        yield dataset[i : i + batch_size]["text"]

ここで分かるように、より改良された効率性のためにそれらに渡り一つ一つ iterate する代わりに、訓練するために使用されるサンプルのバッチを実際には提供できます。それにより、ファイルから直接訓練する間に得られたものと非常に類似したパフォーマンスを期待できます。

iterator の準備ができれば、訓練を始める必要があるだけです。進捗バーの外観を改良するため、データセットの全長を指定できます :

tokenizer.train_from_iterator(batch_iterator(), trainer=trainer, length=len(dataset))

And that’s it!

 

gzip ファイルを使用する

Python 内の gzip ファイルは iterator として使用できますので、そのようなファイル上で訓練することは非常に簡単です。

import gzip

with gzip.open("data/my-file.0.gz", "rt") as f:
    tokenizer.train_from_iterator(f, trainer=trainer)

今は複数の gzip ファイルから訓練することを望んだ場合、それはそれほど難しくはありません :

files = ["data/my-file.0.gz", "data/my-file.1.gz", "data/my-file.2.gz"]

def gzip_iterator():
    for path in files:
        with gzip.open(path, "rt") as f:
            for line in f:
                yield line

tokenizer.train_from_iterator(gzip_iterator(), trainer=trainer)

And voilà!

 

以上



HuggingFace Tokenizers 0.10 : トークン化パイプライン (python)

HuggingFace Tokenizers 0.10 : トークン化パイプライン (python) (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/30/2021 (Python v0.10.2)

* 本ページは、HuggingFace Tokenizers の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

HuggingFace Tokenizers : トークン化パイプライン (python)

encode()encode_batch() を呼び出すとき、入力テキストは次のパイプラインを通過します :

これらのステップの各々の間に加えて、幾つかのトークン id をデコードすることを望むときに何が起きるか、そして
Tokenizer ライブラリが貴方のニーズに応じてそれらのステップの各々をどのようにカスタマイズするかを見ます。もし貴方がそれらのステップに既に馴染みがあり幾つかのコードを見ることにより学習することを望むのであれば、BERT from scratch example にジャンプしてください。

Tokenizer を必要とする例については、Quicktour で訓練されたトークナイザーを利用します、これは次でロードできます :

from tokenizers import Tokenizer

tokenizer = Tokenizer.from_file("data/tokenizer-wiki.json")

 

正規化

正規化は、簡単に言えば、raw 文字列をランダムさを減らすあるいは「クリーン」にするために適用する演算のセットです。一般的な演算は空白を strip し、アクセント付き文字を除去したり、あるいは総てのテキストを小文字化することを含みます。Unicode 正規化 に馴染みがある場合、それは殆どのトークナイザーで適用される非常に一般的な正規化演算でもあります。

各正規化演算は Tokenizers ライブラリでは Normalizer により表され、そして Sequence を使用して幾つかのそれらを連結できます。例としてここに NFD Unicode 正規化を適用してアクセントを除去する normalizer があります :

from tokenizers import normalizers
from tokenizers.normalizers import NFD, StripAccents

normalizer = normalizers.Sequence([NFD(), StripAccents()])

それを任意の文字列に適用することにより normalizer を手動でテストすることができます。

normalizer.normalize_str("Héllò hôw are ü?")
# "Hello how are u?"

Tokenizer を構築するとき、対応する属性を変更するだけで normalizer をカスタマイズできます。

tokenizer.normalizer = normalizer

もちろん、トークナイザーが正規化を適用する方法を変更する場合、多分それを後でスクラッチから再訓練するべきです。

 

事前トークン化

事前トークン化はテキストを (トークンが訓練の最後になるであろう) 上界を与える小さなオブジェクトに分割する高位です。これを考える良い方法は事前トークン化はテキストを「単語」に分割して、最終的なトークンはそれらの単語の一部となります。

入力を事前トークン化する簡単な方法は空白と句読点上で分割することです、これは Whitespace pre-tokenizer により成されます :

from tokenizers.pre_tokenizers import Whitespace

pre_tokenizer = Whitespace()
pre_tokenizer.pre_tokenize_str("Hello! How are you? I'm fine, thank you.")
# [("Hello", (0, 5)), ("!", (5, 6)), ("How", (7, 10)), ("are", (11, 14)), ("you", (15, 18)),
#  ("?", (18, 19)), ("I", (20, 21)), ("'", (21, 22)), ('m', (22, 23)), ("fine", (24, 28)),
#  (",", (28, 29)), ("thank", (30, 35)), ("you", (36, 39)), (".", (39, 40))]

出力はタプルのリストで、各タプルは一つの単語と元のセンテンス内のその範囲を含みます (これは Encoding の最終的な offsets を決定するために使用されます)。句読点上の分割はこのサンプルの “I’m” のような縮約を分割することに注意してください。

任意の PreTokenizer を一緒に組み合わせることができます。例えば、ここに空白、句読点と数字上で分割し、個々の数字で数字を区切る事前トークナイザーがあります。

from tokenizers import pre_tokenizers
from tokenizers.pre_tokenizers import Digits

pre_tokenizer = pre_tokenizers.Sequence([Whitespace(), Digits(individual_digits=True)])
pre_tokenizer.pre_tokenize_str("Call 911!")
# [("Call", (0, 4)), ("9", (5, 6)), ("1", (6, 7)), ("1", (7, 8)), ("!", (8, 9))]

Quicktour で見たように、対応する属性を変更することだけで Tokenizer の事前トークナイザーをカスタマイズできます。

tokenizer.pre_tokenizer = pre_tokenizer

もちろん、事前トークナイザーの方法を変更する場合、多分トークナイザーを後でスクラッチから再訓練するべきです。

 

モデル

ひとたび入力テキストが正規化されて事前トークン化されれば、Tokenizer は事前トークンにモデルを適用します。これはコーパス上の訓練を必要とするパイプラインの一部です (あるいは事前訓練されたトークナイザーを利用している場合はそれは訓練されています)。

モデルの役割はそれが学習したルールを使用して「単語」をトークンに分割することです、それはまたそれらのトークンをモデルの語彙の対応する ID にマップする責任も負います。

モデルは Tokenizer を初期化するときに一緒に渡されますので、この部分をどのようにカスタマイズするかを貴方は既に知っています。現在、 Tokenizers ライブラリは以下をサポートします :

各モデルとその動作の詳細については、ここ を確認できます。

 

後処理

後処理は潜在的な特殊トークンを追加するような、任意の追加の変換を (それが返される前に) Encoding に遂行するためのトークン化パイプラインの最後のステップです。

クイックツアーで見たように、Tokenizer の後処理を対応する属性を設定することでカスタマイズできます。例えば、入力を BERT モデルに適したものにするためにどのように後処理できるかがここにあります :

from tokenizers.processors import TemplateProcessing

tokenizer.post_processor = TemplateProcessing(
    single="[CLS] $A [SEP]",
    pair="[CLS] $A [SEP] $B:1 [SEP]:1",
    special_tokens=[("[CLS]", 1), ("[SEP]", 2)],
)

事前トークナイザーや normalizer と対照的に、後処理を変更した後でトークナイザーを再訓練する必要はないことに注意してください。

 

まとめ: スクラッチから BERT トークナイザー

BERT トークナイザーを構築するためにこれら総てのピースをまとめましょう。最初に、BERT は WordPiece に依拠しますので、このモデルで新しい Tokenizer をインスタンス化します :

from tokenizers import Tokenizer
from tokenizers.models import WordPiece

bert_tokenizer = Tokenizer(WordPiece(unk_token="[UNK]"))

そして BERT はアクセントを除去して小文字化することによりテキストを前処理することを知っています。unicode normalizer も使用します :

from tokenizers import normalizers
from tokenizers.normalizers import Lowercase, NFD, StripAccents

bert_tokenizer.normalizer = normalizers.Sequence([NFD(), Lowercase(), StripAccents()])

事前トークナイザーは空白と句読点上で分割するだけです :

from tokenizers.pre_tokenizers import Whitespace

bert_tokenizer.pre_tokenizer = Whitespace()

そして後処理は前のセクションで見たテンプレートを使用します :

from tokenizers.processors import TemplateProcessing

bert_tokenizer.post_processor = TemplateProcessing(
    single="[CLS] $A [SEP]",
    pair="[CLS] $A [SEP] $B:1 [SEP]:1",
    special_tokens=[
        ("[CLS]", 1),
        ("[SEP]", 2),
    ],
)

このトークナイザーを使用してその上でクイックツアーでのように wikitext 上で訓練できます :

from tokenizers.trainers import WordPieceTrainer

trainer = WordPieceTrainer(
    vocab_size=30522, special_tokens=["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"]
)
files = [f"data/wikitext-103-raw/wiki.{split}.raw" for split in ["test", "train", "valid"]]
bert_tokenizer.train(files, trainer)

bert_tokenizer.save("data/bert-wiki.json")

 

デコード

入力テキストのエンコードに加えて、トークナイザーはまたデコードのための API も持ちます、これはモデルにより生成された ID をテキストに戻します。これはメソッド decode() (一つの予測されたテキストのため) と decode_batch() (予測のバッチのため) により成されます。

デコーダは最初に (トークナイザーの語彙を使用して) ID をトークンに変換し戻し、総ての特殊トークンを除去してから、それらのトークンを空白で結合します :

output = tokenizer.encode("Hello, y'all! How are you 😁 ?")
print(output.ids)
# [1, 27253, 16, 93, 11, 5097, 5, 7961, 5112, 6218, 0, 35, 2]

tokenizer.decode([1, 27253, 16, 93, 11, 5097, 5, 7961, 5112, 6218, 0, 35, 2])
# "Hello , y ' all ! How are you ?"

(WordPiece の “##” のような) 特定の「単語」のサブトークンを表すために特殊文字を追加したモデルを使用した場合、それらを正しく扱うためにデコーダをカスタマイズする必要があります。例えば前の bert_tokenizer を取る場合、デフォルトのデコーダは次を与えます :

output = bert_tokenizer.encode("Welcome to the 🤗 Tokenizers library.")
print(output.tokens)
# ["[CLS]", "welcome", "to", "the", "[UNK]", "tok", "##eni", "##zer", "##s", "library", ".", "[SEP]"]

bert_tokenizer.decode(output.ids)
# "welcome to the tok ##eni ##zer ##s library ."

しかしそれを適切なデコーダに替えることにより、次を得ます :

from tokenizers import decoders

bert_tokenizer.decoder = decoders.WordPiece()
bert_tokenizer.decode(output.ids)
# "welcome to the tokenizers library."
 

以上



HuggingFace Tokenizers 0.10 : Quicktour (python)

HuggingFace Tokenizers 0.10 : Quicktour (python) (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/27/2021 (Python v0.10.2)

* 本ページは、HuggingFace Tokenizers の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

HuggingFace Tokenizers : Quicktour (python)

Tokenizers ライブラリの機能を素早く見てみましょう。このライブラリは使いやすく超高速な今日最も利用されているトークナイザーの実装を提供します。

それは事前訓練されたトークナイザーをインスタンス化するために利用できますが、スクラッチから構築することからクイックツアーを始めてそれをどのように訓練するかを見ます。

 

スクラッチからトークナイザーを構築する

Tokenizers ライブラリがどれほど速いかを示すため、新しいトークナイザーを wikitext-103 (テキストの 516M) の上で数秒間で訓練しましょう。まず最初に、このデータセットをダウンロードして次で unzip する必要があります :

wget https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-103-raw-v1.zip
unzip wikitext-103-raw-v1.zip

 

トークナイザーの訓練

このツアーでは、Byte-Pair エンコーディング (BPE) トークナイザーを構築して訓練します。様々なタイプのトークナイザーについてのより多くの情報については、 Transformers ドキュメントのこの ガイド を確認してください。ここでは、トークナイザーの訓練は次によりマージルールを学習することを意味します :

  • 訓練コーパスに存在する総ての文字からトークンとして始めます。
  • トークの最も一般的なペアを識別してそれを一つのトークンにマージします。
  • 語彙 (e.g., トークンの数) が望んだサイズに到達するまで繰り返します。

ライブラリのメイン API はクラス Tokenizer で、ここに BPE モデルでそれをどのようにインスタンス化するかがあります :

from tokenizers import Tokenizer
from tokenizers.models import BPE

tokenizer = Tokenizer(BPE(unk_token="[UNK]"))

トークナイザーを wikitext ファイル上で訓練するには、トレーナー、この場合は BpeTrainer をインスタンス化する必要があります。

from tokenizers.trainers import BpeTrainer

trainer = BpeTrainer(special_tokens=["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"])

vocab_size や min_frequency のような訓練引数を設定できますが (ここでは 30,000 と 0 のそれらのデフォルト値のままです)、最も重要な部分は後で使う予定の special_tokens を与えることです (それらは訓練の間には全く使われません)、その結果それらは語彙に挿入されます。

Note: special トークンリストを書く順序は重要です : ここでは “[UNK]” は ID 0 を得て、”[CLS]” は ID 1 を得ます、等々。

トークナイザーを直ちに訓練できるでしょうが、それは最適ではありません。入力を単語に分割する事前トークナイザーなしでは、幾つかの単語にオーバーラップするトークンを得るかもしれません : 例えば “it is” トークンを得る可能性があります、何故ならばそれら 2 つの単語はしばしば隣り合って出現するからです。事前トークナイザーの使用は事前トークナイザーにより返される単語よりも大きいトークンがないことを確実にします。ここでは subword BPE tokenizer を訓練することを望みます、そしてホワイトスペースで分割することで可能な最も容易な事前トークナイザーを使用します。

from tokenizers.pre_tokenizers import Whitespace

tokenizer.pre_tokenizer = Whitespace()

今は、使用したい任意のファイルのリストで train() メソッドを単に呼び出すことができます :

files = [f"data/wikitext-103-raw/wiki.{split}.raw" for split in ["test", "train", "valid"]]
tokenizer.train(files, trainer)

これは full wikitext データセット上でトークナイザーを訓練するために数秒しかかからないはずです!総ての configuration と語彙を含む一つのファイルにトークナイザーをセーブするには、単に save() メソッドを使います :

tokenizer.save("data/tokenizer-wiki.json")

そしてそのファイルから from_file() クラスメソッドでトークナイザーを再ロードできます :

tokenizer = Tokenizer.from_file("data/tokenizer-wiki.json")

 

トークナイザーを使用する

トークナイザーを訓練した今、で望む任意のテキスト上で enode() メソッドそれを使用できます :

output = tokenizer.encode("Hello, y'all! How are you 😁 ?")

これはテキスト上でトークナイザーの完全なパイプラインを適用し、エンコーディング・オブジェクトを返します。このパイプラインについて更に学習し、その一部をどのように適用 (or カスタマイズ) するかについては、このページ を調べてください。

そしてこのエンコーディング・オブジェクトは深層学習モデル (or その他) のために必要な総ての属性を持ちます。tokens 属性はテキストのセグメンテーションをトークンで含みます :

print(output.tokens)
# ["Hello", ",", "y", "'", "all", "!", "How", "are", "you", "[UNK]", "?"]

同様に、ids 属性はそれらのトークンのトークナイザーの語彙内の各々のインデックスを含みます :

print(output.ids)
# [27253, 16, 93, 11, 5097, 5, 7961, 5112, 6218, 0, 35]

Tokenizers ライブラリの重要な特徴はそれが完全なアライメント追跡を備えていることです、つまり与えられたトークンに対応する元のセンテンスの一部を常に得ることができます。それらはエンコーディング・オブジェクトの offsets 属性にストアされています。例えば、リストのインデックス 9 のトークンである、出現する “[UNK]” トークンを引き起こしたものを見つけることを望むとすれば、インデックスのオフセットを単に求めることができます :

print(output.offsets[9])
# (26, 27)

そしてそれらは元のセンテンスで絵文字に対応するインデックスです :

sentence = "Hello, y'all! How are you 😁 ?"
sentence[26:27]
# "😁"

 

後処理

トークナイザーが “[CLS]” や “[SEP]” のような特殊トークンを自動的に追加することを望むかもしれません。これを行なうために、post-processor を使用します。TemplateProcessing が最も一般的に使用されます、単一センテンスとセンテンスのペアの処理のために特殊トークンとそれらの ID と一緒に、単にテンプレートを指定しなければなりません。

トークナイザーを構築したとき、特殊トークンのリストの位置 1 と 2 に “[CLS]” と “[SEP]” を設定したので、これはそれらの ID であるはずです。再確認するため、token_to_id() メソッドを使用できます :

tokenizer.token_to_id("[SEP]")
# 2

ここに伝統的な BERT 入力を与える後処理をどのように設定できるかがあります :

from tokenizers.processors import TemplateProcessing

tokenizer.post_processor = TemplateProcessing(
    single="[CLS] $A [SEP]",
    pair="[CLS] $A [SEP] $B:1 [SEP]:1",
    special_tokens=[
        ("[CLS]", tokenizer.token_to_id("[CLS]")),
        ("[SEP]", tokenizer.token_to_id("[SEP]")),
    ],
)

コードのこのスニペットを詳しく調べましょう。最初に単一センテンスのためにテンプレートを指定します : これはフォーム “[CLS] $A [SEP]” を持つべきです、ここで $A はセンテンスを表すします。

そして、センテンスペアのためのテンプレートを指定します、これはフォーム “[CLS] $A [SEP] $B [SEP]” を持つべきです、ここで $A は最初のセンテンスそして $B は 2 番目のものを表します。テンプレートで追加された :1 は入力の各パートのために望むタイプ ID を表します : それは総てについて 0 がデフォルトで (それが $A:0 をもたない理由です) そしてここでは 2 番目のセンテンスのトークンと最後の “[SEP]” トークンのためにそれを 1 に設定します。

最後に、使用した特殊トークンとそれらの ID をトークナイザーの語彙で指定します。

これが正しく動作したことを確認するため、前と同じセンテンスをエンコードしてみましょう :

output = tokenizer.encode("Hello, y'all! How are you 😁 ?")
print(output.tokens)
# ["[CLS]", "Hello", ",", "y", "'", "all", "!", "How", "are", "you", "[UNK]", "?", "[SEP]"]

センテンスのペア上の結果を確認するには、2 つのセンテンスを encode() に渡すだけです :

output = tokenizer.encode("Hello, y'all!", "How are you 😁 ?")
print(output.tokens)
# ["[CLS]", "Hello", ",", "y", "'", "all", "!", "[SEP]", "How", "are", "you", "[UNK]", "?", "[SEP]"]

それから各トークンに属する type ID が正しいかを次で確認できます :

print(output.type_ids)
# [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]

save() でトークナイザーをセーブする場合、post-processor も一緒にセーブされます。

 

バッチで複数センテンスをエンコードする

Tokenizers ライブラリのフルスピードを得るには、encode_batch() メソッドを使用してバッチによりテキストを処理することが最善です :

output = tokenizer.encode_batch(["Hello, y'all!", "How are you 😁 ?"])

そして出力は前にみたもののような Encoding オブジェクトのリストです。メモリに収まる限りは、必要なだけの多くのテキストを処理できます。

センテンスペアのバッチを処理するには、2 つのリストを encode_batch() メソッドに渡します : センテンス A のリストとセンテンス B のリストです :

output = tokenizer.encode_batch(
    [["Hello, y'all!", "How are you 😁 ?"], ["Hello to you too!", "I'm fine, thank you!"]]
)

複数センテンスをエンコードするとき、pad_token とその ID により (前のように token_to_id() によりパディングトークンのための id を再確認できます)、enable_padding() を使用して出力を存在する最長センテンスに自動的にパッドできます :

tokenizer.enable_padding(pad_id=3, pad_token="[PAD]")

総てのサンプルをその特定の数にパッドすることを望む場合、パディングの方向や指定された長さを設定できます (ここでは最長テキストのサイズへのパッドを設定しないままにします)。

output = tokenizer.encode_batch(["Hello, y'all!", "How are you 😁 ?"])
print(output[1].tokens)
# ["[CLS]", "How", "are", "you", "[UNK]", "?", "[SEP]", "[PAD]"]

この場合、トークナイザーによりせいせいされたアテンションマスクはパディングを考慮に入れます :

print(output[1].attention_mask)
# [1, 1, 1, 1, 1, 1, 1, 0]

 

事前訓練されたトークナイザーを使用する

語彙ファイルを持つ限りは事前訓練されたトークナイザーもまた直接利用できます。例えば、ここに古典的な事前訓練された BERT トークナイザーをどのように得るかがあります :

from tokenizers import BertWordPieceTokenizer

tokenizer = BertWordPieceTokenizer("bert-base-uncased-vocab.txt", lowercase=True)

一方でファイル bert-base-uncased-vocab.txt は次でダウンロードしておきます :

wget https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-uncased-vocab.txt
 

以上



HuggingFace Tokenizers 0.10 : 概要 | Python バインディング概要

HuggingFace Tokenizers 0.10 : 概要 | Python バインディング概要 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/20/2021 (Python v0.10.2)

* 本ページは、HuggingFace Tokenizers の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

HuggingFace Tokenizers : 概要

パフォーマンスと多用途性に焦点を置いた、今日最も利用されているトークナイザーの実装を提供します。

 

主要な特徴

  • 今日最も利用されているトークナイザーを使用して、新しい語彙を訓練してトークン化します。
  • Rust 実装のおかげで、非常に高速です (訓練とトークン化の両者で)。サーバの CPU 上で GB のテキストをトークン化するのに 20 秒かかりません。
  • 使いやすく、また極めて多用途性もあります。
  • 研究とプロダクションのために設計されました。
  • 正規化はアラインメント追跡を装備しています。与えられたトークンに対応する元のセンテンスの一部を得ることが常に可能です。
  • 前処理の総てを行ないます : 切り捨て、パディングとモデルが必要な特殊トークンを追加します。

 

バインディング

以下の言語へのバインディングを提供します (more to come!) :

  • Rust (オリジナル実装)
  • Python (訳注 : 本ドキュメント後半で翻訳)
  • Node.js

 

Python を使用するクイック・サンプル

Byte-Pair エンコーディング, WordPiece or Unigram の間でモデルを選択してトークナイザーをインスタンス化します :

from tokenizers import Tokenizer
from tokenizers.models import BPE

tokenizer = Tokenizer(BPE())

どのように事前トークン化 (e.g., 単語に分割する) が成されるかをカスタマイズできます :

from tokenizers.pre_tokenizers import Whitespace

tokenizer.pre_tokenizer = Whitespace()

そしてファイルのセット上でのトークナイザーの訓練は 2 行のコードがかかるだけです :

from tokenizers.trainers import BpeTrainer

trainer = BpeTrainer(special_tokens=["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"])
tokenizer.train(files=["wiki.train.raw", "wiki.valid.raw", "wiki.test.raw"], trainer=trainer)

ひとたびトークナイザーが訓練されれば、任意のテキストを 1 行だけでエンコードします :

output = tokenizer.encode("Hello, y'all! How are you 😁 ?")
print(output.tokens)
# ["Hello", ",", "y", "'", "all", "!", "How", "are", "you", "[UNK]", "?"]

更に学習するために python ドキュメントpython クイックツアー を確認してください!

 

HuggingFace Tokenizers : (bindings/python) 概要

提供されているトークナイザー

殆どの一般的なケースをカバーするために幾つかの事前ビルドされたトークナイザーを提供しています。特定の vocab.json と merges.txt ファイルを使用してこれらの一つを容易にロードできます :

from tokenizers import CharBPETokenizer

# Initialize a tokenizer
vocab = "./path/to/vocab.json"
merges = "./path/to/merges.txt"
tokenizer = CharBPETokenizer(vocab, merges)

# And then encode:
encoded = tokenizer.encode("I can feel the magic, can you?")
print(encoded.ids)
print(encoded.tokens)

そしてそれらを同様に単純に訓練できます :

from tokenizers import CharBPETokenizer

# Initialize a tokenizer
tokenizer = CharBPETokenizer()

# Then train it!
tokenizer.train([ "./path/to/files/1.txt", "./path/to/files/2.txt" ])

# Now, let's use it:
encoded = tokenizer.encode("I can feel the magic, can you?")

# And finally save it somewhere
tokenizer.save("./path/to/directory/my-bpe.tokenizer.json")

 

提供されているトークナイザー

  • CharBPETokenizer: オリジナル BPE
  • ByteLevelBPETokenizer: BPE のバイトレベル・バージョン
  • SentencePieceBPETokenizer: SentencePiece で使用されるものと互換な BPE 実装
  • BertWordPieceTokenizer: WordPiece を使用した、有名な Bert トークナイザー

これらの総てが上で説明されたように利用できて訓練できます!

 

貴方自身のものを構築する

提供されるトークナイザーが十分な自由度を与えないときはいつでも、必要な様々な部分をまとめることで、貴方自身のトークナイザーを構築できます。私達がどのように 提供されるトークナイザー を実装したかを確認してそれらを貴方自身のニーズに容易に適応せることができます。

 

バイトレベル BPE を構築する

ここに総ての様々なピースをまとめて、それを単一ファイルにセーブすることによって貴方自身のバイトレベル BPE をどのように構築するかを示すサンプルがあります :

from tokenizers import Tokenizer, models, pre_tokenizers, decoders, trainers, processors

# Initialize a tokenizer
tokenizer = Tokenizer(models.BPE())

# Customize pre-tokenization and decoding
tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=True)
tokenizer.decoder = decoders.ByteLevel()
tokenizer.post_processor = processors.ByteLevel(trim_offsets=True)

# And then train
trainer = trainers.BpeTrainer(vocab_size=20000, min_frequency=2)
tokenizer.train([
	"./path/to/dataset/1.txt",
	"./path/to/dataset/2.txt",
	"./path/to/dataset/3.txt"
], trainer=trainer)

# And Save it
tokenizer.save("byte-level-bpe.tokenizer.json", pretty=True)

今は、このトークナイザーを使用したいとき、これは次のように簡単です :

from tokenizers import Tokenizer

tokenizer = Tokenizer.from_file("byte-level-bpe.tokenizer.json")

encoded = tokenizer.encode("I can feel the magic, can you?")
 

以上



AI導入支援 #2 ウェビナー

スモールスタートを可能としたAI導入支援   Vol.2
[無料 WEB セミナー] [詳細]
「画像認識 AI PoC スターターパック」の紹介
既に AI 技術を実ビジネスで活用し、成果を上げている日本企業も多く存在しており、競争優位なビジネスを展開しております。
しかしながら AI を導入したくとも PoC (概念実証) だけでも高額な費用がかかり取組めていない企業も少なくないようです。A I導入時には欠かせない PoC を手軽にしかも短期間で認知度を確認可能とするサービの紹介と共に、AI 技術の特性と具体的な導入プロセスに加え運用時のポイントについても解説いたします。
日時:2021年10月13日(水)
会場:WEBセミナー
共催:クラスキャット、日本FLOW(株)
後援:働き方改革推進コンソーシアム
参加費: 無料 (事前登録制)
人工知能開発支援
◆ クラスキャットは 人工知能研究開発支援 サービスを提供しています :
  • テクニカルコンサルティングサービス
  • 実証実験 (プロトタイプ構築)
  • アプリケーションへの実装
  • 人工知能研修サービス
◆ お問合せ先 ◆
(株)クラスキャット
セールス・インフォメーション
E-Mail:sales-info@classcat.com