Web ニューラルネットワーク API

W3C 勧告候補草案,

この文書の詳細
このバージョン:
https://www.w3.org/TR/2026/CRD-webnn-20260910/
最新の公開バージョン:
https://www.w3.org/TR/webnn/
編集者草案:
https://webmachinelearning.github.io/webnn/
以前のバージョン:
履歴:
https://www.w3.org/standards/history/webnn/
実装報告:
https://wpt.fyi/results/webnn?label=master&label=experimental&aligned&q=webnn
テストスイート:
https://github.com/web-platform-tests/wpt/tree/master/webnn
フィードバック:
GitHub
仕様内に記載
編集者:
Ningxin Hu (Intel Corporation)
Dwayne Robinson (Microsoft Corporation)
元編集者:
Chai Chaoweeraprasit (Microsoft Corporation)
その他:
実装状況, 解説, サンプル

Copyright © 2026 World Wide Web Consortium. W3C® liability, trademark and permissive document license rules apply.

概要

この文書では、ニューラルネットワーク推論のハードウェアアクセラレーション用に特化した低レベル API について説明します。

この文書のステータス

このセクションでは、この文書の公開時点におけるステータスについて説明します。現在の W3C 公開文書の一覧およびこの技術報告書の最新版は、W3C 標準および草案の索引にあります。

この文書は、 Web Machine Learning ワーキンググループによって 勧告 トラックを使用した候補勧告草案として公開されました。

候補勧告としての公開は、W3C およびそのメンバーによる承認を意味するものではありません。候補 勧告草案には、ワーキンググループが後続の候補勧告スナップショットに 含めることを意図している、以前の候補勧告からの変更が統合されています。

これは草案文書であり、いつでも他の文書によって更新、置換、または廃止される可能性があります。この文書を 作業中の文書以外として引用することは不適切です。

Web Machine Learning ワーキンググループは、グループがまだ対処していないすべてのバグ 報告の一覧を管理しています。 未解決の問題に対する仕様テキストの提案を含むプルリクエストを強く推奨します。

この文書は、 W3C 特許ポリシーの下で活動するグループによって作成されました。 W3C は、グループの成果物に関連して行われた すべての 特許開示の公開一覧を管理しています。そのページには、 特許を開示するための手順も含まれています。ある個人が、 必須 クレームを含むと考える特許について実際の知識を有する場合、その個人は W3C 特許ポリシーの セクション 6に従ってその情報を開示しなければなりません。

この文書は、2025 年 8 月 18 日版 W3C プロセス文書によって管理されます。

候補勧告スナップショット 2024 年 4 月 11 日から 2026 年 1 月 22 日までの間に、WebNN 仕様は 100 件を超える重要な変更を伴う大幅な進化を遂げました。特に注目すべき 追加には、Transformer のサポートを強化する第 3 波の演算子、バッファ 共有用の MLTensor API、および新しい抽象デバイス選択メカニズムが含まれます。API サーフェスは最新化され、 より幅広い実装経験と開発者からの フィードバックに基づいて相互運用性が改善されました。このバージョンの仕様では、 フィンガープリンティング対策を含むセキュリティおよびプライバシー上の考慮事項が強化され、新しいアクセシビリティ上の考慮事項も追加されています。これらの変更は、 開発者の利便性の向上、より幅広いバックエンド 互換性、および標準への適合性を備え、製品利用に向けて仕様が成熟していることを反映しています。詳細については、§ 14 変更を参照してください。

この文書は常時保守および更新されています。この文書の一部は作業中であり、 今後の改善が改訂された候補勧告草案およびスナップショットに反映されることが期待されています。

勧告案への移行を要求する前に、 ワーキンググループは、以下を実証することを目指します。

1. はじめに

Web Neural Network API は、オペレーティングシステムおよび基盤となるハードウェアプラットフォームの 機械学習機能を、プラットフォーム固有の機能に依存することなく利用できる、 Web に適したハードウェア非依存の抽象化レイヤーを定義します。この抽象化レイヤーは、主要な機械学習 JavaScript フレームワークの要件に対応し、ML 分野に精通した Web 開発者がライブラリの助けを借りずに カスタムコードを記述することも可能にします。

図解による概要については、解説文書を参照してください。

2. ユース ケース

2.1. アプリケーションのユースケース

このセクションでは、ニューラルネットワーク推論の ハードウェアアクセラレーションに関するアプリケーションレベルのユースケースを示します。これらのユースケースに含まれるすべてのアプリケーションは、 事前学習済みのディープニューラルネットワーク (DNN) [models] 上に構築できます。

注: ここで説明するユースケースの一部は、 その性質上、プライバシーを侵害する可能性があることに注意してください。このようなユースケースで API を使用することを計画している開発者は、 API がユーザーの利益のために、ユーザーが理解し承認した目的で使用されることを 確保すべきです。また、 Web 機械学習の倫理原則 [webmachinelearning-ethics] を適用し、透明性、データ最小化、ユーザーによる制御などの 適切なプライバシーリスク軽減策を実装すべきです。

注: § 3 アクセシビリティ上の 考慮事項では、これらのユースケースのアクセシビリティを向上させる方法に関する指針を提供しています。

2.1.1. 人物検出

ユーザーが Web ベースのビデオ会議アプリケーションを開いていますが、一時的に 部屋を離れます。アプリケーションは、物体検出を使用して、ユーザーが PC の前にいるかどうかを監視します（たとえば、単一の DNN を使用する [SSD] や [YOLO] などの物体検出手法を使用して）、 カメラ入力フレーム内の人物を含む領域を 検出します。

ユーザーが戻ると、アプリケーションは自動的にそのユーザーを検出し、 他のオンラインユーザーに、そのユーザーが現在アクティブであることを通知します。

2.1.2. セマンティックセグメンテーション

オフィス内に利用可能な会議室がないため、ユーザーは自分のデスクから Web ベースのビデオ会議アプリケーションを介して 電話会議に参加します。電話会議中、 ユーザーは自分の部屋や背景にいる人々が 見えることを望みません。他の人々や周囲のプライバシーを保護するため、 アプリケーションは [DeepLabv3+]、 [MaskR-CNN] または [SegAny] などの機械学習モデルを実行して、 画像を意味的にセグメントへ分割し、 他の人物や背景を表すセグメントを別の画像で置き換えます。

2.1.3. 骨格検出

Web ベースのビデオ会議アプリケーションは、 [PoseNet] などのリアルタイム人物姿勢 推定を可能にする機械学習モデルを実行してユーザーの骨格姿勢を追跡し、そのユーザーの ジェスチャーやボディランゲージを認識します。ユーザーが 手を上げると、マイクのミュートが自動的に解除され、電話会議で 発言を開始できます。

2.1.4. 顔認識

会議室には複数の人がおり、Web ベースのビデオ会議アプリケーションを使用して オンライン会議に参加します。アプリケーションは、 物体検出（たとえば、[SSD] などの物体検出手法）を使用して参加者の顔を検出し、 [FaceNet] など、 2 つの顔が同一であるかどうかを検証する機械学習モデルを実行して、各顔が 前回の会議に存在していたかどうかを確認します。

2.1.5. 顔ランドマーク検出

ユーザーはオンライン眼鏡店で、自分によく似合う新しい眼鏡を 探したいと考えています。オンラインストアは、Face Alignment Network [FAN] などの機械学習モデルを実行する Web ベースの試着シミュレーターを提供し、 目、鼻、口などの顔ランドマークを検出します。ユーザーが眼鏡を選択すると、シミュレーターは 顔画像上で検出された目の位置に、選択した眼鏡を 適切に描画します。

2.1.6. スタイル変換

ユーザーがオンラインストアで化粧品を探しており、どの色が 自分の顔に合うかを考えています。オンラインストアは化粧品の顔メイクのサンプル画像を表示し、 [ContextualLoss] や [PairedCycleGAN] などの機械学習モデルを実行して、サンプルのメイク画像の メイクスタイルをユーザーの顔画像へ転送するメイクシミュレーターを提供します。ユーザーはシミュレーターで、 選択したメイクが自分の顔でどのように見えるかを確認できます。

2.1.7. 超解像

Web ベースのビデオ会議アプリケーションが相手からビデオストリームを受信していますが、 ネットワークの輻輳によりビデオの解像度が低下します。知覚される 映像品質の低下を防ぐため、アプリケーションは [SRGAN] などの超解像用機械学習モデルを実行して、 より高解像度のビデオフレームを生成します。

2.1.8. 画像キャプショニング

アクセシビリティを向上させるため、Web ベースのプレゼンテーションアプリケーションは、 [im2txt] など、プレゼンテーションスライドの説明文を予測する機械学習モデルを実行して、 自動画像キャプショニングを提供します。

2.1.9. テキストから画像への変換

画像は現代の Web 体験の中核をなす要素です。プライバシーを保護する方法で テキスト入力に基づいて画像を生成できる機能は、Web アプリケーションやコンテンツの視覚的な パーソナライズおよび適応を可能にします。たとえば、Web アプリケーションは、Web ページ上の自然言語による説明、 またはユーザーがテキストプロンプト内で提供した説明を入力として使用し、その テキストの説明に一致する画像を生成できます。このテキストから画像へのユースケースは、 潜在拡散モデルアーキテクチャ [LDM] によって実現され、追加の テキストから画像へのユースケースの基盤となります。たとえば、Web ページ上の既存の 画像の一部を新たに生成したコンテンツを使用して選択的に変更するインペインティングや、 その逆で、元の画像を元の 寸法を超えて拡張し、空いた領域を生成コンテンツで埋めるアウトペインティングがあります。

2.1.10. 機械翻訳

さまざまな国の複数の人々が、Web ベースのリアルタイム テキストチャットアプリケーションを介して会話しています。アプリケーションは、 [GNMT] や [OpenNMT] など、 各テキストを異なる言語へ翻訳する 機械学習モデルを使用して会話を翻訳します。

2.1.11. 感情分析

ユーザーが Web ベースのリアルタイムテキストチャットアプリケーションを介して友人と会話していますが、 友人の顔を見ることができないため、その友人がどのように感じているのか 気になっています。アプリケーションは、 [DeepMoji] など、入力テキストから感情を推論する機械学習 モデルを使用して友人の感情を分析し、推定された感情を表す 絵文字を表示します。

2.1.12. 動画要約

Web ベースのビデオ会議アプリケーションは受信したビデオストリームを記録し、 保存する録画映像データを削減する必要があります。アプリケーションは、 [Video-Summarization-with-LSTM] などの 動画要約用機械学習モデルを使用して、録画映像の短縮版を生成します。

2.1.13. ノイズ抑制

Web ベースのビデオ会議アプリケーションは受信した音声ストリームを記録しますが、 通常、背景ノイズは至るところに存在します。アプリケーションは、 [RNNoise] などのリカレントニューラルネットワークを使用したリアルタイム ノイズ抑制を活用して、赤ちゃんの泣き声や犬の鳴き声などの背景にある動的ノイズを 抑制し、ビデオ会議における 音声体験を改善します。

2.1.14. 音声認識

音声認識は、speech to text とも呼ばれ、話された言語を認識して テキストへ変換することを可能にします。音声認識の用途例には、 文字起こし、自動翻訳、マルチモーダルインタラクション、 リアルタイム字幕、仮想アシスタントなどがあります。音声認識は 音声コンテンツのアクセシビリティを向上させ、そのような コンテンツをプライバシーを保護する方法でテキスト形式として扱えるようにします。一般的な ユースケースの例には、リアルタイム字幕を使用して動画を視聴したりオンライン会議に参加したりすることが 含まれます。[Whisper] などのモデルは、精度 と堅牢性において人間に近づいており、このようなユースケースのアクセシビリティを向上させるうえで適しています。

2.1.15. テキスト生成

さまざまなテキスト生成ユースケースは、大規模言語モデル (LLM) によって実現されます。LLM は、 テキスト列における次の要素を予測する一般的な能力が 必要となるタスクを実行できます。この種類のモデルは、テキストを翻訳したり、テキスト入力に基づいて 質問に回答したり、大量のテキストを要約したり、テキスト入力に基づいて テキスト出力を生成したりできます。LLM は、RNN、CNN、LSTM アーキテクチャに基づく 従来のモデルと比べて優れた性能を実現し、このセクションで説明する その他の多くのユースケースの性能もさらに向上させます。 LLM の例には、[t5-small]、 [m2m100_418M]、[gpt2]、および [llama-2-7b] があります。

2.1.16. 偽動画の検出

ユーザーが Web 上で「ディープフェイク」によって生成されたリアルな偽動画にさらされています。 偽動画では、話者の顔を大統領の顔に差し替えて、 ユーザーを政治的に扇動したり、ユーザーの意見を操作したりすることがあります。 [FaceForensics++] などのディープフェイク検出 アプリケーションは動画を分析し、ユーザーを 偽動画や偽画像から保護します。ユーザーが Web 上で偽動画を視聴すると、 検出アプリケーションはリアルタイムでその偽動画について警告します。

2.2. フレームワークのユースケース

このセクションでは、ニューラルネットワーク推論のハードウェアアクセラレーション用に特化した低レベル API の フレームワークレベルのユースケースをまとめます。機械学習 フレームワークが Web Neural Network API (WebNN API) の主要な利用者となり、WebNN API を通じて公開される低レベルの詳細は 一般的な Web 開発者から抽象化されることが想定されています。ただし、 機械学習に特別な関心と能力を持つ Web 開発者は、 高レベルの ML フレームワークではなく、WebNN API と直接連携したいと考えることも想定されています。

2.2.1. カスタムレイヤー

Web アプリケーション開発者が WebNN API 上で DNN モデルを実行したいと考えています。しかし、 [LeakyReLU]、[ELU] などの一部の活性化関数が WebNN API に含まれていないことが分かりました。この問題に対処するため、 WebNN API 上に追加の活性化関数の カスタムレイヤーを構築します。 カスタムレイヤーの範囲には、活性化だけでなく畳み込み、正規化 なども含まれ得ることに注意してください。

2.2.2. ネットワーク連結

Web アプリケーションが DNN モデルを使用しており、その上位の畳み込み レイヤーと下位の全結合レイヤーのモデルデータは別々のファイルに保存されています。これは、 全結合レイヤーのモデルデータがサーバー側でのファイン チューニングにより定期的に更新されるためです。

そのため、アプリケーションは最初に両方の部分モデルファイルをダウンロードし、 それらを単一のモデルに連結します。モデルが更新されると、 アプリケーションはモデルのファインチューニング済み部分をダウンロードし、 全結合レイヤーだけをそれで置き換えます。

2.2.3. 性能適応

Web アプリケーション開発者は、モバイルデバイス上での DNN モデルの性能を 懸念しています。GPU アクセラレーションを備えていないモバイルデバイスでは 動作が遅すぎる可能性があることを確認しました。この問題に対処するため、Web アプリケーションは WebNN API を参照してアクセラレーションが利用可能かどうかを確認し、 アクセラレーションのないデバイスに対して警告を表示できるようにします。

数週間後、開発者は CPU 上でも実行可能な 小型 DNN モデルを開発しました。CPU 実行に対応するため、 CPU のみのデバイスの場合には小型モデルを読み込むよう アプリケーションを変更します。

2.2.4. 演算レベルの実行

JavaScript ML フレームワークは、ML モデルの読み込み、解釈、実行を担当します。モデルの 実行フェーズでは、フレームワークはモデルの演算を順に処理し、各演算を CPU、GPU、ML アクセラレーターなどのハードウェアデバイス上で実行します。デバイス間の不要なデータコピーを避けるため、 フレームワークは同じデバイスを選択して演算を実行します。2D 畳み込みや 行列乗算など、計算負荷の高い演算については、フレームワークは WebNN API を使用し、選択したデバイスで利用可能な ML 固有のアクセラレーションを使用して実行します。

2.2.5. リアルタイム動画処理との統合

WebRTC ベースのビデオ会議のユーザー体験は、リアルタイム動画処理を使用して向上させることができます。たとえば、 § 2.1.2 セマンティック セグメンテーションモデルを使用して実装された背景ぼかしは、ユーザーのライブカメラ映像の背景をぼかします。このユースケースの性能 要件を満たすため、WebNN API は、メディアパイプラインを構成する他の Web API のプリミティブと統合され、 WebNN API に基づくリアルタイム動画ストリームの変換を可能にします。

3. アクセシビリティ上の考慮事項

このセクションでは、ニューラルネットワーク推論の ハードウェアアクセラレーションによって実現される § 2.1 アプリケーションのユースケース のアクセシビリティを向上させる方法について、Web 制作者に指針を提供します。この指針は、この 仕様で概説する特定のユースケースを超えて一般化できるものであり、Web 制作者には、さらなるアクセシビリティ指針について [wcag] を、 また倫理原則の文脈におけるデジタルアクセシビリティについて § 6 倫理上の考慮事項 を参照することを推奨します。

§ 2.1.8 画像キャプショニングは、キャプションが スクリーンリーダーおよびその他の支援技術 (AT) のユーザーに提示されることを確保することで改善できます。Web 制作者には、 生成された画像キャプションを、それぞれ対応する画像に標準の alt 属性、またはページの初回読み込み時に説明が更新されるのか、 その後ユーザー操作の結果として更新されるのかに応じたその他の手段によって、意味的に関連付けることを推奨します。

§ 2.1.11 感情分析はユーザーに誤ったラベルを付け、それによって誤分類し、 差別的な体験につながる可能性があります。Web 制作者には信頼度スコアを公開し、ユーザーに この機能をオフにする選択肢を提供することを推奨します。

§ 2.1.13 ノイズ抑制で強力なフィルターを使用すると、 構音障害のあるユーザーの発話まで除去され、字幕や認識が失敗する可能性があります。Web 制作者には、 バイパスまたは感度調整機能を公開し、ライブ字幕が有効なときにはノイズ抑制を固定的に適用しないことを推奨します。

§ 2.2.5 リアルタイム動画処理との統合における 背景ぼかしを利用したセグメンテーションは注意をそらす要素の除去に役立ちますが、 読唇やライブ字幕を損なうほど大きな遅延を追加する可能性があります。Web 制作者には、ユーザー向けにキーボード およびスクリーンリーダーで操作可能な「背景ぼかしオン/オフ」コントロールを、他のアクセシビリティ/メディア 設定の近くに表示する機能を提供することを推奨します。

§ 7.2 デバイス選択により、Web 制作者は 実行速度と消費電力に関する優先設定を示すことができます。実装者には、 低性能またはバッテリー消費に敏感なデバイスを使用している人でも、 特に携帯型 AAC や視線入力 環境で、字幕やその他の重要なアクセシビリティ機能の応答性を維持できるよう、ブラウザー UI で Web 制作者のヒントをユーザーが上書きできるようにすることを推奨します。

4. セキュリティ上の考慮事項

この仕様は、ニューラルネットワーク推論のハードウェアアクセラレーション用の低レベル API を定義します。この API は、 ユーザーのコンピューターへの低レベルアクセスを許可するため、強力な機能 [POWERFUL-FEATURES] とみなされます。強力な機能に求められる 認証および機密性の要件を満たし、中間者 攻撃を防止するため、この仕様で定義されるすべてのインターフェイスはセキュアコンテキストでのみ利用できます。

この API は、§ 7.5 Permissions Policy との統合を使用するすべてのクロスオリジンフレームでデフォルトで無効です。これにより、 埋め込み元ページが許可を与えるポリシーを明示的に設定しない限り、 サードパーティコンテンツがこの API を使用することを防ぎます。

この API では、WebGPU 仕様で定義された GPUDevice から MLContext を作成できます。 このコンテキストのセキュリティ特性の詳細については、WebGPU のセキュリティ上の考慮事項を参照してください。

この API は GPU、CPU、および専用 ML アクセラレーターハードウェアを横断する抽象化を提供します。GPU を使用する場合は、WebGPU と同様の サービス拒否に関する考慮事項が 適用されます。CPU または専用 ML アクセラレーターを使用する場合、潜在的なリソース競合の種類は 異なり、その軽減策は実装および構成に依存します。実装は、 サイトが不当に大量のシステム リソースを使用することを防ぐためにプラットフォームで利用可能なあらゆる仕組みを使用すべきです。これらの計算ユニットは共有リソースであり、どのような計算 API の使用も、 完全に負荷のかかったシステムでは全体的な性能に影響します。

グラフが完全に構築されコンパイルされると、グラフ内の各演算への入力形状が 推論され確定します。境界チェックは、実際のデータに対してグラフを実行する compute メソッドが呼び出されたときに行われます。この段階より前には、実際のデータはコンパイル済みグラフに結び付けられません。その時点までに 推論済みのデータ形状に対して適切な境界チェックが行われることを保証する責任は、 実装にあります。

実装者への指針として、 範囲外アクセスの影響を受けやすい演算を文書化する。

実装は、定数とみなされるデータの変更に基づく制御フロー攻撃を防御しなければなりません。 たとえば、基盤プラットフォームの最適化では、計算全体を通して重みが変更されないことを前提とする場合があります。 API が、計算中に重みを保持するバッファの内容を変更することを許可した場合、 その最適化の前提は無効になり、基盤 プラットフォームで未定義の動作が発生します。この API は常にバッファをコピーまたは転送することで、スクリプトからのこの種の攻撃を軽減しますが、 実装は、定数と仮定されるデータのプロセス分離などの追加の防御も検討すべきです。

将来への備えとして、API 設計では、一般的にエミュレート可能な特定の演算を、 互換性を損なうことなく、セキュリティ、性能、またはその他の理由で非推奨にできます。これは、 この仕様で定義されるより小さなプリミティブ演算を用いて定義される高レベル関数によって可能になります。 これにより、高レベル関数のネイティブ実装を polyfill 実装に置き換えることができます。

CPU がレンダラーを実行するプロセス間で共有されている 現在の状態を考慮し、サイドチャネル攻撃の 実現可能性を調査する。

攻撃者が欠陥を含む可能性のある特定の実装を標的にできないようにするため、§ 7.2 デバイス選択メカニズムはヒントにすぎず、 具体的なデバイス選択は実装に委ねられます。たとえばユーザーエージェントは、 既知の脆弱性を持つデバイスではモデルを決して実行しないことを選択できます。さらなる軽減策として、デバイス列挙メカニズムは 定義されていません。

ヒントにより懸念は部分的に 軽減される。追加の軽減策を調査する。

API 設計は、コンパイル済み計算グラフの攻撃対象領域を最小限にします。さまざまな演算を保持する MLGraphBuilder インターフェイスはデータ定義 API であり、それ自体は何も実行せず、 データを構築するだけです。したがって、攻撃の可能性は、MLContext.dispatch() メソッドを呼び出して実行する前にデータをグラフへ結び付けるときに限定されます。これにより実装者は、MLContext.dispatch() メソッドの堅牢化に集中できます。たとえば、データ境界を遵守し、境界が 守られていない場合に適切に失敗することを保証できます。

高解像度時間を測定するために特別に設計された Web API は、 解像度の低減、ジッターの追加、不正使用の検出、API 呼び出しのスロットリングなどの手法を使用してタイミング攻撃を軽減します [hr-time-3]。WebNN 実装の 実際の展開では、タイミング攻撃を 非現実的なものにするのに十分なジッターが生じる可能性があります（たとえば IPC を使用するため）が、実装者には、 タイミング攻撃に対して実装を検討し、テストすることを推奨します。

注: Unicode シーケンスに関連するセキュリティリスクについては、 label USVString の定義の文脈で説明されています。

4.1. 新しい演算のガイドライン

このセクションは非規範的です。

この仕様で定義される演算を安全に実装できる形で設計するため、 このセクションには、潜在的な 実装上の問題を減らすために演算をどのように定義することが期待されるかについてのガイドラインを含めます。これらのガイドラインは、業界のベスト プラクティスに合わせて時間とともに進化することが期待されます。

一般に、新しい機能を追加する際には、 Technical Architecture Group および Privacy Interest Group による [security-privacy-questionnaire] に文書化されているセキュリティとプライバシーへの影響を常に考慮してください。

5. プライバシー上の考慮事項

この API は、機密性の高いユーザー データをブラウザーのサンドボックス内に保持することで、クラウドベースの推論手段よりもプライバシーを向上させます。画像、音声、ビデオストリーム、その他の個人 情報などの入力データはユーザーのデバイスから一切外部へ送信されず、リモート サーバーへのデータ送信やサードパーティによるデータ処理に関連するリスクを排除します。

ただし、ハードウェアアクセラレーション機能と密接に連携する強力なローカル計算 API として、 WebNN API は性能最適化とプライバシー保護のバランスを取る必要があります。この API には、 効果的な機械 学習推論機能を可能にしながらフィンガープリンティングを軽減する、複数のプライバシー保護措置が含まれています。

5.1. フィンガープリンティング

設計上、この API は、特定された § 2 ユースケースに、最良の性能と結果の信頼性で対応するために必要な最小限の情報のみを公開することを目的としています。まず、この API は 標準化によってフィンガープリンティングを軽減します。すなわち、多様な プラットフォーム API 間で一貫した動作を定義し、適合実装間で基盤ハードウェアの差異に関する 情報漏えいを最小限にします。これは以下によって実現されます。

全体的な設計により、実装は異なるプラットフォーム間で一貫したインターフェイスを維持しながら、 必要な機能を提供できます。プラットフォーム固有の詳細を抽象化することで、API は、 基盤となるアクセラレーションが CPU、GPU、または専用 ML ハードウェアのいずれによって提供されるかにかかわらず、プライバシーを保護する予測可能な動作を提供できます。

注: MLContextOptions は現在活発に開発中であり、その設計は、さらなる実装 経験や、より広範な Web コミュニティからの新しいユースケースを踏まえて変更されることが見込まれています。

MLGraph.devices API 拡張は、グラフが完全に構築され コンパイルされた後、実行に実際に選択されたデバイスを公開するために提案されています。この API 拡張のプライバシーへの影響は 調査中です。[Issue #836]

5.2. 実行時間分析

演算のタイミング特性は、基盤ハードウェアの 性能に関する一定の間接情報を提供する可能性があり、これはあらゆる計算 API に内在する特性です。特定の状況では、実行時間分析によって、 ある基盤プラットフォームのニューラルネットワークハードウェアアクセラレーション 機能の性能を、別の基盤プラットフォームとの比較で間接的に明らかにできる場合があります。タイミング攻撃に関する詳細については、§ 4 セキュリティ上の 考慮事項も参照してください。

注: グループは、提案されている 実行時間分析のフィンガープリンティングベクトルおよび軽減策について、さらなる意見を歓迎しています。

5.3. WebGPU との比較

WebGPU とは異なり、この API は本質的にカスタムシェーダーの作成をサポートしません。そのため、 シェーダーキャッシュやその他の永続データに依存するタイミング攻撃の影響を受けにくくなっています。この API は、既存の シェーダーおよびブラウザーまたは基盤 OS の低レベルプリミティブ上に構築されます。 GPUDevice と連携する Web 開発者は、WebGPU コンパイルキャッシュに関する考慮事項を認識していることが期待されます。

WebGPU API は、マシン固有のアーティファクトを プライバシー上の考慮事項として特定しています。同様に、WebNN API の計算ユニットのスケジューリングも、特定の状況では フィンガープリントを生じさせる可能性があります。ただし、WebGPU と同様に、このようなフィンガープリントは各ベンダーのほとんどまたはすべての デバイスで同一であるため、懸念は軽減されます。さらに、ソフトウェア実装を使用して このようなアーティファクトをさらに除去できます。

一般に、この API の実装者は、適用可能な場合には WebGPU のプライバシー上の考慮事項を実装に適用することが期待されます。

6. 倫理上の考慮事項

ワーキンググループは、Web 上で機械学習を使用することに関連する倫理上の問題の文書化を開始しており、 規範的な仕様で考慮すべき軽減策を特定する助けとしています。ワーキンググループは、 Web 機械学習の倫理原則に関する文書 [webmachinelearning-ethics] を公開および維持し、 専用の GitHub リポジトリを通じて、より広範なコミュニティからの貢献を受け付けています。

7. プログラミングモデル

7.1. 概要

ニューラルネットワークの中心には、数学的演算の 計算グラフがあります。 これらの演算は、コンピュータービジョン、自然言語処理、ロボティクスにおける 現代の機械学習技術の構成要素です。 WebNN API は、ニューラルネットワークの計算 グラフを構築、コンパイル、実行するための仕様です。

MLGraph インターフェイスは、不変のコンパイル済み計算グラフ（つまりモデル）を表します。

MLGraphBuilder インターフェイスは、計算グラフ（その グラフ） を構築するためのビルダー（ファクトリー）として機能し、その後コンパイルされて MLGraph が作成されます。

WebNN では、計算グラフは、データに作用しグラフのノードとなる 演算子で構成されます。MLOperand は、 計算グラフ内を流れるデータの表現であり、グラフのエッジです。MLOperand には、 計算グラフの、推論用の 入力値、推論に使用される 定数（学習済み重みを含む）、 推論中に計算される中間値（多くの場合、活性化と呼ばれます）、および推論の出力 値が含まれます。演算子の 入力は 1 つ以上の MLOperand です。 演算子の 出力は 1 つ以上の MLOperand です。演算子には、その動作を制御する演算子固有の パラメーターがあり、0 個以上の 活性化関数を含む場合があります。

MLGraphBuilder インターフェイスの重要な部分は、gemm() や relu() などのメソッドであり、計算の実行時に入力データに対して実行する実際の演算を表す 演算子を作成し、新しい MLOperand を返してその演算子を保持します。MLOperand を作成するメソッドは、あらゆる 入力と 活性化を 演算子へ接続します。各メソッド呼び出しは、他の MLOperand の値を変更することなく、個別の新しい値を返します。

演算子は ラベルを持ちます。これは、例外メッセージなどの診断情報に含めることができる文字列です。演算子が作成されると、その ラベルは 実装定義の方法で初期化され、渡された label を含む場合があります。

dispatch() 中にエラーを報告するためのメカニズムの追加を検討する。 [Issue #778]

推論時には、すべての MLOperand が テンソル（実際のデータ）にバインドされます。テンソルは本質的には多次元配列です。 テンソルの表現は実装依存ですが、通常は何らかのバッファ （メモリ）に保存された配列データと、その配列データを記述するメタデータ（形状など）を含みます。

計算グラフ内の演算は関数的意味論を持ちます。これにより実装は、 複数のテンソル間で配列データを共有できる可能性があります。たとえば、 reshape や slice などの演算の実装は、入力テンソルと同じバッファを共有する 入力テンソルのビューを返す場合があります。（reshape の場合、 データ全体が共有されますが、slice の場合は入力データの一部が共有されます。） 実装は、上記のようなビューを中間値に使用する場合があります。

実行前に、指定された 1 つ以上の出力を計算するために使用される計算グラフを 変換、コンパイル、最適化する必要があります。コンパイル手順の主な目的は、 演算やループの融合など、2 つ以上の演算にまたがる最適化を可能にすることです。ユーザーエージェントは、 グラフ変換中にもこれらの最適化を実行する場合があります。

MLGraphBuilder.build() メソッドは、呼び出し元スレッドをブロックせずにバックグラウンドでグラフをコンパイルし、MLGraph に解決される Promise を返します。各 MLGraphBuilder が構築できる MLGraph は最大 1 つです。

MLGraph の基盤実装は、MLGraphBuilder の 演算子および MLOperand に対応する、プラットフォーム固有の演算子とオペランドの表現で 構成されますが、それらはスクリプトからは見えず、スクリプトによって構築された グラフの合成または分解である場合があります。

MLGraph が構築されると、MLContext.dispatch() メソッドは、CPU 実行の場合には別個のワーカー スレッド上の並列タイムラインで、GPU の場合には GPU コマンドキュー上の GPU タイムラインで、グラフの実行を非同期に行います。このメソッドは、 実際の実行が別のタイムラインへオフロードされる間、呼び出し元スレッドをブロックせず 即座に返ります。呼び出し元は MLNamedTensors を使用して入力値を提供し、入力 MLOperand を それぞれの値へバインドします。呼び出し元は出力 MLOperand 用の MLNamedTensors も提供します。これらには、成功した場合にグラフ実行の結果が格納され、その結果は MLContext.readTensor(tensor) メソッドを使用してスクリプトから読み戻すことができます。この種類の実行は CPU、GPU、NPU デバイスをサポートします。

7.2. デバイス選択

MLContext インターフェイスは、ニューラルネットワーク実行のグローバル状態を表します。重要なコンテキスト状態の 1 つは、 リソースを管理し、ニューラルネットワークグラフのコンパイルおよび最終的な 実行を容易にする基盤実行デバイスです。MLContextOptions を使用するデフォルトの作成方法に加えて、MLContext は、アプリケーションですでに使用中の特定の GPUDevice から作成することもできます。

GPU コンテキストが、システムメモリ内に ArrayBufferView として存在する定数または入力を含むグラフを実行する場合、 入力内容はシステムメモリから GPU メモリへ自動的にアップロードされ、グラフ実行の終了時には ArrayBufferView の出力バッファのシステムメモリへダウンロードされます。このデータのアップロードおよびダウンロードサイクルは、 GPU の場合のように、実行デバイスがデータをシステムメモリからコピーし、再び システムメモリへ戻す必要がある場合にのみ発生します。デバイスが CPU デバイスの場合には発生しません。さらに、 グラフ実行の結果は既知のレイアウト形式になります。実行中、グラフ内の中間結果について ネイティブメモリアクセスパターン向けに最適化される場合がありますが、グラフの最後の演算の出力は、 呼び出し元から見た期待される動作を維持するため、グラフの最後で内容を 既知のレイアウト形式へ戻す必要があります。

MLContext が MLContextOptions を使用して作成される場合、ユーザーエージェントはこれらのオプションを考慮して、 基盤となる実行デバイスを選択して作成します。

基盤プラットフォームに応じて、ユーザーエージェントは CPU、NPU、GPU デバイスの異なる 組み合わせを選択する場合があります。

この設計の経緯と根拠については、デバイス 選択の解説文書を参照してください。

7.3. 演算子

このセクションは非規範的です。

WebNN API は、主要な § 2.1 アプリケーションのユースケースに対応する、 よく知られた CNN、RNN、Transformer、および生成 モデルで必要となる一連の演算子を定義します。各演算子の詳細は、この仕様の規範的なセクションで、演算子 名のアルファベット順に定義されています。これらの演算子は、API サーフェスの機能的な概要を示すため、 以下の非規範的な表でその機能に基づいてカテゴリに分類されています。

注: 一部の演算子は複数のカテゴリに属します。たとえば、 clamp() は数学関数であると同時に、活性化としても使用されます。

カテゴリ別の演算子
カテゴリ 演算子​
テンソル作成 input(), constant()
テンソル操作 concat(), expand(), gather(), gatherElements(), scatterElements(), gatherND(), scatterND(), where(), pad(), reshape(), slice(), split(), transpose(), resample2d(), reverse(), tile(), triangular()
テンソル量子化 quantizeLinear(), dequantizeLinear()
テンソルキャスト cast()
数学 add(), sub(), mul(), div(), max(), min(), clamp(), pow(), abs(), ceil(), cos(), erf(), exp(), floor(), identity(), log(), neg(), reciprocal(), roundEven(), sin(), sqrt(), tan(), tanh(), sign(), clamp()
論理 equal(), notEqual(), greater(), greaterOrEqual(), lesser(), lesserOrEqual(), logicalNot(), logicalAnd(), logicalOr(), logicalXor(), isNaN(), isInfinite()
行列乗算 matmul(), gemm()
畳み込み conv2d(), convTranspose2d()
プーリング averagePool2d(), l2Pool2d(), maxPool2d()
活性化 clamp(), elu(), gelu(), hardSigmoid(), hardSwish(), leakyRelu(), linear(), prelu(), relu(), sigmoid(), softmax(), softplus(), softsign(), tanh()
正規化 batchNormalization(), instanceNormalization(), layerNormalization()
リダクション argMin(), argMax(), reduceL1(), reduceL2(), reduceLogSum(), reduceLogSumExp(), reduceMax(), reduceMean(), reduceMin(), reduceProduct(), reduceSum(), reduceSumSquare(), cumulativeSum()
リカレントニューラルネットワーク gruCell(), gru(), lstmCell(), lstm()

7.4. タスクソース

ML タスクソースは、 MLGraph の非同期コンパイルおよび実行、ならびに MLContext の作成に関連するすべての タスクに使用される タスクソースです。

グローバルオブジェクト global と一連の手順 steps が与えられたとき、ML タスクをキューに入れるには、global および steps を指定して、ML タスクソース上で グローバルタスクをキューに入れます。

7.5. Permissions Policy との統合

この仕様は、 "webnn" という文字列によって識別される ポリシー制御機能を定義します。 その デフォルト許可リストは 'self' です。

8. API

8.1. navigator.ml インターフェイス

ML オブジェクトは、 Window および WorkerGlobalScope コンテキストで、それぞれ Navigator および WorkerNavigator インターフェイスを介して利用でき、navigator.ml を通じて公開されます。 

interface mixin NavigatorML {
  [SecureContext, SameObject] readonly attribute ML ml;
};
Navigator includes NavigatorML;
WorkerNavigator includes NavigatorML;

8.2. ML インターフェイス

enum MLPowerPreference {
  "default",
  "high-performance",
  "low-power"
};

dictionary MLContextOptions {
  MLPowerPreference powerPreference = "default";
  boolean accelerated = true;
};

[SecureContext, Exposed=(Window, Worker)]
interface ML {
  Promise<MLContext> createContext(optional MLContextOptions options = {});
  Promise<MLContext> createContext(GPUDevice gpuDevice);
};

8.2.1. MLContextOptions

注: MLContextOptions は現在活発に開発中であり、さらなる実装 経験や、より広範な Web コミュニティからの新しいユースケースを踏まえて設計が変更されることが見込まれています。ワーキンググループは、 フォールバックデバイス、優先順位を持つ複数のデバイス、または特定のデバイスの 除外を定義できるようにする追加の API 制御を検討しています。議論中のその他の考慮事項には、エラー処理、最終的な フォールバック、および量子化演算子が含まれます。これらの設計上の考慮事項に関する Web 開発者、ライブラリ作者、OS およびハードウェアベンダー、その他の関係者からのフィードバックを GitHub で歓迎します。フィンガープリンティングに関する 追加の議論については § 5 プライバシー上の考慮事項を参照してください。

powerPreference オプションは MLPowerPreference であり、消費電力に関するアプリケーションの 優先設定を示します。これは次のいずれかです。

"default"
ユーザーエージェントに最も適した動作を選択させます。
"high-performance"
消費電力よりも実行速度を優先します。
"low-power"
実行速度などの他の考慮事項よりも消費電力を優先します。

accelerated オプションは、大規模並列アクセラレーションに関するアプリケーションの 優先設定を示します。このオプションの優先度は powerPreference より低くなります。 true（デフォルト）に設定すると、基盤プラットフォームは、powerPreference にも応じて、GPU や NPU など、利用可能な 大規模並列アクセラレーターの使用を試みます。 false に設定すると、アプリケーションは CPU 推論を優先することを示します。たとえば powerPreference が "high-performance" であり、accelerated が false である場合のように入力が矛盾している場合、実装は基盤 プラットフォームで利用可能な最良の一致を選択します（たとえば高性能 CPU モードを使用するか、accelerated は powerPreference より優先度が低いため無視します）。

8.2.2. createContext()

引数: 戻り値: MLContext。
レルム realm および options（GPUDevice または MLContextOptions） が与えられたときに コンテキストを 作成するには、次の手順を実行します。

  1. context を realm 内の新しい MLContext とします。

  2. options が GPUDevice オブジェクトである場合、次を行います。

    1. context.[[contextType]] を "webgpu" に設定します。

    2. context.[[powerPreference]] を "default" に設定します。

    3. context.[[accelerated]] を true に設定します。

  3. それ以外の場合:

    1. context.[[contextType]] を "default" に設定します。

    2. context.[[lost]] を realm 内の 新しい promise に設定します。

    3. options["powerPreference"] が存在する場合、context.[[powerPreference]] を options["powerPreference"] に設定します。

    4. それ以外の場合、context.[[powerPreference]] を "default" に設定します。

    5. options["accelerated"] が存在する場合、context.[[accelerated]] を options["accelerated"] に設定します。

    6. それ以外の場合、context.[[accelerated]] を true に設定します。

  4. ユーザーエージェントが context.[[contextType]] をサポートできない場合、失敗を返します。

  5. context を返します。

createContext(options) の手順は次のとおりです。

  1. global を this の関連グローバルオブジェクトとします。

  2. realm を this の関連レルムとします。

  3. global の関連付けられた Document が webnn 機能の使用を許可されていない場合、realm 内で "SecurityError" DOMException によって拒否された新しい promise を返します。

  4. promise を realm 内の新しい promise とします。

  5. 次の手順を並列に実行します。

    1. context を、realm と options が与えられたときにコンテキストを作成した結果とします。それが失敗を返した場合、 global で ML タスクをキューに入れ、 promise を "NotSupportedError" DOMException で拒否し、この手順を中止します。

    2. global で ML タスクをキューに入れ、promise を context で解決します。

  6. promise を返します。

createContext(gpuDevice) メソッドの 手順は次のとおりです。

  1. global を this の関連グローバルオブジェクトとします。

  2. realm を this の関連レルムとします。

  3. global の関連付けられた Document が webnn 機能の使用を許可されていない場合、realm 内で "SecurityError" DOMException によって拒否された新しい promise を返します。

  4. promise を realm 内の新しい promise とします。

  5. 次の手順を並列に実行します。

    1. context を、realm と gpuDevice が与えられたときにコンテキストを作成した結果とします。それが失敗を返した場合、 global で ML タスクをキューに入れ、 promise を "NotSupportedError" DOMException で拒否し、この手順を中止します。

    2. global で ML タスクをキューに入れ、promise を context で解決します。

  6. promise を返します。

8.3. MLContext インターフェイス

MLContext インターフェイスは、ニューラルネットワークの計算ワークロードおよび実行プロセスのグローバル状態を表します。各 MLContext オブジェクトには、 関連付けられた コンテキスト型および MLPowerPreference があります。 
typedef record<USVString, MLTensor> MLNamedTensors;

dictionary MLContextLostInfo {
  DOMString message;
};

[SecureContext, Exposed=(Window, Worker)]
interface MLContext {
  undefined dispatch(MLGraph graph, MLNamedTensors inputs, MLNamedTensors outputs);

  Promise<MLTensor> createTensor(MLTensorDescriptor descriptor);
  Promise<MLTensor> createExportableTensor(
    MLTensorDescriptor descriptor, GPUDevice gpuDevice);
  Promise<MLTensor> createConstantTensor(
    MLOperandDescriptor descriptor, AllowSharedBufferSource inputData);

  Promise<ArrayBuffer> readTensor(MLTensor tensor);
  Promise<undefined> readTensor(MLTensor tensor, AllowSharedBufferSource outputData);

  undefined writeTensor(MLTensor tensor, AllowSharedBufferSource inputData);

  GPUBuffer exportToGPU(MLTensor tensor);

  MLOpSupportLimits opSupportLimits();

  undefined destroy();

  readonly attribute boolean accelerated;
  readonly attribute Promise<MLContextLostInfo> lost;
};
MLContext には次の内部スロットがあります。
[[contextType]]、型は コンテキスト型。

MLContext の コンテキスト型。

[[powerPreference]]、 型は MLPowerPreference。

MLContext の MLPowerPreference。

[[accelerated]]、型は boolean。

MLContext の 処理タイプ（CPU または大規模並列処理）。

[[lost]]、型は Promise<MLContextLostInfo>。

MLContext の 基盤となる実行デバイスが利用できなくなったときに解決される Promise。

[[timeline]]

MLContext の計算ユニット上での演算の実行に関連付けられたタイムライン。 これらの演算には、計算グラフ上での推論、および MLTensor の [[data]] の変更が含まれます。

このタイムラインを より厳密に定義する。[Issue #529]

コンテキスト型は、 リソースを管理し、ニューラルネットワークグラフのコンパイルと実行を容易にする 実行コンテキストの型です。

"default"
ユーザーの優先オプションに従って作成されたコンテキスト。
"webgpu"
WebGPU デバイスから作成されたコンテキスト。
accelerated getter の手順は、this.[[accelerated]] を返すことです。
AllowSharedBufferSource bufferSource および MLOperandDescriptor descriptor が与えられたときに descriptor を用いて buffer を検証するには、次の手順を実行します。

  1. bufferSource のバイト長が descriptor のバイト長と等しくない場合、false を返します。

  2. bufferSource の型に応じて切り替えます。

    ArrayBuffer

    true を返します。

    SharedArrayBuffer

    true を返します。

    ArrayBufferView

    1. bufferSource が Uint8Array オブジェクトである場合、true を返します。

    2. bufferSource が、この 表に従って descriptor の dataType と一致する場合、true を返します。

    3. false を返します。

注: descriptor の dataType に関係なく Uint8Array を使用することは、たとえば WebAssembly.Memory インスタンスの一部など、ArrayBuffer の一部分を表現する汎用的な方法としてサポートされています。開発者には、WebNN コードを記述する際、 可読性と保守性のために、より具体的なビュー型を使用することを推奨します。

record<USVString, MLOperandDescriptor> namedDescriptors とともに MLNamedTensors namedTensors が与えられたときに descriptor を用いて tensor を検証するには:

  1. namedTensors のサイズが namedDescriptors のサイズと等しくない場合、 false を返します。

  2. namedTensors の各 name → tensor について反復します。

    1. tensor.[[isConstant]] が true の場合、false を返します。

    2. namedDescriptors[name] が存在しない場合、 false を返します。

    3. tensor.[[descriptor]] が namedDescriptors[name] と等しくない場合、false を返します。

  3. true を返します。

8.3.1. dispatch()

コンパイル済み MLGraph の計算ワークロードを、 MLContext の [[timeline]] 上にスケジュールします。

引数:

戻り値: undefined。

注: dispatch() 自体は、 グラフの実行が完了したことを示すシグナルを提供しません。代わりに、呼び出し元は出力テンソルの読み戻し結果を await できます。 以下の § 8.3.1.1 例を参照してください。

dispatch(graph, inputs, outputs) メソッドの手順は次のとおりです。

  1. graph.[[context]] が this でない場合、TypeError をスローします。

  2. graph.[[isDestroyed]] が true の場合、"InvalidStateError" DOMException をスローします。

  3. allTensors を、inputs の値を outputs の値で拡張して構成される、MLTensor のリストとします。

  4. allTensors に重複する項目が含まれている場合、TypeError をスローします。

  5. allTensors の各 tensor について反復します。

    1. tensor.[[context]] が this でない場合、TypeError をスローします。

    2. tensor.[[isDestroyed]] が true の場合、TypeError をスローします。

    3. tensor がエクスポート済みの場合、TypeError をスローします。

  6. inputs と graph.[[inputDescriptors]] が与えられたときのdescriptor を用いた tensor の検証が false を返した場合、TypeError をスローします。

  7. outputs と graph.[[outputDescriptors]] が与えられたときのdescriptor を用いた tensor の検証が false を返した場合、TypeError をスローします。

  8. 次の手順を graph.[[context]].[[timeline]] にエンキューします。

    1. 次の手順を実行しますが、this が失われた場合は中止します。

      1. inputs と outputs を指定して、graph.[[implementation]] に計算要求を発行します。

        グラフ実行中のエラーを報告するためのメカニズムを追加する。[Issue #778]

tensor を使用して定数オペランドを作成する場合、build が完了した後にその tensor を破棄することは許可されています。 実装は、そのような破棄によってコンパイル済みグラフの有効性が損なわれず、影響も受けないことを保証することが期待されます。

8.3.1.1. 例
次のコードは、MLTensor を使用して MLGraph を実行する例を示しています。 
const descriptor = {
  dataType: 'float32',
  shape: [2, 2]
};
const context = await navigator.ml.createContext();
const builder = new MLGraphBuilder(context);

// 1. 計算グラフ 'C = 0.2 * A + B' を作成する。
const constant = builder.constant(descriptor, new Float32Array(4).fill(0.2));
const A = builder.input('A', descriptor);
const B = builder.input('B', descriptor);
const C = builder.add(builder.mul(A, constant), B);

// 2. グラフをコンパイルする。
const graph = await builder.build({'C': C});

// 3. 再利用可能な入力および出力 tensor を作成する。
const [inputTensorA, inputTensorB, outputTensorC] = await Promise.all([
  context.createTensor({dataType: A.dataType, shape: A.shape, writable: true}),
  context.createTensor({dataType: B.dataType, shape: B.shape, writable: true}),
  context.createTensor({dataType: C.dataType, shape: C.shape, readable: true})
]);

// 4. 入力を初期化する。
context.writeTensor(inputTensorA, new Float32Array(4).fill(1.0));
context.writeTensor(inputTensorB, new Float32Array(4).fill(0.8));

// 5. グラフを実行する。
const inputs = {
  'A': inputTensorA,
  'B': inputTensorB
};
const outputs = {
  'C': outputTensorC
};
context.dispatch(graph, inputs, outputs);

// 6. 計算結果を読み戻す。
const result = await context.readTensor(outputTensorC);
console.log('出力値:', new Float32Array(result));  // [1, 1, 1, 1]

8.3.2. createTensor()

この MLContext に関連付けられた MLTensor を作成します。

引数:

戻り値: Promise<MLTensor>。

createTensor(descriptor) メソッドの手順は 次のとおりです。

  1. global を this の関連グローバルオブジェクトとします。

  2. realm を this の関連レルムとします。

  3. this が失われている場合、realm 内で "InvalidStateError" DOMException によって拒否された新しい promise を返します。

  4. tensor を、this と descriptor が与えられたときに MLTensor を作成した結果とします。

  5. promise を realm 内の新しい promise とします。

  6. 次の手順を this.[[timeline]] にエンキューします。

    1. 次の手順を実行しますが、this が失われた場合は中止します。

      1. descriptor を指定して tensor.[[data]] を作成し、すべてのバイトを 0 に初期化します。

      2. それが失敗した場合、global で ML タスクをキューに入れ、 promise を "UnknownError" DOMException で拒否し、この手順を中止します。

      3. それ以外の場合、global で ML タスクをキューに入れ、 promise を tensor で解決します。

    2. 中止された場合、global で ML タスクをキューに入れ、 promise を "InvalidStateError" DOMException で拒否します。

  7. promise を返します。

8.3.3. createExportableTensor()

この MLContext に関連付けられ、exportToGPU() を使用して指定された GPUDevice にエクスポートできる MLTensor を作成します。

引数:

戻り値: Promise<MLTensor>。

createExportableTensor(descriptor, gpuDevice) メソッドの手順は次のとおりです。

  1. global を this の関連グローバルオブジェクトとします。

  2. realm を this の関連レルムとします。

  3. this が失われている場合、realm 内で "InvalidStateError" DOMException によって拒否された新しい promise を返します。

  4. gpuDevice が失われている場合、realm 内で "InvalidStateError" DOMException によって拒否された新しい promise を返します。

  5. this が MLTensor を gpuDevice にエクスポートすることをサポートできない場合、realm 内で "NotSupportedError" DOMException によって拒否された新しい promise を返します。

    注: MLContext が特定の GPUDevice へのエクスポートをサポートするかどうかは実装定義であり、MLContext の コンテキスト型および 基盤プラットフォームに依存する場合があります。

  6. tensor を、this、 descriptor、および gpuDevice が与えられたときにエクスポート可能な MLTensor を作成した結果とします。

  7. promise を realm 内の新しい promise とします。

  8. 次の手順を this.[[timeline]] にエンキューします。

    1. 次の手順を実行しますが、this が失われた場合は中止します。

      1. descriptor を指定して tensor.[[data]] を作成し、すべてのバイトを 0 に初期化します。

      2. それが失敗した場合、global で ML タスクをキューに入れ、 promise を "UnknownError" DOMException で拒否し、この手順を中止します。

      3. それ以外の場合、global で ML タスクをキューに入れ、 promise を tensor で解決します。

    2. 中止された場合、global で ML タスクをキューに入れ、 promise を "InvalidStateError" DOMException で拒否します。

  9. promise を返します。

8.3.4. createConstantTensor()

この MLContext に関連付けられた定数 MLTensor を作成します。

引数:

戻り値: Promise<MLTensor>。

createConstantTensor(descriptor, inputData) メソッドの手順は次のとおりです。

  1. global を this の関連グローバルオブジェクトとします。

  2. realm を this の関連レルムとします。

  3. this が失われている場合、realm 内で "InvalidStateError" DOMException によって拒否された新しい promise を返します。

  4. descriptor が与えられたときの次元のチェックが false を返した場合、realm 内で TypeError によって拒否された新しい promise を返します。

  5. inputData と descriptor が与えられたときのdescriptor を用いた buffer の検証が false を返した場合、realm 内で TypeError によって拒否された新しい promise を返します。

  6. bytes を、inputData が与えられたときにbuffer source が保持するバイトのコピーを取得した結果とします。

  7. 表明: bytes の長さは descriptor のバイト長と等しい。

  8. tensor を、this と descriptor が与えられたときに定数 MLTensor を作成した結果とします。

  9. promise を realm 内の新しい promise とします。

  10. 次の手順を this.[[timeline]] にエンキューします。

    1. 次の手順を実行しますが、this が失われた場合は中止します。

      1. descriptor を指定して tensor.[[data]] を作成します。

      2. それが失敗した場合、global で ML タスクをキューに入れ、 promise を "UnknownError" DOMException で拒否し、この手順を中止します。

      3. bytes を tensor.[[data]] にコピーします。

      4. それが失敗した場合、global で ML タスクをキューに入れ、 promise を "UnknownError" DOMException で拒否し、この手順を中止します。

      5. それ以外の場合、global で ML タスクをキューに入れ、 promise を tensor で解決します。

    2. 中止された場合、global で ML タスクをキューに入れ、 promise を "InvalidStateError" DOMException で拒否します。

  11. promise を返します。

8.3.5. readTensor(tensor)

MLTensor の [[data]] を MLContext.[[timeline]] からスクリプトへ読み戻します。

引数:

戻り値: Promise<ArrayBuffer>。 読み取り結果を含むバッファです。

readTensor(tensor) メソッドの手順は次のとおりです。

  1. global を this の関連グローバルオブジェクトとします。

  2. realm を this の関連レルムとします。

  3. tensor.[[context]] が this でない場合、realm 内で TypeError によって拒否された新しい promise を返します。

  4. tensor.[[isDestroyed]] が true の場合、realm 内で TypeError によって拒否された新しい promise を返します。

  5. tensor.[[descriptor]].readable が false の場合、realm 内で TypeError によって拒否された新しい promise を返します。

  6. tensor がエクスポート済みの場合、realm 内で TypeError によって拒否された新しい promise を返します。

  7. promise を realm 内の新しい promise とします。

  8. promise を tensor.[[pendingPromises]] に追加します。

  9. 次の手順を tensor.[[context]].[[timeline]] にエンキューします。

    1. 次の手順を実行しますが、this が失われた場合は中止します。

      1. bytes を、tensor.[[data]] のコピーを含むバイト列とします。

      2. それが失敗した場合、global で ML タスクをキューに入れ、 次の手順を実行します。

        1. promise を tensor.[[pendingPromises]] から削除します。

        2. promise を "UnknownError" DOMException で拒否し、この手順を中止します。

      3. それ以外の場合、global で ML タスクをキューに入れ、 次の手順を実行します。

        1. promise を tensor.[[pendingPromises]] から削除します。

        2. buffer を、realm 内で bytes から ArrayBuffer を作成した結果とします。

        3. promise を buffer で解決します。

    2. 中止された場合、global で ML タスクをキューに入れ、 promise を "InvalidStateError" DOMException で拒否します。

  10. promise を返します。

8.3.6. readTensor(tensor, outputData)

readTensor(tensor) の Bring-your-own-buffer バリアントです。 MLTensor の [[data]] を、指定されたバッファへ読み戻します。

引数:

戻り値: Promise<undefined>。

readTensor(tensor, outputData) メソッドの手順は次のとおりです。

  1. global を this の関連グローバルオブジェクトとします。

  2. realm を this の関連レルムとします。

  3. tensor.[[context]] が this でない場合、realm 内で TypeError によって拒否された新しい promise を返します。

  4. tensor.[[isDestroyed]] が true の場合、realm 内で TypeError によって拒否された新しい promise を返します。

  5. tensor.[[descriptor]].readable が false の場合、realm 内で TypeError によって拒否された新しい promise を返します。

  6. tensor がエクスポート済みの場合、realm 内で TypeError によって拒否された新しい promise を返します。

  7. outputData と tensor.[[descriptor]] が与えられたときのdescriptor を用いた buffer の検証が false を返した場合、realm 内で TypeError によって拒否された新しい promise を返します。

  8. promise を realm 内の新しい promise とします。

  9. promise を tensor.[[pendingPromises]] に追加します。

  10. 次の手順を tensor.[[context]].[[timeline]] にエンキューします。

    1. 次の手順を実行しますが、this が失われた場合は中止します。

      1. bytes を、tensor.[[data]] のコピーを含むバイト列とします。

      2. それが失敗した場合、global で ML タスクをキューに入れ、 次の手順を実行します。

        1. promise を tensor.[[pendingPromises]] から削除します。

        2. promise を "UnknownError" DOMException で拒否し、この手順を中止します。

      3. それ以外の場合、global で ML タスクをキューに入れ、 次の手順を実行します。

        1. promise を tensor.[[pendingPromises]] から削除します。

        2. outputData が切り離されている場合、promise を TypeError で拒否し、この手順を中止します。

          注: 上記のdescriptor を用いた buffer の検証は、outputData が切り離されている場合に失敗しますが、 その手順とこの手順の間に outputData が切り離される可能性があります。

        3. bytes を outputData に書き込みます。

        4. promise を undefined で解決します。

    2. 中止された場合、global で ML タスクをキューに入れ、 promise を "InvalidStateError" DOMException で拒否します。

  11. promise を返します。

8.3.7. writeTensor()

MLTensor の [[data]] に、MLContext の [[timeline]] 上でデータを書き込みます。

引数:

戻り値: undefined。

writeTensor(tensor, inputData) メソッドの手順は次のとおりです。

  1. tensor.[[context]] が this でない場合、TypeError をスローします。

  2. tensor.[[isDestroyed]] が true の場合、TypeError をスローします。

  3. tensor.[[descriptor]].writable が false の場合、TypeError をスローします。

  4. tensor がエクスポート済みの場合、TypeError をスローします。

  5. inputData と tensor.[[descriptor]] が与えられたときのdescriptor を用いた buffer の検証が false を返した場合、TypeError をスローします。

  6. bytes を、inputData が与えられたときにbuffer source が保持するバイトのコピーを取得した結果とします。

  7. 表明: bytes の長さは tensor.[[descriptor]] の バイト長と等しい。

  8. 次の手順を tensor.[[context]].[[timeline]] にエンキューします。

    1. 次の手順を実行しますが、this が失われた場合は中止します。

      1. bytes を tensor.[[data]] にコピーします。

        tensor への書き込み中に発生するエラーを報告するためのメカニズムを追加する。[Issue #778]

注: dispatch() と同様に、 writeTensor() 自体は書き込みが完了したことを示すシグナルを提供しません。tensor の内容を確認するには、 呼び出し元は tensor の読み戻し結果を await できます。

8.3.8. exportToGPU()

エクスポート可能な MLTensor を、関連付けられた GPUDevice へ GPUBuffer としてエクスポートし、返された GPUBuffer が破棄されるまで、その GPUDevice に貸し出します。

引数:

戻り値: GPUBuffer。

MLTensor がエクスポートされている間、 [[gpuDevice]] は MLTensor の内容への排他的アクセス権を持ち、MLTensor に依存するすべての WebNN 演算 — dispatch()、 readTensor(tensor)、 readTensor(tensor, outputData)、 および writeTensor() — は TypeError をスローします。

返される GPUBuffer は、usage が GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST、size が MLTensor の [[descriptor]] の バイト長と等しい状態で作成されます。返された GPUBuffer が破棄されると、MLTensor は MLContext に返却され、再び WebNN 演算で使用できます。

注: MLTensor のエクスポートが ゼロコピーになる保証はありません。MLTensor を支えるメモリに [[gpuDevice]] からアクセスできない場合、エクスポートには MLTensor の 内容を返される GPUBuffer へコピーし、GPUBuffer が破棄された時点でそれらをコピーし戻す必要がある場合があります。

exportToGPU(tensor) メソッドの手順は次のとおりです。

  1. tensor.[[context]] が this でない場合、TypeError をスローします。

  2. tensor.[[isDestroyed]] が true の場合、TypeError をスローします。

  3. tensor.[[exportableToGPU]] が false の場合、TypeError をスローします。

  4. realm を this の関連レルムとします。

  5. gpuDevice を tensor.[[gpuDevice]] とします。

  6. gpuDevice が失われている場合、"InvalidStateError" DOMException をスローします。

  7. tensor がエクスポート済みの場合、tensor.[[exportedBuffer]] を返します。

  8. usage を GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST とします。

  9. buffer を、gpuDevice に関連付けられた realm 内の新しい GPUBuffer とします。その size は tensor.[[descriptor]] の バイト長であり、その usage は usage です。

  10. 次の手順を tensor.[[context]].[[timeline]] にエンキューします。

    1. 次の手順を実行しますが、this が失われた場合は中止します。

      1. buffer の内容が tensor.[[data]] を反映するようにします。

        注: エクスポートが ゼロコピーの場合、buffer と tensor.[[data]] は同じメモリによって支えられており、コピーは行われません。

  11. tensor.[[exportedBuffer]] を buffer に設定します。

  12. buffer を返します。

ユーザーエージェントは、buffer の内容が tensor.[[data]] を反映するようにするため、上記でエンキューされた手順が完了する前に、buffer から読み取る、または buffer へ書き込む gpuDevice の GPUQueue にエンキューされた演算が実行されないことを確保しなければなりません。

注: この順序保証はユーザーエージェント内部のものであり、 アプリケーション側で観測可能な同期を必要としません。アプリケーションは exportToGPU() が返った直後に、buffer を使用する GPUQueue の作業を安全に記録して送信できます。

exportToGPU() によって返された GPUBuffer が破棄された場合、ユーザーエージェントは、それがエクスポートされた元の MLTensor を指定してエクスポートされた MLTensor を返却しなければなりません。

注: MLTensor またはその MLContext を、それがエクスポート されている間に破棄しても、返された GPUBuffer は無効になりません。 GPUBuffer は破棄されるまで [[gpuDevice]] から引き続き使用できます。

注: MLTensor がエクスポートされている間に [[gpuDevice]] が失われた場合、返された GPUBuffer は暗黙的には破棄されず、MLTensor は、アプリケーションが destroy() を呼び出すまでエクスポートされたままです （したがって WebNN 演算では使用できません）。destroy() は gpuDevice が失われた後でも引き続き有効に呼び出せます。

8.3.8.1. 例
次のコードは、エクスポート可能な tensor を使用する最小限の WebNN から WebGPU へのフローを示します。 
// 1. WebGPU および WebNN コンテキストを作成する。
const gpuAdapter = await navigator.gpu.requestAdapter();
const gpuDevice = await gpuAdapter.requestDevice();
const context = await navigator.ml.createContext();

// 2. 単純なグラフを構築する: y = x + 1。
const builder = new MLGraphBuilder(context);
const descriptor = {dataType: 'float32', shape: [4]};
const x = builder.input('x', descriptor);
const one = builder.constant(descriptor, new Float32Array([1, 1, 1, 1]));
const y = builder.add(x, one);
const graph = await builder.build({y});

// 3. エクスポート可能な tensor を作成し、WebNN dispatch を実行する。
const inputTensor = await context.createExportableTensor(
    {dataType: 'float32', shape: [4], writable: true}, gpuDevice);
const outputTensor = await context.createExportableTensor(
    {dataType: 'float32', shape: [4], readable: true}, gpuDevice);
context.writeTensor(inputTensor, new Float32Array([1, 2, 3, 4]));
context.dispatch(graph, {x: inputTensor}, {y: outputTensor});

// 4. WebGPU にエクスポートし、GPU コマンドで使用する。
const gpuBuffer = context.exportToGPU(outputTensor);
// ... WebGPU の compute/render 処理で gpuBuffer を使用する ...

// 5. tensor を WebNN に返却し、その後 WebNN から再び読み取る。
gpuBuffer.destroy();
const result = new Float32Array(await context.readTensor(outputTensor));
console.log(result);  // [2, 3, 4, 5]

8.3.9. opSupportLimits()

opSupportLimits() は、演算子レベルで実装ごとに異なるサポートの程度を公開します。WebNN API の利用者には、 各対象プラットフォームに展開する最適なモデルアーキテクチャを決定するため、opSupportLimits() を使用して機能のサポートレベルを調査することを推奨します。

注: opSupportLimits() API は、ブラウザーのフィンガープリンティングに追加のエントロピーを提供することを意図したものではありません。現在の実装では、 この機能サポート情報は OS とブラウザーのバージョンだけから推測できます。将来の実装の多様性によって必要になった場合、この API は、 エントロピーを低減するために WebGPU と同様に機能をバケット化するなど、将来の実装が新しいプライバシー軽減策を 追加できるようにします。

フィンガープリンティングに関する追加の議論については、§ 5 プライバシー上の考慮事項を参照してください。

8.3.9.1. MLOpSupportLimits 辞書
MLOpSupportLimits には次のトップレベルメンバーがあります。これらに加えて、各 演算子には、そのビルダーメソッドで定義された対応するメンバーがあります。 
dictionary MLOpSupportLimits {
  MLInputOperandLayout preferredInputLayout;
  [EnforceRange] unsigned long long maxTensorByteLength;
  MLTensorLimits input;
  MLTensorLimits constant;
  MLTensorLimits output;
};
preferredInputLayout, 型は MLInputOperandLayout

conv2d() など、レイアウトに依存する演算子の優先入力レイアウト。

maxTensorByteLength, 型は unsigned long long

サポートされる tensor の最大長（バイト単位）。

input, 型は MLTensorLimits

MLGraph の入力 MLOperand のサポート制限。

constant, 型は MLTensorLimits

MLGraph の定数 MLOperand のサポート制限。

output, 型は MLTensorLimits

MLGraph の出力 MLOperand のサポート制限。

8.3.9.2. MLRankRange 辞書
dictionary MLRankRange {
  unsigned long min;
  unsigned long max;
};
min, 型は unsigned long

サポートされる最小ランク。

max, 型は unsigned long

サポートされる最大ランク。

8.3.9.3. MLTensorLimits 辞書
typedef sequence<MLOperandDataType> MLDataTypeList;

dictionary MLTensorLimits {
  MLDataTypeList dataTypes;
  MLRankRange rankRange;
};
dataTypes, 型は MLDataTypeList

サポートされるデータ型。

rankRange, 型は MLRankRange

サポートされる最小および最大ランク。

8.3.9.4. MLBinarySupportLimits 辞書
dictionary MLBinarySupportLimits {
  MLTensorLimits a;
  MLTensorLimits b;
  MLTensorLimits output;
};
a, 型は MLTensorLimits

a オペランドの MLTensorLimits。

b, 型は MLTensorLimits

b オペランドの MLTensorLimits。

output, 型は MLTensorLimits

出力オペランドの MLTensorLimits。

8.3.9.5. MLSingleInputSupportLimits 辞書 
dictionary MLSingleInputSupportLimits {
  MLTensorLimits input;
  MLTensorLimits output;
};
input, 型は MLTensorLimits

入力オペランドの MLTensorLimits。

output, 型は MLTensorLimits

出力オペランドの MLTensorLimits。

8.3.10. destroy()

destroy() メソッドを呼び出して、コンテキストに関連付けられたすべてのリソースを解放できます。未処理の計算要求 および MLTensor の作成/読み取り/書き込み要求はすべて失敗します。

destroy() メソッドの手順は次のとおりです。

  1. this が失われている場合、この手順を中止します。

  2. 実装定義のメッセージを使用して、this を失わせる手順を実行します。

    注: destroy() が呼び出されたことを示すメッセージは、開発者がコンテキスト喪失の原因を区別するのに役立ちます。

8.3.11. エラー

ユーザーエージェントが MLContext が 要求を処理するために利用できなくなったと判断した場合、そのコンテキストに対してコンテキスト喪失手順を実行しなければなりません。

MLContext context に対する コンテキスト喪失 手順は次のとおりです。

  1. global を context の関連グローバルオブジェクトとします。

  2. global で ML タスクをキューに入れ、次の手順を実行します。

    1. 失わせる context を、実装定義のメッセージで。

MLContext context を DOMString message で 失わせるには:

  1. info を新しい MLContextLostInfo とします。

  2. info.message を message に設定します。

  3. context.[[lost]] を info で解決します。

  4. graph.[[context]] が this と等しい各 MLGraph graph について:

    1. graph を this として、graph に対する destroy() メソッドの手順を実行します。

  5. tensor.[[context]] が this と等しい各 MLTensor tensor について:

    1. tensor を this として、tensor に対する destroy() メソッドの手順を実行します。

message, 型は DOMString

発生したエラーに関する情報を提供する実装定義のメッセージ。

lost getter の手順は、this の [[lost]] Promise を返すことです。

MLContext は、その [[lost]] Promise が 確定済みである場合、失われています。

8.4. MLGraph インターフェイス

MLGraph インターフェイスは、コンパイル済みの計算グラフを表します。コンパイル済みグラフは一度構築されると不変であり、 その後変更することはできません。 
[SecureContext, Exposed=(Window, Worker)]
interface MLGraph {
  undefined destroy();
};
MLGraph には 次の内部スロットがあります。
[[context]]、型は MLContext

この MLGraph に関連付けられた、型 MLContext のコンテキスト。

[[inputDescriptors]]、 型は record<USVString, MLOperandDescriptor>

この MLGraph のすべての入力 MLOperand について、入力 MLOperand の名前をその MLOperandDescriptor にマッピングします。

[[outputDescriptors]]、 型は record<USVString, MLOperandDescriptor>

この MLGraph のすべての出力 MLOperand について、出力 MLOperand の名前をその MLOperandDescriptor にマッピングします。

[[implementation]]

ユーザーエージェントによって提供される基盤実装。

[[isDestroyed]]、型は boolean

MLGraph.destroy() メソッドの手順が実行されたかどうか。一度破棄されると、MLGraph はそれ以上使用できません。

8.4.1. destroy()

destroy() メソッドを呼び出して、グラフに関連付けられたすべてのリソースを解放できます。

destroy() メソッドの手順は次のとおりです。

  1. this.[[isDestroyed]] が true の場合、この手順を中止します。

  2. this.[[isDestroyed]] を true に設定します。

  3. this.[[context]].[[timeline]] 上に、このグラフが所有するリソースを解放可能としてマークするタスクをキューに入れます。

注: このグラフを使用してこれ以上ワークロードをエンキューできないため、 実装は、このグラフを使用して以前に送信されたすべてのワークロードが完了した後、このグラフに関連付けられた追加の リソース割り当てを解放できます。

8.5. MLOperandDescriptor 辞書

MLOperandDescriptor はオペランドの形状（次元）とデータ型を記述します。これらは MLGraph の入力と 定数を記述するために使用され、すべての MLOperand は内部に MLOperandDescriptor を持ちます。 

enum MLInputOperandLayout {
  "nchw",
  "nhwc"
};

enum MLOperandDataType {
  "float32",
  "float16",
  "int32",
  "uint32",
  "int64",
  "uint64",
  "int8",
  "uint8"
};

dictionary MLOperandDescriptor {
  required MLOperandDataType dataType;
  required sequence<[EnforceRange] unsigned long> shape;
};
dataType, 型は MLOperandDataType

オペランドのデータ型。

shape, 型は sequence<[EnforceRange] unsigned long>

オペランドの次元のリスト。スカラーオペランドの場合は空です。

MLOperandDescriptor A は、A.dataType が B.dataType と等しく、かつ A.shape が B.shape と等しい場合、MLOperandDescriptor B と 等しいです。
MLOperandDataType dataType と リスト shape が与えられたときに MLOperandDescriptor を 作成するには、次の手順を実行します。

  1. descriptor を新しい MLOperandDescriptor とします。

  2. descriptor.dataType を dataType に設定します。

  3. descriptor.shape を shape の複製に設定します。

  4. descriptor を返します。

MLOperandDescriptor desc の バイト長は、次の手順によって返される値です。

  1. elementLength を 1 とします。

  2. desc.shape の各 dimension について反復します。

    1. elementLength を elementLength * dimension に設定します。

  3. elementSize を、この 表に従って desc.dataType と一致する ArrayBufferView 型のいずれかの要素サイズとします。

  4. elementLength * elementSize を返します。

MLOperandDescriptor desc の 要素数は、次の手順によって返される値です。

  1. elementCount を 1 とします。

  2. desc.shape の各 dimension について反復します。

    1. elementCount を elementCount * dimension に設定します。

  3. elementCount を返します。

有効な次元とは、 0 より大きく、long の範囲内にある整数です。実装は、より小さい上限を課す場合があります。

有効な tensor 数とは、0 より大きく 8192 以下の整数です。実装は、 より小さい上限を課す場合があります。

サイズ 0 の次元を サポートすべきか？ [Issue #391]

MLOperandDescriptor descriptor が与えられたときに 次元をチェックするには、次の手順を実行します。

  1. descriptor.shape のいずれかの項目が有効な 次元でない場合、false を返します。

  2. descriptor.shape の サイズが実装でサポートするには大きすぎる場合、 false を返します。

    オペランドの次元数の最大値は 定義されていませんが、ネイティブ ML API には通常、サポートされる最大 サイズがあります。[Issue #456]

  3. descriptor の要素数が有効な 次元でない場合、false を返します。

  4. descriptor のバイト長が実装でサポートされていない場合、false を返します。

  5. true を返します。

8.6. MLOperand インターフェイス

MLOperand は、演算の各部分を完全に合成された演算へ合成した結果として構築される途中のグラフを表します。

たとえば、MLOperand は、 演算へ供給される定数、または複数の定数を演算内で結合した結果を表すことができます。 § 7 プログラミングモデルも参照してください。 

[SecureContext, Exposed=(Window, Worker)]
interface MLOperand {
  readonly attribute MLOperandDataType dataType;
  readonly attribute FrozenArray<unsigned long> shape;
};

dictionary MLOperatorOptions {
  USVString label = "";
};

typedef (bigint or unrestricted double) MLNumber;
MLOperand には次の内部スロットがあります。
[[builder]]、型は MLGraphBuilder

MLOperand に 関連付けられた builder オブジェクト。

[[descriptor]]、型は MLOperandDescriptor

MLOperand の descriptor。

[[name]]、型は 文字列

MLOperand の 名前（入力オペランドの場合のみ）。

[[operator]]、型は 演算子

MLOperand に 対応する演算子への参照。

[[constantTensor]]、型は MLTensor

MLOperand の tensor（定数オペランドの場合のみ）。

MLOperand の dataType は、その [[descriptor]].dataType です。

MLOperand の shape は、その [[descriptor]].shape です。

MLOperand の ランクは、そのshape のサイズです。

dataType のgetter 手順は、this のdataType を返すことです。

shape のgetter 手順は、this のshape を返すことです。

[[builder]] オブジェクトは MLGraphBuilder() コンストラクターによって MLContext オブジェクトに結び付けられるため、MLOperand も 常に同じ MLContext オブジェクトに結び付けられます。

演算が MLOperandDataType の一部のみをサポートする場合、 位置引数とオプションの両方を含む演算の各入力オペランドに対する 許可されるデータ 型は、MLOperandDataType の明示的なリスト、 またはオペランドの dataType が別の入力オペランドの dataType と 同じでなければならないという制約、または任意の MLOperandDataType を許可する 任意として指定されます。

実装は、オペランドについて指定されたものより少ないデータ型をサポートしてもよいですが、少なくとも指定された 必須データ 型をサポートしなければなりません。各演算のサポートは、MLContext の opSupportLimits() メソッドを使用し、現在の Chromium プロトタイプにおける ONNX Runtime、LiteRT、および CoreML バックエンド全体で、 演算に対応するメンバーの dataTypes 値を調べることで問い合わせることができます。

必須データ 型の集合は、開発者がこれらのデータ型のみを使用するようモデルを設計することで相互運用可能なコンテンツを作成できるよう、 幅広いプラットフォームでの実装経験に基づいて決定されています。この仕様の Web Platform Tests は、この機能検出メカニズムを使用して、すべての許可されるデータ 型に対する正しい動作を検証しますが、必須データ型のみをサポートしていても合格できます。

演算が特定のランクを持つ入力オペランドを必要とする場合、位置引数とオプションの両方を含む 演算の各入力オペランドに対する 許可されるランクは、明示的なランク（例: 1）、任意の次元数を許可する N、または別のオペランドと 同じとして指定されます。入力オペランドの shape が別の入力オペランドに対して単方向にブロードキャスト可能でなければならない場合や、別の入力オペランドと双方向にブロードキャスト可能でなければならない場合など、より具体的な制約も一般的です。 このような場合、許可される ランクは範囲として列挙され、具体的な検証は演算内の手順として示されます。

実装は、オペランドのランクについて、指定されたものより制限の厳しい下限および/または上限を課してもよいですが、少なくとも指定された 必須ランクをサポートしなければなりません。各演算のサポートは、MLContext の opSupportLimits() メソッドを使用し、現在の Chromium プロトタイプにおける ONNX Runtime、LiteRT、および CoreML バックエンド全体で、 演算に対応するメンバーの rankRange.min および rankRange.max の値を調べることで問い合わせることができます。

必須ランクの集合は、 開発者がこれらのランクのみを持つ入力オペランドから構成されるモデルを設計することで相互運用可能なコンテンツを 作成できるよう、幅広いプラットフォームでの実装経験に基づいて決定されています。

MLOperatorOptions には次のメンバーがあります。

label, 型は USVString、デフォルトは ""

演算子が MLOperand を作成する MLGraphBuilder メソッドを使用して作成されるときに、必要に応じて指定されます。 実装は、この値を使用して演算子のラベルを初期化する場合があります。

注: ラベルは自然言語の 文字列として使用することを意図したものではありません。これは、変数名やエラーコードと同様の、言語に依存しない識別子であり、 "mul#1234" のようなものです。

注: 実装には、開発者が提供する label を使用してエラーメッセージを強化し、グラフ構築中の同期 エラーと、非同期の build() メソッド中に発生するエラーの両方を含め、デバッグ容易性を向上させることを推奨します。

label を介して開発者が提供したラベルをデバッグツール、ログ、またはエラーメッセージに表示する場合、実装は 悪意のある Unicode シーケンスの注入などのセキュリティリスクを防ぐため、出力をサニタイズすべきです（例: 双方向テキスト スプーフィング [UTR36]、ソースコードスプーフィング [UTS55]、 その他の懸念事項）。たとえば、実装は制御文字（例: U+202A から U+202E、U+2066 から U+2069）をエスケープまたはフィルタリングするか、安全なレンダリングメカニズムを使用して潜在的な スプーフィングを無効化すべきです。

8.6.1. MLOperand の作成

MLOperand オブジェクトは、MLGraphBuilder のメソッドによって、 内部的に次のアルゴリズムを使用して作成されます。
MLGraphBuilder builder と MLOperandDescriptor desc が与えられたときに MLOperand を 作成するには、次の手順を実行します。

  1. realm を builder の関連レルムとします。

  2. operand を realm 内の新しい MLOperand とします。

  3. operand.[[builder]] を builder に設定します。

  4. operand.[[descriptor]] を desc に設定します。

  5. operand を返します。

MLOperand operand が与えられたときに MLOperand を コピーするには、次の手順を実行します。

  1. builder を operand.[[builder]] とします。

  2. realm を builder の関連レルムとします。

  3. result を realm 内の新しい MLOperand とします。

  4. result.[[builder]] を builder に設定します。

  5. result.[[descriptor]] を operand.[[descriptor]] に設定します。

  6. operand.[[name]] が存在する場合、result.[[name]] を operand.[[name]] に設定します。

  7. result を返します。

MLGraphBuilder builder と MLOperand operand が与えられたときに オペランドを検証するには、operand.[[builder]] が builder であれば true を、それ以外の場合は false を返します。

8.6.1.1. MLNumber

MLNumber は、64 ビット整数型（"uint64" および "int64"） と 32 ビット浮動小数点（"float32"） の両方を含む、任意の MLOperandDataType になり得る MLOperand に対する数値オプションの型を指定するときに使用されます。 実装は、対応する MLOperandDataType に従って値を処理します。たとえば、clamp(input, options) が dataType "uint32" の MLOperand で呼び出された場合、 MLNumber パラメーターは明示的に unsigned long にキャストされます。

オプションを double として指定すると、253 を超える値を渡す際に精度が失われ、long long として指定すると 263 を超える値が許可されません。

bigint と数値型の union のサポートは [WEBIDL] では新しく、実装によるサポートも限定的です。 プロトタイプ実装には、このアプローチに関するフィードバックを提供することを推奨します。[whatwg/webidl Issue #1388]

8.7. MLTensorDescriptor 辞書

MLTensorDescriptor は MLTensor の特性と機能を記述します。

dictionary MLTensorDescriptor : MLOperandDescriptor {
  boolean readable = false;
  boolean writable = false;
};
readable, 型は boolean、デフォルトは false

tensor の内容を readTensor(tensor) または readTensor(tensor, outputData) を介して読み取れるかどうか。

writable, 型は boolean、デフォルトは false

tensor の内容に writeTensor() を介して書き込めるかどうか。

8.8. MLTensor インターフェイス

MLTensor インターフェイスは、MLGraph の入力または出力として使用できる tensor を表します。MLTensor を支える メモリは、その作成に使用された MLContext および MLTensorDescriptor の要件に従って、実装定義の方法で割り当てるべきです。MLTensor の [[data]] に関する演算は、関連付けられた MLContext の [[timeline]] 上で行われます。

MLTensor の割り当て方法に関する実装定義の要件には、 メモリを特定のバイトアラインメントで割り当てることや、特定のメモリプール内に割り当てることなどの制約が含まれる場合があります。

[SecureContext, Exposed=(Window, Worker)]
interface MLTensor {
  readonly attribute MLOperandDataType dataType;
  readonly attribute FrozenArray<unsigned long> shape;
  readonly attribute boolean readable;
  readonly attribute boolean writable;
  readonly attribute boolean constant;

  undefined destroy();
};
MLTensor には 次の内部スロットがあります。
[[context]]、型は MLContext

MLTensor に 関連付けられたコンテキスト。

[[descriptor]]、型は MLTensorDescriptor

MLTensor の descriptor。

[[pendingPromises]]、 型は Promise の集合

進行中でまだ解決されていない MLContext.readTensor(tensor) メソッド呼び出しに対応する Promise。MLTensor が破棄されると、保留中のすべての promise は拒否されます。

[[isDestroyed]]、型は boolean

MLTensor.destroy() の手順が実行されたかどうか。一度破棄されると、MLTensor はそれ以上使用できません。

[[data]]、実装定義の型

MLTensor を支えるバイト。 このデータは [[context]].[[timeline]] からのみアクセスまたは変更できます。

[[isConstant]]、型は boolean

MLTensor が定数 MLTensor を作成することによって作成されたかどうか。

[[exportableToGPU]]、 型は boolean

MLTensor がエクスポート可能な MLTensor を作成することによって作成され、exportToGPU() を使用して GPUDevice にエクスポートできるかどうか。

[[gpuDevice]]、型は GPUDevice または null

MLTensor をエクスポートできる GPUDevice、 または MLTensor がエクスポート可能でない場合は null。[[exportableToGPU]] が true の場合にのみ設定されます。

[[exportedBuffer]]、型は GPUBuffer または null

exportToGPU() の結果として、現在 [[gpuDevice]] に貸し出されている GPUBuffer、 または MLTensor が現在エクスポートされていない場合は null。

MLTensor の dataType は、その [[descriptor]] の dataType です。

MLTensor の shape は、その [[descriptor]] の shape です。

dataType のgetter 手順は、 this のdataType を返すことです。

shape のgetter 手順は、 this のshape を返すことです。

readable のgetter 手順は、 this.[[descriptor]].readable を返すことです。

writable のgetter 手順は、 this.[[descriptor]].writable を返すことです。

constant のgetter 手順は、 this の [[isConstant]] を返すことです。

MLTensor は、その [[exportedBuffer]] が null でない場合、エクスポートされています。

8.8.1. MLTensor の作成

MLTensor は、 関連付けられた MLContext によって作成されます。

MLContext context および MLTensorDescriptor descriptor が与えられたときに MLTensor を 作成するには、次の手順を実行します。

  1. realm を context の関連レルムとします。

  2. tensor を realm 内の新しい MLTensor とします。

  3. tensor.[[context]] を context に設定します。

  4. tensor.[[descriptor]] を descriptor に設定します。

  5. tensor.[[isDestroyed]] を false に設定します。

  6. tensor.[[isConstant]] を false に設定します。

  7. tensor.[[exportableToGPU]] を false に設定します。

  8. tensor.[[gpuDevice]] を null に設定します。

  9. tensor.[[exportedBuffer]] を null に設定します。

  10. tensor を返します。

MLContext context、MLTensorDescriptor descriptor、および GPUDevice gpuDevice が与えられたときに エクスポート可能な MLTensor を作成するには、次の手順を実行します。

  1. tensor を、context および descriptor が与えられたときに MLTensor を作成した結果とします。

  2. tensor.[[exportableToGPU]] を true に設定します。

  3. tensor.[[gpuDevice]] を gpuDevice に設定します。

  4. tensor を返します。

MLTensor tensor が与えられたときに エクスポートされた MLTensor を返却するには、次の手順を実行します。

  1. tensor がエクスポートされていない場合、この手順を中止します。

  2. buffer を tensor.[[exportedBuffer]] とします。

  3. tensor.[[exportedBuffer]] を null に設定します。

  4. tensor.[[isDestroyed]] が true の場合、この手順を中止します。

  5. 次の手順を tensor.[[context]].[[timeline]] にエンキューします。

    1. 次の手順を実行しますが、tensor.[[context]] が失われた場合は中止します。

      1. tensor.[[data]] が buffer の内容を反映するようにします。

        注: エクスポートが ゼロコピーであった場合、buffer と tensor.[[data]] は同じメモリによって支えられており、コピーは行われません。

ユーザーエージェントは、tensor.[[data]] が buffer の内容を反映するようにする上記のエンキューされた手順が、buffer から読み取る、または buffer に書き込む、 gpuDevice の GPUQueue に以前エンキューされたすべての演算が完了する前に実行されないことを確保しなければなりません。

8.8.2. destroy()

MLTensor に関連付けられたリソースを解放します。この メソッドは冪等です。

戻り値: undefined。
destroy() メソッドの手順は次のとおりです。

  1. this.[[isDestroyed]] を true に設定します。

  2. this.[[pendingPromises]] 内の各 promise について反復します。

    1. promise を this.[[pendingPromises]] から削除します。

    2. promise を "InvalidStateError" DOMException で拒否します。

  3. 次の手順を this.[[context]].[[timeline]] にエンキューします。

    1. this.[[data]] を解放します。

注: この tensor を使用してこれ以上演算をエンキューできないため、 実装は、この tensor を使用して以前に送信されたすべての演算が完了した後、この tensor に関連付けられた追加のリソース割り当てを 解放できます。

8.8.3. 定数 MLTensor の作成

定数 MLTensor は、 関連付けられた MLContext によって作成されます。

MLContext context、MLOperandDescriptor inputDescriptor が与えられたときに 定数 MLTensor を作成するには、次の手順を実行します。

  1. realm を context の関連レルムとします。

  2. tensor を realm 内の新しい MLTensor とします。

  3. tensor.[[context]] を context に設定します。

  4. tensorDescriptor を新しい MLTensorDescriptor とします。

  5. tensorDescriptor.readable を false に設定します。

  6. tensorDescriptor.writable を false に設定します。

  7. tensorDescriptor.dataType を inputDescriptor.dataType に設定します。

  8. tensorDescriptor.shape を inputDescriptor.shape に設定します。

  9. tensor.[[descriptor]] を tensorDescriptor に設定します。

  10. tensor.[[isDestroyed]] を false に設定します。

  11. tensor.[[isConstant]] を true に設定します。

  12. tensor.[[exportableToGPU]] を false に設定します。

  13. tensor.[[gpuDevice]] を null に設定します。

  14. tensor.[[exportedBuffer]] を null に設定します。

  15. tensor を返します。

8.9. MLGraphBuilder インターフェイス

MLGraphBuilder インターフェイスは、§ 2 ユースケースで特定された、計算グラフへ 合成できる一連の演算を定義します。また、グラフ構築セッションの中間状態も表します。 

typedef record<USVString, MLOperand> MLNamedOperands;

[SecureContext, Exposed=(Window, Worker)]
interface MLGraphBuilder {
  // コンテキストからグラフビルダーを構築する。
  constructor(MLContext context);

  // グラフ入力用のオペランドを作成する。
  MLOperand input(USVString name, MLOperandDescriptor descriptor);

  // グラフ定数用のオペランドを作成する。
  MLOperand constant(MLOperandDescriptor descriptor,
                     AllowSharedBufferSource buffer);

  // 指定された型の指定された数値からスカラーオペランドを作成する。
  MLOperand constant(MLOperandDataType dataType, MLNumber value);

  // 指定された定数 tensor からオペランドを作成する。
  MLOperand constant(MLTensor tensor);

  // 指定された出力オペランドまでのグラフを非同期にコンパイルする。
  Promise<MLGraph> build(MLNamedOperands outputs);
};
MLGraphBuilder.build() メソッドは、グラフビルダーの状態を指定された出力オペランドまで、その作成元となる MLContext の型に従って コンパイル済みグラフへコンパイルします。MLContext の [[contextType]] が "default" に設定されている場合、コンパイル済みグラフは MLGraph が 返される直前に初期化されます。このグラフ初期化段階は、その後のグラフ 実行で最適な性能を得るために重要です。通常は「重みの前処理」と呼ばれる処理を伴い、グラフへのすべての定数入力を 前処理し、その後のグラフ実行呼び出しのためにオペレーティングシステムレベルでキャッシュします。 初期化用の入力は通常、グラフ構築時に constant() メソッドを通じて定数オペランドとして指定された定数の重みデータです。
MLGraphBuilder には次の内部スロットがあります。
[[context]]、型は MLContext

この MLGraphBuilder に関連付けられた、型 MLContext のコンテキスト。

[[hasBuilt]]、型は boolean

MLGraphBuilder.build() が呼び出されたかどうか。一度ビルドされると、MLGraphBuilder はそれ以上演算子を作成したり、MLGraph をコンパイルしたりできません。

MLGraphBuilder は、その [[hasBuilt]] が false であり、その [[context]] が失われていない場合、ビルドできます。

8.9.1. MLGraphBuilder コンストラクター

引数:
new MLGraphBuilder(context) コンストラクターの手順は次のとおりです。

  1. this の関連グローバルオブジェクトの関連付けられた Document が webnn 機能の使用を許可されていない場合、"SecurityError" DOMException をスローします。

  2. context が失われている場合、"InvalidStateError" DOMException をスローします。

  3. this.[[context]] を context に設定します。

  4. this.[[hasBuilt]] を false に設定します。

8.9.2. 入力オペランド

descriptor に基づいて、入力として使用できる名前付き MLOperand を作成します。

引数: 戻り値: MLOperand。
input(name, descriptor) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. name が空の場合、TypeError をスローします。

  3. this のグラフの入力に含まれるいずれかの MLOperand の [[name]] が name と等しい場合、TypeError をスローします。

  4. descriptor が与えられたときの次元のチェックが false を返した場合、TypeError をスローします。

  5. グラフの接続を行います。

    1. operand を、this と descriptor が与えられたときにMLOperand を 作成した結果とします。

    2. operand.[[name]] を name に設定します。

    3. operand を this のグラフの入力に追加します。

  6. operand を返します。

MLGraphBuilder API では、入力オペランドなしで MLGraph を作成できます。 基盤プラットフォームがそれをサポートしない場合、実装はダミー入力を追加するか、 定数をグラフへの入力として渡すことができます。

8.9.3. 定数オペランド

MLGraphBuilder メソッドで使用できる定数 MLOperand を作成します。
8.9.3.1. constant(descriptor, buffer)
初期化データを含む、指定されたデータ型と shape の定数 MLOperand を作成します。
引数: 戻り値: MLOperand。 定数出力 tensor。
constant(descriptor, buffer) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. descriptor が与えられたときの次元のチェックが false を返した場合、TypeError をスローします。

  3. buffer と descriptor が与えられたときのdescriptor を用いた buffer の検証が false を返した場合、TypeError をスローします。

  4. グラフの接続を行います。

    1. operand を、this と descriptor が与えられたときにMLOperand を 作成した結果とします。

    2. bytes を、buffer が与えられたときにbuffer source が保持するバイトのコピーを取得した結果とします。

    3. operand を、bytes を値として this のグラフの定数に追加します。

  5. operand を返します。

8.9.3.2. constant(tensor)
初期化済みデータを含む、指定されたデータ型と shape の定数 MLOperand を作成します。
引数: 戻り値: MLOperand。 定数出力 tensor。
constant(tensor) メソッドの手順は 次のとおりです。

  1. tensor.[[context]] が this.[[context]] でない場合、TypeError をスローします。

  2. tensor.[[isDestroyed]] が true の場合、TypeError をスローします。

  3. tensor.[[isConstant]] が false の場合、TypeError をスローします。

  4. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  5. グラフの接続を行います。

    1. operand を、this と tensor.[[descriptor]] が与えられたときにMLOperand を 作成した結果とします。

    2. operand.[[constantTensor]] を tensor に設定します。

    3. operand を、tensor を値として this のグラフの定数に追加します。

  6. operand を返します。

8.9.3.3. constant(dataType, value)
指定された値とデータ型のスカラー定数 MLOperand を作成します。
指定された値が指定された出力データ型の範囲を超える場合、たとえば浮動小数点値を "int8" データ型に割り当てた場合などには、データの切り捨てが発生します。
引数: 戻り値: MLOperand。 定数出力。
constant(dataType, value) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. value を、value を dataType にキャストした結果に設定します。

  3. descriptor を、dataType と « » が与えられたときにMLOperandDescriptor を 作成した結果とします。

  4. グラフの接続を行います。

    1. operand を、this と descriptor が与えられたときにMLOperand を 作成した結果とします。

    2. operand を、value を値として this のグラフの定数に追加します。

  5. operand を返します。

8.9.4. build メソッド

指定された出力オペランドまでの合成済みグラフを、計算グラフへ非同期にビルドします。
引数: 戻り値: Promise<MLGraph>。
build(outputs) メソッドの手順は次のとおりです。

  1. realm を this の関連レルムとします。

  2. this がビルドできない場合、realm 内で "InvalidStateError" DOMException によって拒否された新しい promise を返します。

  3. outputs が空の場合、realm 内で TypeError によって拒否された新しい promise を返します。

  4. outputs の各 name → operand について反復します。

    1. name が空の場合、realm 内で TypeError によって拒否された新しい promise を返します。

    2. this と operand が与えられたときのオペランドの検証が false を返した場合、realm 内で TypeError によって拒否された新しい promise を返します。

    3. operand が this のグラフの入力 または定数に含まれる場合、realm 内で TypeError によって拒否された新しい promise を返します。

    4. operand.[[constantTensor]] が存在し、operand.[[constantTensor]].[[isDestroyed]] が true の場合、realm 内で TypeError によって拒否された新しい promise を返します。

  5. operands を新しい空の集合とします。

  6. operators を新しい空の集合とします。

  7. inputs を新しい空の集合とします。

  8. queue を、outputs の値を含む新しいキューとします。

  9. queue が空でない間:

    1. queue から operand をデキューします。

    2. operand を operands に追加します。

    3. operand.[[operator]] を operators に追加します。

    4. operand が this のグラフの入力に含まれる場合、operand を inputs に追加します。

    5. operand.[[operator]] の 入力の各 input について反復します。

      1. input を queue にエンキューします。

  10. global を this の関連グローバルオブジェクトとします。

  11. graph を realm 内の新しい MLGraph とします。

  12. graph.[[context]] を this.[[context]] に設定します。

  13. graph.[[isDestroyed]] を false に設定します。

  14. inputs 内の各 operand について反復します。

    1. graph.[[inputDescriptors]][operand.[[name]]] を operand.[[descriptor]] に設定します。

  15. outputs の各 name → operand について反復します。

    1. graph.[[outputDescriptors]][name] を operand.[[descriptor]] に設定します。

  16. this.[[hasBuilt]] を true に設定します。

  17. promise を realm 内の新しい promise とします。

  18. 次の手順を graph.[[context]].[[timeline]] にエンキューします。

    1. 次の手順を実行しますが、graph.[[context]] が失われた場合は中止します。

      1. graphImpl を、this の グラフを operands、 operators、inputs、outputs の値、さらに graph.[[context]].[[powerPreference]] および graph.[[context]].[[accelerated]] とともに、基盤プラットフォームが解釈できる実装定義の形式へ変換した結果とします。

      2. 前の手順が失敗した場合、global で ML タスクをキューに入れ、promise を "OperationError" DOMException で拒否し、この手順を中止します。

      3. graph.[[implementation]] を graphImpl に設定します。

      4. global で ML タスクをキューに入れ、 promise を graph で解決します。

    2. 中止された場合、global で ML タスクをキューに入れ、 promise を "InvalidStateError" DOMException で拒否します。

  19. promise を返します。

注: 入力オペランドまたは定数オペランドをグラフの 出力 として指定するとエラーになります。これは通常、API の誤った使用方法であるためです。呼び出し元は、 identity() 演算子を導入することでこれを回避できます。

8.9.5. argMin/argMax 演算

軸に沿ったすべての入力値の最小値または最大値のインデックス位置を返します。同値の場合、 返り値がどちらになるかは実装依存です。 
dictionary MLArgMinMaxOptions : MLOperatorOptions {
  boolean keepDimensions = false;
  MLOperandDataType outputDataType = "int32";
};

partial interface MLGraphBuilder {
  MLOperand argMin(MLOperand input, [EnforceRange] unsigned long axis,
                   optional MLArgMinMaxOptions options = {});
  MLOperand argMax(MLOperand input, [EnforceRange] unsigned long axis,
                   optional MLArgMinMaxOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits argMin;
  MLSingleInputSupportLimits argMax;
};

MLArgMinMaxOptions には次のメンバーがあります。

keepDimensions, 型は boolean、デフォルトは false

true の場合、削減された次元をサイズ 1 で保持します。

outputDataType, 型は MLOperandDataType、デフォルトは "int32"

MLOperandDataType。 出力データ型。

引数:

戻り値: MLOperand。 keepDimensions が true の場合は input の ランクと等しいランクを持ち、keepDimensions が false の場合は input の ランク - 1 のランクを持つ出力 N-D tensor。 値は outputDataType 型で、[0, N-1] の範囲内でなければなりません。ここで N は axis で指定された入力次元のサイズです。

argMin()/argMax() の tensor 制限
オペランド 許可されるデータ 型 必須データ 型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32" 1 から N 1 から 5
出力 "int32", "int64" "int32" N 0 から 5

MLOpSupportLimits には argMin() および argMax() 用の次のメンバーがあります。

argMin, 型は MLSingleInputSupportLimits

argMin() 演算子のサポート制限。

argMax, 型は MLSingleInputSupportLimits

argMax() 演算子のサポート制限。

文字列 op、MLOperand input、unsigned long axis、および MLArgMinMaxOptions options が与えられたときに argMin/argMax 演算を作成するには、次の手順を実行します。

  1. 表明: op は "argMin"、"argMax" のいずれかです。

  2. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  3. this と input を用いたオペランドの検証が false を返した場合、TypeError をスローします。

  4. axis が input のランク以上の場合、TypeError をスローします。

  5. options.outputDataType が（この表に従って）出力 tensor の許可されるデータ型でない場合、TypeError をスローします。

  6. input のshape[axis] が options.outputDataType の 最大値より大きい場合、TypeError をスローします。

  7. outputShape を、input のshape、« axis »、および options.keepDimensions が与えられたときにリダクション出力サイズを 計算した結果とします。それが失敗を返した場合、TypeError をスローします。

  8. desc を、options.outputDataType と outputShape が与えられたときにMLOperandDescriptor を 作成した結果とします。

  9. グラフの接続を行います。

    1. operator を、options が与えられた op 演算用の演算子とします。

    2. output を、this と desc が与えられたときにMLOperand を 作成した結果とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  10. output を返します。

次の argMin/argMax アルゴリズムがサポートされています。
argMin(input, axis, options) メソッドの手順は次のとおりです。

  1. output を、"argMin"、input、axis および options が与えられたときにargMin/argMax 演算を 作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

argMax(input, axis, options) メソッドの手順は次のとおりです。

  1. output を、"argMax"、input、axis および options が与えられたときにargMin/argMax 演算を 作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

8.9.6. batchNormalization

[Batch-Normalization] を使用して入力 tensor の値を正規化します。 モデルの学習中、各入力特徴について、その特徴の平均値と分散値が バッチ次元内のすべてのサンプルにわたって計算されます。これらの平均値と分散値は、その後、 モデル推論中にこの演算へ与えられます。 
dictionary MLBatchNormalizationOptions : MLOperatorOptions {
  MLOperand scale;
  MLOperand bias;
  [EnforceRange] unsigned long axis = 1;
  double epsilon = 1e-5;
};

partial interface MLGraphBuilder {
  MLOperand batchNormalization(MLOperand input, MLOperand mean, MLOperand variance,
                               optional MLBatchNormalizationOptions options = {});
};

dictionary MLBatchNormalizationSupportLimits {
  MLTensorLimits input;
  MLTensorLimits mean;
  MLTensorLimits variance;
  MLTensorLimits scale;
  MLTensorLimits bias;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLBatchNormalizationSupportLimits batchNormalization;
};

MLBatchNormalizationOptions には次のメンバーがあります。

scale, 型は MLOperand

axis で示される入力次元のサイズとサイズが等しい、 スケーリング値の 1-D tensor。

bias, 型は MLOperand

axis で示される入力次元のサイズとサイズが等しい、 バイアス値の 1-D tensor。

axis, 型は unsigned long、デフォルトは 1

平均値と分散値が対応する、入力 shape の特徴数次元へのインデックス。 値は [0, N-1] の範囲内でなければなりません。ここで N は入力 tensor のランクです。デフォルト 値は 1 であり、"nchw" データレイアウトにおけるチャンネル（"c"）次元に対応します。

epsilon, 型は double、デフォルトは 1e-5

ゼロ除算による計算エラーを防ぐための小さな値。

引数:

戻り値: MLOperand。 input と同じ shape を持つ、バッチ正規化された N-D tensor。

batchNormalization() の tensor 制限
オペランド 許可されるデータ 型 必須データ 型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" 1 から N 3 から 5
mean input と同じ "float32", "float16" 1 1
variance input と同じ "float32", "float16" 1 1
scale input と同じ "float32", "float16" 1 1
bias input と同じ "float32", "float16" 1 1
出力 input と同じ "float32", "float16" input と同じ 3 から 5

MLBatchNormalizationSupportLimits には次のメンバーがあります。

input, 型は MLTensorLimits

入力オペランドの MLTensorLimits。

mean, 型は MLTensorLimits

mean オペランドの MLTensorLimits。

variance, 型は MLTensorLimits

variance オペランドの MLTensorLimits。

scale, 型は MLTensorLimits

scale オペランドの MLTensorLimits。

bias, 型は MLTensorLimits

bias オペランドの MLTensorLimits。

output, 型は MLTensorLimits

出力オペランドの MLTensorLimits。

MLOpSupportLimits には batchNormalization() 用の次のメンバーがあります。

batchNormalization, 型は MLBatchNormalizationSupportLimits

batchNormalization() 演算子のサポート制限。

batchNormalization(input, mean, variance, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. this と、input、mean、 variance、options.scale （それが存在する場合）、および options.bias （それが存在する場合）のいずれかを用いたオペランドの検証が false を返した場合、TypeError をスローします。

  3. input のdataType が（この表に従って）その許可されるデータ型 のいずれでもない場合、TypeError をスローします。

  4. options.axis が、0 から input のランクまでの範囲（上限を含まない）にない場合、TypeError をスローします。

  5. mean のdataType が（この表に従って）その許可されるデータ型 のいずれでもない場合、TypeError をスローします。

  6. mean のshape が « input のshape[options.axis] » と等しくない場合、TypeError をスローします。

  7. variance のdataType が（この表に従って）その許可されるデータ型 のいずれでもない場合、TypeError をスローします。

  8. variance のshape が « input のshape[options.axis] » と等しくない場合、TypeError をスローします。

  9. options.epsilon を、options.epsilon を input のdataType にキャストした 結果に設定します。

  10. options.scale が存在する場合:

    1. そのdataType が（この表に従って）その許可されるデータ型のいずれでもない場合、TypeError をスローします。

    2. そのshape が « input のshape[options.axis] » と等しくない場合、TypeError をスローします。

  11. options.bias が存在する場合:

    1. そのdataType が（この表に従って）その許可されるデータ型のいずれでもない場合、TypeError をスローします。

    2. そのshape が « input のshape[options.axis] » と等しくない場合、TypeError をスローします。

  12. グラフの接続を行います。

    1. operator を、input、mean、variance および options が与えられた "batchNormalization" 演算用の演算子とします。

    2. output を、this と input.[[descriptor]] が与えられたときにMLOperand を 作成した結果とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input、mean、および variance に設定します。

    5. options.scale が存在する場合、それを operator の入力に追加します。

    6. options.bias が存在する場合、それを operator の入力に追加します。

    7. operator の出力を output に設定します。

  13. output を返します。

入力 tensor が "nchw" レイアウトの 4-D である場合、この演算の動作は、ユーザーエージェントが通常はより効率的な実装を備えているものの、 次のように他の演算を使用して一般的にエミュレートできます。基盤プラットフォームが 演算を直接サポートしていない場合、この分解を実装の指針となるテンプレートとして使用できます。 
function batchNormalization(builder, input, mean, variance, options) {
  const shape = [1, input.shape[options.axis], 1, 1];
  return builder.add(
    builder.mul(
      builder.reshape(options.scale, shape),
      builder.div(
        builder.sub(input, builder.reshape(mean, shape)),
        builder.sqrt(builder.add(
          builder.reshape(variance, shape),
          builder.constant(input.dataType, options.epsilon))))),
    builder.reshape(options.bias, shape));
}

8.9.7. cast

入力テンソルの各要素を対象データ型にキャストします。 
partial interface MLGraphBuilder {
  MLOperand cast(MLOperand input,
                 MLOperandDataType dataType,
                 optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits cast;
};
引数:

戻り値: MLOperand。 input と同じ shape を持ち、各要素が対象データ型にキャストされた N-D テンソル。

cast() のテンソル制限
オペランド 許可されるデータ 型 必須データ 型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32", "int8", "uint8" N 0 から 5
出力 任意 "float32", "float16", "int32", "int8", "uint8" input と同じ 0 から 5

MLOpSupportLimits には cast() 用の次のメンバーがあります。

cast, 型は MLSingleInputSupportLimits

cast() 演算子のサポート制限。

MLOperandDataType 間のキャストは、次の表に従い、一部の場合については規定され、それ以外の場合は実装定義です。

cast() 演算の動作。input の dataType（行） と対象 dataType （列）によって決まります。
対象型 入力型 "float32", "float16" "int32", "uint32", "int64", "uint64", "int8", "uint8"
"float32", "float16" 範囲内の場合、最も近い表現可能な値。

範囲外の場合、+/-Infinity。

 範囲内の場合、切り捨て。

範囲外の場合、実装定義。

"int32", "uint32", "int64", "uint64", "int8", "uint8" 範囲内の場合、最も近い表現可能な値。

範囲外の場合、+/-Infinity。

 範囲内の場合、同じ値。

範囲外の場合、下位 N ビットを対象型として再解釈します。符号付き型については 2 の補数を仮定します。

注: たとえば、"int8" の -1 を "uint8" にキャストすると 255 になると規定されています。しかし、"float32" の -1 を "uint8" にキャストした場合は実装定義です。

cast(input, dataType, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、TypeError をスローします。

  3. dataType が（この表に従って）出力テンソルの許可されるデータ型でない場合、TypeError をスローします。

  4. グラフの接続を行います。

    1. operator を、dataType および options が与えられた "cast" 演算用の演算子とします。

    2. output を、input が与えられたときに MLOperand をコピーした結果とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  5. output を返します。

8.9.8. clamp

最小値と最大値で指定された範囲内に、入力テンソルを要素単位で制限します。 
dictionary MLClampOptions : MLOperatorOptions {
  MLNumber minValue;
  MLNumber maxValue;
};

partial interface MLGraphBuilder {
  MLOperand clamp(MLOperand input, optional MLClampOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits clamp;
};

MLClampOptions には次のメンバーがあります。

minValue, 型は MLNumber

範囲の最小値。指定されていない場合、範囲の下限ではクランプを行いません。

maxValue, 型は MLNumber

範囲の最大値。指定されていない場合、範囲の上限ではクランプを行いません。

引数: 戻り値:
clamp() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16" N 0 から 5
出力 input と同じ "float32", "float16" input と同じ 0 から 5

MLOpSupportLimits には clamp() 用の次のメンバーがあります。

clamp, 型は MLSingleInputSupportLimits

clamp() 演算子のサポート制限。

clamp(input, options) メソッドの 手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、TypeError をスローします。

  3. minValue を、指定されている場合は options.minValue とし、それ以外の場合は Infinity とします。

  4. options.minValue を、minValue を input のdataType にキャストした結果に設定します。

  5. maxValue を、指定されている場合は options.maxValue とし、それ以外の場合は -Infinity とします。

  6. options.maxValue を、maxValue を input のdataType にキャストした結果に設定します。

  7. options.minValue が options.maxValue より大きい場合、TypeError をスローします。

  8. グラフの接続を行います。

    1. output を、input が与えられたときに MLOperand をコピーした結果とします。

    2. operator を、options が与えられた "clamp" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  9. output を返します。

この演算の動作は、ユーザーエージェントが通常はより効率的な実装を備えているものの、 次のように他の演算を使用して一般的にエミュレートできます。基盤プラットフォームが演算を 直接サポートしていない場合、この分解を実装の指針となるテンプレートとして使用できます。 
function clamp(builder, input, options) {
  if (options.minValue === undefined) {
    if (options.maxValue === undefined) {
      return input;
    } else {
      return builder.min(
        input, builder.constant(input.dataType, options.maxValue));
    }
  } else {
    if (options.maxValue === undefined) {
      return builder.max(
        input, builder.constant(input.dataType, options.minValue));
    } else {
      return builder.min(
        builder.max(input, builder.constant(input.dataType, options.minValue)),
        builder.constant(input.dataType, options.maxValue));
    }
  }
}

8.9.9. concat

指定された軸に沿って入力テンソルを連結します。 
partial interface MLGraphBuilder {
  MLOperand concat(sequence<MLOperand> inputs,
                   [EnforceRange] unsigned long axis,
                   optional MLOperatorOptions options = {});
};

dictionary MLConcatSupportLimits {
  MLTensorLimits inputs;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLConcatSupportLimits concat;
};
引数:

戻り値: MLOperand。 すべての入力を axis に沿って連結したテンソル。 出力テンソルは、すべての入力が連結される次元を除いて同じ shape を持ちます。 その次元のサイズは、同じ次元におけるすべての入力サイズの合計として計算されます。

concat() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
inputs の 項目 任意 "float32", "float16", "int32" 1 から N 1 から 5
出力 inputs の 項目と同じ "float32", "float16", "int32" inputs の 項目と同じ 1 から 5

MLConcatSupportLimits には次のメンバーがあります。

inputs, 型は MLTensorLimits

すべての入力オペランドの MLTensorLimits。

output, 型は MLTensorLimits

出力オペランドの MLTensorLimits。

MLOpSupportLimits には concat() 用の次のメンバーがあります。

concat, 型は MLConcatSupportLimits

concat() 演算子のサポート制限。

concat(inputs, axis, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と inputs 内のいずれかの項目で行った結果が false の場合、TypeError をスローします。

  3. inputs のサイズが有効なテンソル数でない場合、TypeError をスローします。

  4. first を inputs[0] とします。

  5. axis が first のランク以上の場合、TypeError をスローします。

  6. desc を、first のdataType と first のshape が与えられたときに MLOperandDescriptor を作成した結果とします。

  7. desc.shape[axis] を first のshape[axis] に設定します。

  8. 1 から inputs のサイズまでの範囲（上限を含まない）の各 index について反復します。

    1. input を inputs[index] とします。

    2. input のdataType が first のdataType と等しくない場合、TypeError をスローします。

    3. input のランクが first のランクと等しくない場合、TypeError をスローします。

    4. 0 から input のランクまでの範囲（上限を含まない）の各 dim について反復します。

      axis で指定された次元を除き、オペランドの対応する各次元の shape と型が 同じでない場合、失敗します。

      1. dim が axis と等しくなく、かつ input のshape[dim] が first のshape[dim] と等しくない場合、TypeError をスローします。

      2. dim が axis と等しい場合:

        1. size を desc.shape[axis] と input のshape[dim] の合計とします。

        2. size が有効な 次元でない場合、TypeError をスローします。

        3. desc.shape[axis] を size に設定します。

  9. グラフの接続を行います。

    1. output を、this と desc が与えられたときに MLOperand を作成した結果とします。

    2. operator を、inputs、axis、および options が与えられた "concat" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を inputs に設定します。

    5. operator の出力を output に設定します。

  10. output を返します。

8.9.10. conv2d

4-D の入力テンソルとフィルターテンソルから 2-D 畳み込みを計算します 
enum MLConv2dFilterOperandLayout {
  "oihw",
  "hwio",
  "ohwi",
  "ihwo"
};

dictionary MLConv2dOptions : MLOperatorOptions {
  sequence<[EnforceRange] unsigned long> padding;
  sequence<[EnforceRange] unsigned long> strides;
  sequence<[EnforceRange] unsigned long> dilations;
  [EnforceRange] unsigned long groups = 1;
  MLInputOperandLayout inputLayout = "nchw";
  MLConv2dFilterOperandLayout filterLayout = "oihw";
  MLOperand bias;
};

partial interface MLGraphBuilder {
  MLOperand conv2d(MLOperand input,
                   MLOperand filter,
                   optional MLConv2dOptions options = {});
};

dictionary MLConv2dSupportLimits {
  MLTensorLimits input;
  MLTensorLimits filter;
  MLTensorLimits bias;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLConv2dSupportLimits conv2d;
};

MLConv2dOptions には次のメンバーがあります。

padding, 型は sequence<[EnforceRange] unsigned long>

長さ 4 のリスト: [beginningHeight, endingHeight, beginningWidth, endingWidth]。 畳み込み入力の各空間次元の先頭と末尾に追加される行および列を指定します。 デフォルト値は [0, 0, 0, 0] です。

strides, 型は sequence<[EnforceRange] unsigned long>

長さ 2 のリスト: [strideHeight, strideWidth]。 畳み込み入力の各空間次元に対するスライディングウィンドウのストライドを指定します。 デフォルト値は [1, 1] です。

dilations, 型は sequence<[EnforceRange] unsigned long>

長さ 2 のリスト: [dilationHeight, dilationWidth]。畳み込みフィルター（カーネル）に適用される各 空間次元の dilation 係数を指定します。 デフォルト値は [1, 1] です。

groups, 型は unsigned long、デフォルトは 1

入力チャンネルと出力チャンネルを分割するグループ数。

inputLayout, 型は MLInputOperandLayout、デフォルトは "nchw"

入力テンソルおよび出力テンソルのレイアウト形式を次のように指定します。

  • "nchw"

    • 入力テンソル: [batches, inputChannels, height, width]

    • 出力テンソル: [batches, outputChannels, height, width]

  • "nhwc":

    • 入力テンソル: [batches, height, width, inputChannels]

    • 出力テンソル: [batches, height, width, outputChannels]

filterLayout, 型は MLConv2dFilterOperandLayout、デフォルトは "oihw"

フィルターテンソルのレイアウト形式を次のように指定します。

  • "oihw": [outputChannels, inputChannels/groups, height, width]

  • "hwio": [height, width, inputChannels/groups, outputChannels]

  • "ohwi": [outputChannels, height, width, inputChannels/groups]

  • "ihwo": [inputChannels/groups, height, width, outputChannels]

bias, 型は MLOperand

shape が [outputChannels] で、その値が畳み込み結果に加算される追加の 1-D テンソル。

引数:

戻り値: MLOperand。 畳み込み結果を含む出力 4-D テンソル。出力 shape は inputLayout に従って解釈されます。 より具体的には、"nchw" 入力レイアウトにおける出力テンソルの空間次元、すなわち最後の 2 次元のサイズは、 次のように計算できます。

outputSize = 1 + (inputSize - (filterSize - 1) * dilation - 1 + beginningPadding + endingPadding) / stride

conv2d() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" 4 4
filter input と同じ "float32", "float16" 4 4
bias input と同じ "float32", "float16" 1 1
出力 input と同じ "float32", "float16" 4 4

MLConv2dSupportLimits には次のメンバーがあります。

input, 型は MLTensorLimits

入力オペランドの MLTensorLimits。

filter, 型は MLTensorLimits

filter オペランドの MLTensorLimits。

bias, 型は MLTensorLimits

bias オペランドの MLTensorLimits。

output, 型は MLTensorLimits

出力オペランドの MLTensorLimits。

MLOpSupportLimits には conv2d() 用の次のメンバーがあります。

conv2d, 型は MLConv2dSupportLimits

conv2d() 演算子のサポート制限。

depthwise conv2d 演算は、MobileNet のようなモデルで使用される grouped convolution の一種であり、groups = inputChannels = outputChannels で、フィルターテンソルの shape は [options.groups, 1, height, width] （"oihw" レイアウトの場合）、[height, width, 1, options.groups]（"hwio" レイアウトの場合）、[options.groups, height, width, 1]（"ohwi" レイアウトの場合）、および [1, height, width, options.groups]（"ihwo" レイアウトの場合）です。
符号なし整数 inputSize、filterSize、beginningPadding、 endingPadding、stride および dilation が与えられたときに、conv 出力サイズを計算するには、次の手順を実行します。数値を返します。

  1. effectiveFilterSize を ( filterSize - 1 ) * dilation + 1 とします。

  2. outputSize を ( inputSize - effectiveFilterSize + beginningPadding + endingPadding ) / stride + 1 とします。

  3. outputSize を返します。

符号なし整数 inputHeight、inputWidth、filterHeight および filterWidth、4 個の符号なし整数のリスト padding、2 個の符号なし整数のリスト strides、および 2 個の符号なし整数のリスト dilations が与えられたときに、conv2d 出力サイズを計算するには、次の手順を実行します。 2 個の数値のリストを返します。

  1. outputHeight を、inputHeight、filterHeight、padding[0]、 padding[1]、strides[0] および dilations[0] が与えられたときに conv 出力サイズを計算した結果とします。

  2. outputWidth を、inputWidth、filterWidth、padding[2]、 padding[3]、strides[1] および dilations[1] が与えられたときに conv 出力サイズを計算した結果とします。

  3. « outputHeight, outputWidth » を返します。

conv2d(input, filter, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と、input、filter、および options.bias （それが存在する場合）のいずれかで行った結果が false の場合、TypeError をスローします。

  3. input のdataType が（この表に従って）その許可されるデータ型 のいずれでもない場合、TypeError をスローします。

  4. input のランクがその許可されるランクでない場合、TypeError をスローします。

  5. filter のランクがその許可されるランクでない場合、TypeError をスローします。

  6. filter のdataType が（この表に従って）その許可されるデータ型 のいずれでもない場合、TypeError をスローします。

  7. options.padding が存在しない場合、それをリスト « 0, 0, 0, 0 » に設定します。

  8. それ以外の場合、options.padding の サイズが 4 でない場合、TypeError をスローします。

  9. options.strides が存在しない場合、それをリスト « 1, 1 » に設定します。

  10. それ以外の場合、options.strides の サイズが 2 でない場合、TypeError をスローします。

  11. options.strides 内のいずれかの項目が 0 と等しい場合、TypeError をスローします。

  12. options.dilations が存在しない場合、それをリスト « 1, 1 » に設定します。

  13. それ以外の場合、options.dilations の サイズが 2 でない場合、TypeError をスローします。

  14. options.dilations 内のいずれかの項目が 0 と等しい場合、TypeError をスローします。

  15. options.groups が 0 の場合、TypeError をスローします。

  16. 出力 shape を計算します。

    1. inputShape を input のshape とします。

    2. options.inputLayout に応じて切り替えます。

      "nchw"

      « batches, inputChannels, inputHeight, inputWidth » を inputShape とします。

      "nhwc"

      « batches, inputHeight, inputWidth, inputChannels » を inputShape とします。

    3. filterShape を filter のshape とします。

    4. options.filterLayout に応じて切り替えます。

      "hwio"

      « filterHeight, filterWidth, filterInputChannels, outputChannels » を filterShape とします。

      "ohwi"

      « outputChannels, filterHeight, filterWidth, filterInputChannels » を filterShape とします。

      "ihwo"

      « filterInputChannels, filterHeight, filterWidth, outputChannels » を filterShape とします。

      "oihw"

      « outputChannels, filterInputChannels, filterHeight, filterWidth » を filterShape とします。

    5. inputChannels % options.groups が 0 でない場合、TypeError をスローします。

    6. それ以外の場合、inputChannels / options.groups が filterInputChannels と等しくない場合、TypeError をスローします。

    7. outputChannels % options.groups が 0 でない場合、TypeError をスローします。

    8. options.bias が存在する場合:

      1. そのshape が « outputChannels » と等しくない場合、TypeError をスローします。

      2. そのdataType が（この表に従って）その許可されるデータ型のいずれでもない場合、TypeError をスローします。

    9. « outputHeight, outputWidth » を、inputHeight、inputWidth、 filterHeight、filterWidth、options.padding、 options.strides、 および options.dilations が与えられたときにconv2d 出力サイズを計算した結果とします。

    10. outputHeight を floor( outputHeight ) に設定します。

    11. outputWidth を floor( outputWidth ) に設定します。

    12. outputHeight または outputWidth のいずれかが有効な 次元でない場合、TypeError をスローします。

    13. options.inputLayout に応じて切り替えます。

      "nchw"

      outputShape を « batches, outputChannels, outputHeight, outputWidth » とします。

      "nhwc"

      outputShape を « batches, outputHeight, outputWidth, outputChannels » とします。

    14. desc を、input のdataType と outputShape が与えられたときに MLOperandDescriptor を作成した結果とします。

  17. グラフの接続を行います。

    1. output を、this と desc が与えられたときにMLOperand を作成した結果とします。

    2. operator を、options および filter が与えられた "conv2d" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input および filter に設定します。

    5. options.bias が存在する場合、それを operator の入力に追加します。

    6. operator の出力を output に設定します。

  18. output を返します。

8.9.11. convTranspose2d

4-D の入力テンソルとフィルターテンソルから 2-D 転置畳み込みを計算します 
enum MLConvTranspose2dFilterOperandLayout {
  "iohw",
  "hwoi",
  "ohwi"
};

dictionary MLConvTranspose2dOptions : MLOperatorOptions {
  sequence<[EnforceRange] unsigned long> padding;
  sequence<[EnforceRange] unsigned long> strides;
  sequence<[EnforceRange] unsigned long> dilations;
  sequence<[EnforceRange] unsigned long> outputPadding;
  sequence<[EnforceRange] unsigned long> outputSizes;
  [EnforceRange] unsigned long groups = 1;
  MLInputOperandLayout inputLayout = "nchw";
  MLConvTranspose2dFilterOperandLayout filterLayout = "iohw";
  MLOperand bias;
};

partial interface MLGraphBuilder {
  MLOperand convTranspose2d(MLOperand input, MLOperand filter,
                            optional MLConvTranspose2dOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLConv2dSupportLimits convTranspose2d;
};

MLConvTranspose2dOptions には次のメンバーがあります。

padding, 型は sequence<[EnforceRange] unsigned long>

長さ 4 のリスト: [beginningHeight, endingHeight, beginningWidth, endingWidth]。 畳み込み入力の各空間次元の先頭と末尾に追加される行および列を指定します。 デフォルト値は [0, 0, 0, 0] です。

strides, 型は sequence<[EnforceRange] unsigned long>

長さ 2 のリスト: [strideHeight, strideWidth]。 畳み込み入力の各空間次元に対するスライディングウィンドウのストライドを指定します。 デフォルト値は [1, 1] です。

dilations, 型は sequence<[EnforceRange] unsigned long>

長さ 2 のリスト: [dilationHeight, dilationWidth]。畳み込みフィルター（カーネル）に適用される各 空間次元の dilation 係数を指定します。 デフォルト値は [1, 1] です。

outputPadding, 型は sequence<[EnforceRange] unsigned long>

長さ 2 のリスト。 出力テンソルの各空間次元に適用される padding 値を指定します。strides の値が 1 より大きい場合に、転置畳み込みの出力テンソル shape の曖昧さを解消するため、明示的な padding 値が必要になります。

これらの値は必要に応じて出力 shape の曖昧さを解消するためにのみ使用され、 必ずしも padding 値が出力テンソルに書き込まれるわけではないことに注意してください。

デフォルト値は [0, 0] です。

outputSizes, 型は sequence<[EnforceRange] unsigned long>

長さ 2 のリスト。 出力テンソルの最後の 2 次元のサイズを指定します。出力サイズが 明示的に指定された場合、outputPadding の出力 padding 値は無視されます。

指定されていない場合、出力サイズは自動的に計算されます。

groups, 型は unsigned long、デフォルトは 1

入力チャンネルと出力チャンネルを分割するグループ数。

inputLayout, 型は MLInputOperandLayout、デフォルトは "nchw"

入力テンソルおよび出力テンソルのレイアウト形式を次のように指定します。

  • "nchw"

    • 入力テンソル: [batches, inputChannels, height, width]

    • 出力テンソル: [batches, outputChannels, height, width]

  • "nhwc":

    • 入力テンソル: [batches, height, width, inputChannels]

    • 出力テンソル: [batches, height, width, outputChannels]

filterLayout, 型は MLConvTranspose2dFilterOperandLayout、 デフォルトは "iohw"

フィルターテンソルのレイアウト形式を次のように指定します。

  • "iohw": [inputChannels, outputChannels/groups, height, width]

  • "hwoi": [height, width, outputChannels/groups, inputChannels]

  • "ohwi": [outputChannels/groups, height, width, inputChannels]

bias, 型は MLOperand

shape が [outputChannels] で、その値が畳み込み結果に加算される追加の 1-D テンソル。

引数:

戻り値: MLOperand。 転置畳み込み結果を含む出力 4-D テンソル。出力 shape は inputLayout に従って解釈されます。 より具体的には、outputSizes が明示的に指定されていない限り、outputPadding は出力テンソルの空間次元値を次のように計算するために必要です。

outputSize = (inputSize - 1) * stride + (filterSize - 1) * dilation + 1 - beginningPadding - endingPadding + outputPadding

convTranspose2d() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" 4 4
filter input と同じ "float32", "float16" 4 4
bias input と同じ "float32", "float16" 1 1
出力 input と同じ "float32", "float16" 4 4

MLOpSupportLimits には convTranspose2d() 用の次のメンバーがあります。

convTranspose2d, 型は MLConv2dSupportLimits

convTranspose2d() 演算子のサポート制限。

符号なし整数 inputSize、filterSize、beginningPadding、 endingPadding、stride、および dilation が与えられたときに、 convtranspose 出力サイズを計算するには、 次の手順を実行します。数値を返します。

  1. effectiveFilterSize を ( filterSize - 1 ) * dilation + 1 とします。

  2. outputSize を ( inputSize - 1 ) * stride + effectiveFilterSize - beginningPadding - endingPadding とします。

  3. outputSize を返します。

convTranspose2d(input, filter, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と、input、filter、および options.bias （それが存在する場合）のいずれかで行った結果が false の場合、TypeError をスローします。

  3. input のランクがその許可されるランクでない場合、TypeError をスローします。

  4. input のdataType が（この表に従って）その許可されるデータ型 のいずれでもない場合、TypeError をスローします。

  5. filter のランクがその許可されるランクでない場合、TypeError をスローします。

  6. filter のdataType が（この表に従って）その許可されるデータ型 のいずれでもない場合、TypeError をスローします。

  7. options.padding が存在しない場合、それをリスト « 0, 0, 0, 0 » に設定します。

  8. それ以外の場合、options.padding の サイズが 4 でない場合、TypeError をスローします。

  9. options.strides が存在しない場合、それをリスト « 1, 1 » に設定します。

  10. それ以外の場合、options.strides の サイズが 2 でない場合、TypeError をスローします。

  11. options.strides 内のいずれかの項目が 0 と等しい場合、TypeError をスローします。

  12. options.dilations が存在しない場合、それをリスト « 1, 1 » に設定します。

  13. それ以外の場合、options.dilations の サイズが 2 でない場合、TypeError をスローします。

  14. options.dilations 内のいずれかの項目が 0 と等しい場合、TypeError をスローします。

  15. options.outputPadding が存在しない場合、それをリスト « 0, 0 » に設定します。

  16. それ以外の場合、options.outputPadding の サイズが 2 でない場合、TypeError をスローします。

  17. options.outputSizes が存在する場合:

    1. そのサイズが 2 でない場合、TypeError をスローします。

  18. それ以外の場合:

    1. options.outputPadding[0] が options.strides[0] 以上、または options.outputPadding[1] が options.strides[1] 以上の場合、TypeError をスローします。

  19. options.groups が 0 の場合、TypeError をスローします。

  20. 出力 shape を計算します。

    1. inputShape を input のshape とします。

    2. options.inputLayout に応じて切り替えます。

      "nchw"

      « batches, inputChannels, inputHeight, inputWidth » を inputShape とします。

      "nhwc"

      « batches, inputHeight, inputWidth, inputChannels » を inputShape とします。

    3. filterShape を filter のshape とします。

    4. options.filterLayout に応じて切り替えます。

      "iohw"

      « filterInputChannels, filterOutputChannels, filterHeight, filterWidth » を filterShape とします。

      "hwoi"

      « filterHeight, filterWidth, filterOutputChannels, filterInputChannels » を filterShape とします。

      "ohwi"

      « filterOutputChannels, filterHeight, filterWidth, filterInputChannels » を filterShape とします。

    5. inputChannels が filterInputChannels と等しくない場合、TypeError をスローします。

    6. outputChannels を filterOutputChannels * options.groups とします。

    7. outputChannels が有効な次元でない場合、TypeError をスローします。

    8. options.bias が存在する場合:

      1. そのshape が « outputChannels » と等しくない場合、TypeError をスローします。

      2. そのdataType が（この表に従って）その許可されるデータ型のいずれでもない場合、TypeError をスローします。

    9. calculatedOutputHeight を、inputHeight、filterHeight、 padding[0]、padding[1]、strides[0] および dilations[0] が与えられたときに convtranspose 出力サイズを計算した結果とします。

    10. calculatedOutputWidth を、inputWidth、filterWidth、 padding[2]、padding[3]、strides[1] および dilations[1] が与えられたときに convtranspose 出力サイズを計算した結果とします。

    11. options.outputSizes が存在する場合:

      1. « outputHeight, outputWidth » を options.outputSizes とします。

      2. outputHeight が calculatedOutputHeight より小さい、または outputHeight が calculatedOutputHeight + strides[0] 以上の場合、TypeError をスローします。

      3. outputWidth が calculatedOutputWidth より小さい、または outputWidth が calculatedOutputWidth + strides[1] 以上の場合、TypeError をスローします。

    12. それ以外の場合:

      1. outputHeight を calculatedOutputHeight + options.outputPadding[0] とします。

      2. outputWidth を calculatedOutputWidth + options.outputPadding[1] とします。

    13. outputHeight または outputWidth のいずれかが有効な 次元でない場合、TypeError をスローします。

    14. options.inputLayout に応じて切り替えます。

      "nchw"

      outputShape を « batches, outputChannels, floor( outputHeight ), floor( outputWidth ) » とします。

      "nhwc"

      outputShape を « batches, floor( outputHeight ), floor( outputWidth ), outputChannels » とします。

    15. desc を、input のdataType と outputShape が与えられたときに MLOperandDescriptor を作成した結果とします。

  21. グラフの接続を行います。

    1. output を、this と desc が与えられたときにMLOperand を作成した結果とします。

    2. operator を、options および filter が与えられた "convTranspose2d" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input および filter に設定します。

    5. options.bias が存在する場合、それを operator の入力に追加します。

    6. operator の出力を output に設定します。

  22. output を返します。

8.9.12. cumulativeSum

指定された軸に沿って一連の値の累積和を計算します。現在の値を含める場合と含めない場合の いずれかを選択できます。 
dictionary MLCumulativeSumOptions : MLOperatorOptions {
  boolean exclusive = false;
  boolean reversed = false;
};

partial interface MLGraphBuilder {
  MLOperand cumulativeSum(MLOperand input,
                          unsigned long axis,
                          optional MLCumulativeSumOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits cumulativeSum;
};
cumulativeSum() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16", "int32", "uint32", "int64", "uint64" "float32", "float16", "int32" 1 から N 1 から 5
出力 input と同じ "float32", "float16", "int32" input と同じ 1 から 5

MLCumulativeSumOptions には次のメンバーがあります。

exclusive, 型は boolean、デフォルトは false

出力に現在の値を含めるか除外するか。つまり、包含 prefix sum または 排他的 prefix sum [Prefix-sum] を意味します。入力 [1,2,3,4] が与えられた場合、包含和では [1,3,6,10] が出力され、排他的和では [0,1,3,6] が出力されます。デフォルト は包含です。

reversed, 型は boolean、デフォルトは false

アクティブな軸に沿った加算方向を反転し、高い 座標から低い座標へ開始するかどうか。入力 [1,2,3,4] が与えられた場合、包含前向き加算では [1,3,6,10] が出力され、包含後ろ向き加算では [10,9,7,4] が出力されます。デフォルトは前向きです。

引数:

戻り値:

MLOpSupportLimits には cumulativeSum() 用の次のメンバーがあります。

cumulativeSum, 型は MLSingleInputSupportLimits

cumulativeSum() 演算子のサポート制限。

cumulativeSum(input, axis, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、TypeError をスローします。

  3. input のdataType が（この表に従って）その許可されるデータ型 のいずれでもない場合、TypeError をスローします。

  4. axis が input のランク以上の場合、TypeError をスローします。

  5. グラフの接続を行います。

    1. output を、input が与えられたときに MLOperand をコピーした結果とします。

    2. operator を、"cumulativeSum" 演算および options 用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  6. output を返します。

8.9.13. 要素単位の二項演算

2 つの入力テンソルについて、要素単位の加算、減算、乗算、除算、累乗、最大値、および最小値を 計算します。

演算は ブロードキャスト されます。これは [numpy-broadcasting-rule] に従います。入力テンソルは双方向にブロードキャスト可能でなければなりません。出力テンソルのランクは 入力テンソルのランクの 最大値です。出力テンソルの各次元について、そのサイズは入力テンソルのその次元に沿った最大サイズです。

partial interface MLGraphBuilder {
  MLOperand add(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
  MLOperand sub(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
  MLOperand mul(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
  MLOperand div(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
  MLOperand max(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
  MLOperand min(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
  MLOperand pow(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLBinarySupportLimits add;
  MLBinarySupportLimits sub;
  MLBinarySupportLimits mul;
  MLBinarySupportLimits div;
  MLBinarySupportLimits max;
  MLBinarySupportLimits min;
  MLBinarySupportLimits pow;
};
引数:

戻り値: MLOperand。 2 つの入力テンソルの要素単位の二項演算結果を 含む出力テンソル。

演算の種類:
要素単位の二項演算のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
a 任意 "float32", "float16", "int32" N 0 から 5
b a と同じ "float32", "float16", "int32" N 0 から 5
出力 a と同じ "float32", "float16", "int32" N 0 から 5

MLOpSupportLimits には要素単位の二項演算用の次のメンバーがあります。

add, 型は MLBinarySupportLimits

add() 演算子のサポート制限。

sub, 型は MLBinarySupportLimits

sub() 演算子のサポート制限。

mul, 型は MLBinarySupportLimits

mul() 演算子のサポート制限。

div, 型は MLBinarySupportLimits

div() 演算子のサポート制限。

max, 型は MLBinarySupportLimits

max() 演算子のサポート制限。

min, 型は MLBinarySupportLimits

min() 演算子のサポート制限。

pow, 型は MLBinarySupportLimits

pow() 演算子のサポート制限。

文字列 op、MLOperand a、MLOperand b、および MLOperatorOptions options が与えられたときに 要素単位の 二項演算を作成するには、次の手順を実行します。

  1. 表明: op は "add", "sub", "mul", "div", "max", "min", "pow" のいずれかです。

  2. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  3. オペランドを検証する処理を this と a および b のいずれかで行った結果が false の場合、 スローします、TypeError を。

  4. a のdataType が b のdataType と等しくない場合、TypeError をスローします。

  5. outputShape を、a のshape と b のshape を双方向にブロードキャストした結果とします。

    1. それが失敗を返した場合、TypeError をスローします。

  6. descriptor を、a のdataType と outputShape が与えられたときに MLOperandDescriptor を 作成した結果とします。

  7. グラフの接続を行います。

    1. output を、this と descriptor が与えられたときに MLOperand を 作成した結果とします。

    2. operator を、a、b、および options が与えられた op 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を a および b に設定します。

    5. operator の出力を output に設定します。

  8. output を返します。

要素単位の二項演算アルゴリズムは、次のように 要素単位の二項演算を作成する 手順を呼び出します。
add(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"add"、a、b、および options が与えられたときに 要素単位の二項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

sub(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"sub"、a、b、および options が与えられたときに 要素単位の二項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

mul(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"mul"、a、b、および options が与えられたときに 要素単位の二項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

div(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"div"、a、b、および options が与えられたときに 要素単位の二項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

max(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"max"、a、b、および options が与えられたときに 要素単位の二項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

min(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"min"、a、b、および options が与えられたときに 要素単位の二項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

pow(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"pow"、a、b、および options が与えられたときに 要素単位の二項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

8.9.14. 要素単位の論理演算

入力テンソルを要素単位で比較し、比較結果として値 0（false）または 1（true）の "uint8" テンソルを返します。単一オペランド演算の場合は、演算の論理 結果を返します。

複数オペランド演算の場合、演算は ブロードキャストされます。これは [numpy-broadcasting-rule] に従います。入力テンソルは双方向にブロードキャスト可能でなければなりません。出力テンソルのランクは 入力テンソルのランクの 最大値です。出力テンソルの各次元について、そのサイズは入力テンソルのその次元に沿った最大サイズです。 

partial interface MLGraphBuilder {
  MLOperand equal(MLOperand a,
                  MLOperand b,
                  optional MLOperatorOptions options = {});
  MLOperand notEqual(MLOperand a,
                     MLOperand b,
                     optional MLOperatorOptions options = {});
  MLOperand greater(MLOperand a,
                    MLOperand b,
                    optional MLOperatorOptions options = {});
  MLOperand greaterOrEqual(MLOperand a,
                           MLOperand b,
                           optional MLOperatorOptions options = {});
  MLOperand lesser(MLOperand a,
                   MLOperand b,
                   optional MLOperatorOptions options = {});
  MLOperand lesserOrEqual(MLOperand a,
                          MLOperand b,
                          optional MLOperatorOptions options = {});
  MLOperand logicalNot(MLOperand a, optional MLOperatorOptions options = {});
  MLOperand logicalAnd(MLOperand a,
                       MLOperand b,
                       optional MLOperatorOptions options = {});
  MLOperand logicalOr(MLOperand a,
                      MLOperand b,
                      optional MLOperatorOptions options = {});
  MLOperand logicalXor(MLOperand a,
                       MLOperand b,
                       optional MLOperatorOptions options = {});
  MLOperand isNaN(MLOperand a, optional MLOperatorOptions options = {});
  MLOperand isInfinite(MLOperand a, optional MLOperatorOptions options = {});
};

dictionary MLLogicalNotSupportLimits {
  MLTensorLimits a;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLBinarySupportLimits equal;
  MLBinarySupportLimits notEqual;
  MLBinarySupportLimits greater;
  MLBinarySupportLimits greaterOrEqual;
  MLBinarySupportLimits lesser;
  MLBinarySupportLimits lesserOrEqual;
  MLLogicalNotSupportLimits logicalNot;
  MLBinarySupportLimits logicalAnd;
  MLBinarySupportLimits logicalOr;
  MLBinarySupportLimits logicalXor;
  MLLogicalNotSupportLimits isNaN;
  MLLogicalNotSupportLimits isInfinite;
};
引数:

戻り値: MLOperand。 2 つの入力テンソルを要素単位で比較した結果を含む出力テンソル。

equal()/notEqual()/greater()/greaterOrEqual()/lesser()/lesserOrEqual() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
a 任意 "float32", "float16", "int32" N 0 から 5
b a と同じ "float32", "float16", "int32" N 0 から 5
出力 "uint8" "uint8" N 0 から 5
logicalNot() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
a "uint8" "uint8" N 0 から 5
出力 "uint8" "uint8" N 0 から 5
logicalAnd()/logicalOr()/logicalXor() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
a "uint8" "uint8" N 0 から 5
b a と同じ "uint8" N 0 から 5
出力 "uint8" "uint8" N 0 から 5
isNaN()/isInfinite() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
a 任意 "float32", "float16" N 0 から 5
出力 "uint8" "uint8" N 0 から 5

MLLogicalNotSupportLimits には次のメンバーがあります。

a, 型は MLTensorLimits

a オペランドの MLTensorLimits。

output, 型は MLTensorLimits

出力オペランドの MLTensorLimits。

MLOpSupportLimits には要素単位の論理演算用の次のメンバーがあります。

equal, 型は MLBinarySupportLimits

equal() 演算子のサポート制限。

notEqual, 型は MLBinarySupportLimits

notEqual() 演算子のサポート制限。

greater, 型は MLBinarySupportLimits

greater() 演算子のサポート制限。

greaterOrEqual, 型は MLBinarySupportLimits

greaterOrEqual() 演算子のサポート制限。

lesser, 型は MLBinarySupportLimits

lesser() 演算子のサポート制限。

lesserOrEqual, 型は MLBinarySupportLimits

lesserOrEqual() 演算子のサポート制限。

logicalNot, 型は MLLogicalNotSupportLimits

logicalNot() 演算子のサポート制限。

logicalAnd, 型は MLBinarySupportLimits

logicalAnd() 演算子のサポート制限。

logicalOr, 型は MLBinarySupportLimits

logicalOr() 演算子のサポート制限。

logicalXor, 型は MLBinarySupportLimits

logicalXor() 演算子のサポート制限。

isNaN, 型は MLLogicalNotSupportLimits

isNaN() 演算子のサポート制限。

isInfinite, 型は MLLogicalNotSupportLimits

isInfinite() 演算子のサポート制限。

演算の種類:
greaterOrEqual() および lesserOrEqual() 演算は、それぞれ logicalNot()、 lesser()、 および greater() 演算を用いて実装できます （つまり builder.greaterOrEqual(a, b) は builder.logicalNot(builder.lesser(a, b)) です）が、NaN の場合を処理し、 二重比較を避けて性能を向上させるために明示的に定義されています。
文字列 op、MLOperand a、オプションの MLOperand b、および MLOperatorOptions options が与えられたときに 要素単位の 論理演算を作成するには、次の手順を実行します。

  1. 表明: op は "equal", "notEqual", "greater", "greaterOrEqual", "lesser", "lesserOrEqual", "logicalNot", "logicalAnd", "logicalOr", "logicalXor", "isNaN", "isInfinite" のいずれかです。

  2. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  3. オペランドを検証する処理を this と a で行った結果が false の場合、TypeError をスローします。

  4. op が "logicalNot", "logicalAnd", "logicalOr", "logicalXor" のいずれかの場合:

    1. a のdataType が "uint8" でない場合、TypeError をスローします。

  5. op が "isNaN", "isInfinite" のいずれかの場合:

    1. a のdataType が « "float32", "float16" » のいずれでもない場合、TypeError をスローします。

  6. b が渡された場合:

    1. オペランドを検証する処理を this と b で行った結果が false の場合、TypeError をスローします。

    2. a のdataType が b のdataType と等しくない場合、TypeError をスローします。

    3. outputShape を、a のshape と b のshape を双方向にブロードキャストした結果とします。それが 失敗を返した場合、TypeError をスローします。

  7. それ以外の場合:

    1. outputShape を a のshape の複製 とします。

  8. descriptor を、"uint8" と outputShape が与えられたときに MLOperandDescriptor を 作成した結果とします。

  9. グラフの接続を行います。

    1. output を、this と descriptor が与えられたときに MLOperand を 作成した結果とします。

    2. operator を、a および（b が渡された場合は）b、 および options が与えられた op 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を a および（b が 渡された場合は）b に設定します。

    5. operator の出力を output に設定します。

  10. output を返します。

要素単位の論理演算アルゴリズムは、次のように 要素単位の論理演算を作成する 手順を呼び出します。
equal(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"equal"、a、b、および options が与えられたときに 要素単位の論理 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

notEqual(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"notEqual"、a、b、および options が与えられたときに 要素単位の論理 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

greater(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"greater"、a、b、および options が与えられたときに 要素単位の論理 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

greaterOrEqual(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"greaterOrEqual"、a、b、および options が与えられたときに 要素単位の論理 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

lesser(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"lesser"、a、b、および options が与えられたときに 要素単位の論理 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

lesserOrEqual(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"lesserOrEqual"、a、b、および options が与えられたときに 要素単位の論理 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

logicalNot(a, options) メソッドの手順は次のとおりです。

  1. output を、"logicalNot"、a、および options が与えられたときに 要素単位の論理 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

logicalAnd(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"logicalAnd"、a、b、および options が与えられたときに 要素単位の論理 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

logicalOr(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"logicalOr"、a、b、および options が与えられたときに 要素単位の論理 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

logicalXor(a, b, options) メソッドの手順は次のとおりです。

  1. output を、"logicalXor"、a、b、および options が与えられたときに 要素単位の論理 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

isNaN(a, options) メソッドの 手順は次のとおりです。

  1. output を、"isNaN"、a、および options が与えられたときに 要素単位の論理 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

isInfinite(a, options) メソッドの手順は次のとおりです。

  1. output を、"isInfinite"、a、および options が与えられたときに 要素単位の論理 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

8.9.15. 要素単位の単項演算

入力テンソルに対して要素単位の単項演算を計算します。 
partial interface MLGraphBuilder {
  MLOperand abs(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand ceil(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand cos(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand erf(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand exp(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand floor(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand identity(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand log(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand neg(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand reciprocal(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand roundEven(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand sin(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand sign(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand sqrt(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand tan(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits abs;
  MLSingleInputSupportLimits ceil;
  MLSingleInputSupportLimits cos;
  MLSingleInputSupportLimits erf;
  MLSingleInputSupportLimits exp;
  MLSingleInputSupportLimits floor;
  MLSingleInputSupportLimits identity;
  MLSingleInputSupportLimits log;
  MLSingleInputSupportLimits neg;
  MLSingleInputSupportLimits reciprocal;
  MLSingleInputSupportLimits roundEven;
  MLSingleInputSupportLimits sin;
  MLSingleInputSupportLimits sign;
  MLSingleInputSupportLimits sqrt;
  MLSingleInputSupportLimits tan;
};
引数:

戻り値: MLOperand。 入力テンソルに対する要素単位の単項演算の結果を 含む出力テンソル。出力テンソルの shape は 入力テンソルの shape と同じです。

abs()/neg() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16", "int64", "int32", "int8" "float32", "float16", "int32" N 0 から 5
出力 input と同じ "float32", "float16", "int32" input と同じ 0 から 5
ceil()/cos()/erf()/exp()/floor()/log()/reciprocal()/roundEven()/sin()/sqrt()/tan() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" N 0 から 5
出力 input と同じ "float32", "float16" input と同じ 0 から 5
identity() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32" N 0 から 5
出力 input と同じ "float32", "float16", "int32" input と同じ 0 から 5
sign() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16", "int64", "int32", "int8" "float32", "float16", "int32" N 0 から 5
出力 input と同じ "float32", "float16", "int32" input と同じ 0 から 5

MLOpSupportLimits には要素単位の単項演算用の次のメンバーがあります。

abs, 型は MLSingleInputSupportLimits

abs() 演算子のサポート制限。

ceil, 型は MLSingleInputSupportLimits

ceil() 演算子のサポート制限。

cos, 型は MLSingleInputSupportLimits

cos() 演算子のサポート制限。

erf, 型は MLSingleInputSupportLimits

erf() 演算子のサポート制限。

exp, 型は MLSingleInputSupportLimits

exp() 演算子のサポート制限。

floor, 型は MLSingleInputSupportLimits

floor() 演算子のサポート制限。

identity, 型は MLSingleInputSupportLimits

identity() 演算子のサポート制限。

log, 型は MLSingleInputSupportLimits

log() 演算子のサポート制限。

neg, 型は MLSingleInputSupportLimits

neg() 演算子のサポート制限。

reciprocal, 型は MLSingleInputSupportLimits

reciprocal() 演算子のサポート制限。

roundEven, 型は MLSingleInputSupportLimits

roundEven() 演算子のサポート制限。

sin, 型は MLSingleInputSupportLimits

sin() 演算子のサポート制限。

sign, 型は MLSingleInputSupportLimits

sign() 演算子のサポート制限。

sqrt, 型は MLSingleInputSupportLimits

sqrt() 演算子のサポート制限。

tan, 型は MLSingleInputSupportLimits

tan() 演算子のサポート制限。

演算の種類:
文字列 op、MLOperand input、オプションのリスト allowedDataTypes、および options が与えられたときに 要素単位の 単項演算を作成するには、次の手順を実行します。

  1. 表明: op は "abs", "ceil", "cos", "erf", "exp", "floor", "identity", "log", "neg", "reciprocal", "roundEven", "sin", "sign", "sqrt", "tan" のいずれかです。

  2. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  3. オペランドを検証する処理を this と input で行った結果が false の場合、TypeError をスローします。

  4. allowedDataTypes が与えられ、それが input のdataType を含まない場合、TypeError をスローします。

  5. グラフの接続を行います。

    1. output を、input が与えられたときに MLOperand をコピーした結果とします。

    2. operator を、options が与えられた op 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  6. output を返します。

要素単位の単項演算アルゴリズムは、次のように 要素単位の単項演算を作成する手順を 呼び出します。
abs(input, options) メソッドの 手順は次のとおりです。

  1. output を、"abs"、input、« "float32", "float16", "int64", "int32", "int8" »、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

ceil(input, options) メソッドの 手順は次のとおりです。

  1. output を、"ceil"、input、« "float32", "float16" »、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

cos(input, options) メソッドの 手順は次のとおりです。

  1. output を、"cos"、input、« "float32", "float16" »、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

erf(input, options) メソッドの 手順は次のとおりです。

  1. output を、"erf"、input、« "float32", "float16" »、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

exp(input, options) メソッドの 手順は次のとおりです。

  1. output を、"exp"、input、« "float32", "float16" »、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

floor(input, options) メソッドの 手順は次のとおりです。

  1. output を、"floor"、input、« "float32", "float16" »、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

identity(input, options) メソッドの手順は次のとおりです。

  1. output を、"identity"、input、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

log(input, options) メソッドの 手順は次のとおりです。

  1. output を、"log"、input、« "float32", "float16" »、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

neg(input, options) メソッドの 手順は次のとおりです。

  1. output を、"neg"、input、« "float32", "float16", "int64", "int32", "int8" »、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

reciprocal(input, options) メソッドの手順は次のとおりです。

  1. output を、"reciprocal"、input、« "float32", "float16" »、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

roundEven(input, options) メソッドの手順は次のとおりです。

  1. output を、"roundEven"、input、« "float32", "float16" »、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

sin(input, options) メソッドの 手順は次のとおりです。

  1. output を、"sin"、input、« "float32", "float16" »、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

sign(input, options) メソッドの 手順は次のとおりです。

  1. output を、"sign"、input、« "float32", "float16", "int64", "int32", "int8" »、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

sqrt(input, options) メソッドの 手順は次のとおりです。

  1. output を、"sqrt"、input、« "float32", "float16" »、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

tan(input, options) メソッドの 手順は次のとおりです。

  1. output を、"tan"、input、« "float32", "float16" »、および options が与えられたときに 要素単位の単項 演算を作成した結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

sign() 演算の動作は、ユーザーエージェントが通常はより効率的な実装を備えているものの、次のように他の演算を 使用して一般的にエミュレートできます。基盤プラットフォームが演算を直接 サポートしていない場合、この分解を実装の指針となるテンプレートとして 使用できます。 
function sign(builder, input, options) {
  const zero = builder.constant(input.dataType, 0);
  const positiveOne = builder.constant(input.dataType, 1);
  const negativeOne = builder.constant(input.dataType, -1);

  return builder.where(
    builder.greater(input, zero),
    positiveOne,
    builder.where(builder.lesser(input, zero), negativeOne, zero));
}

8.9.16. dequantizeLinear

scale とゼロポイントバイアスを使用して整数テンソルを浮動小数点テンソルに逆量子化します。ここで output = (input - zeroPoint) * scale です。scale および zeroPoint テンソルはブロック単位でブロードキャスト可能であるため、input テンソルより小さくても構いません。 
partial interface MLGraphBuilder {
  MLOperand dequantizeLinear(MLOperand input,
                             MLOperand scale,
                             MLOperand zeroPoint,
                             optional MLOperatorOptions options = {});
};

dictionary MLQuantizeDequantizeLinearSupportLimits {
  MLTensorLimits input;
  MLTensorLimits scale;
  MLTensorLimits zeroPoint;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLQuantizeDequantizeLinearSupportLimits dequantizeLinear;
};
引数:

戻り値: MLOperand。 逆量子化された値を含む出力テンソル。

dequantizeLinear() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "uint8", "int8", "uint32", "int32" "uint8", "int8" N 0 から 5
scale "float32", "float16" "float32", "float16" input と同じ 0 から 5
zeroPoint input と同じ "uint8", "int8", "int32" input と同じ 0 から 5
出力 scale と同じ "float32", "float16" input と同じ 0 から 5

MLQuantizeDequantizeLinearSupportLimits には次のメンバーがあります。

input, 型は MLTensorLimits

input オペランドの MLTensorLimits。

scale, 型は MLTensorLimits

scale オペランドの MLTensorLimits。

zeroPoint, 型は MLTensorLimits

zeroPoint オペランドの MLTensorLimits。

output, 型は MLTensorLimits

出力オペランドの MLTensorLimits。

MLOpSupportLimits には dequantizeLinear() 用の次のメンバーがあります。

dequantizeLinear, 型は MLQuantizeDequantizeLinearSupportLimits

dequantizeLinear() 演算子のサポート制限。

dequantizeLinear(input, scale, zeroPoint, options) メソッドの手順は次のとおりです。

  1. this.[[hasBuilt]] が true の場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input、scale、および zeroPoint のいずれかで行った結果が false の場合、TypeError をスローします。

  3. input のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. scale のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  5. zeroPoint のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  6. zeroPoint のdataType が input のdataType と等しくない場合、TypeError をスローします。

  7. scale のランクまたは zeroPoint のランクが input のランクと等しくない場合、TypeError をスローします。

  8. scale のshape が zeroPoint のshape と等しくない場合、TypeError をスローします。

  9. scale のshape と input のshape をブロック単位でブロードキャストする処理が false を返した場合、TypeError をスローします。

  10. zeroPoint のshape と input のshape をブロック単位でブロードキャストする処理が false を返した場合、TypeError をスローします。

  11. outputDescriptor を、scale のdataType と input のshape が与えられたときに MLOperandDescriptor を 作成した結果とします。

  12. グラフの接続を行います。

    1. output を、this と outputDescriptor が与えられたときに MLOperand を 作成した結果とします。

    2. operator を、input、scale、zeroPoint、および options が与えられた "dequantizeLinear" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  13. output を返します。

この演算の動作は、ユーザーエージェントが通常はより効率的な実装を備えているものの、他の演算を使用して 次のように一般的にエミュレートできます。基盤となるプラットフォームが 演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function dequantizeLinear(builder, input, scale, zeroPoint, options) {
  // output = (input - zeroPoint) * scale
  const floatInput = builder.cast(input, scale.dataType);
  const floatZeroPoint = builder.cast(zeroPoint, scale.dataType);
  const upsampledScale = blockwiseExpand(builder, scale, input.shape);
  const upsampledZeroPoint =
    blockwiseExpand(builder, floatZeroPoint, input.shape);
  return builder.mul(
    builder.sub(floatInput, upsampledZeroPoint), upsampledScale);
}

function blockwiseExpand(builder, input, outputShape) {
  // 元の input と目的の出力 shape が与えられたとき、各軸について
  // その軸ごとの回数だけブロックを繰り返して拡張します。ただし、バックエンドの
  // 実装には、複数の次元を受け取り、すべての次元を一度に
  // 整数倍（tile のように）でアップサンプリングできる、より効率的なアップサンプリング演算子が
  // 最近傍再サンプリングを使用して存在する場合があります:
  // output = resample(scale, {sizes: input.shape})

  let output = input;

  for (let axis = 0; axis < input.shape.length; ++axis) {
    const oldShape = output.shape;
    const oldDimensionLength = oldShape[axis];
    const newDimensionLength = outputShape[axis];

    if (newDimensionLength != oldDimensionLength) {
      // tile/expand は次元全体のスライスの反復しか受け付けられないため
      // （軸に沿って個々の要素を繰り返すことはできないため）、一時的に
      // テンソルを reshape し、挿入したサイズ 1 の次元を利用して
      // 要素を完全なブロックサイズまでブロードキャストできるようにします。
      const elementRepeatCount = newDimensionLength / oldDimensionLength;
      const flattenedShape = getFlattenedShapeAroundAxis(oldShape, axis);
      const unexpandedShape =
        [flattenedShape[0], flattenedShape[1], 1, flattenedShape[2]];
      const expandedShape = [
        flattenedShape[0],
        flattenedShape[1],
        elementRepeatCount,
        flattenedShape[2]
      ];
      const reshapedInput = builder.reshape(output, unexpandedShape);
      output = builder.expand(reshapedInput, expandedShape);

      let newShape = [...oldShape];
      newShape[axis] = newDimensionLength;
      output = builder.reshape(output, newShape);
    }
  }

  return output;
}

// 指定された軸の前後の平坦化された shape を計算し、
// 3 要素のリストを生成します。例:
// - inputShape = [2,3,4,5,6]、axis = 2 の場合、shape [6,4,30] を生成します。
// - inputShape = [4]、axis = 0 の場合、shape [1,4,1] を生成します。
function getFlattenedShapeAroundAxis(inputShape, axis) {
  axis = Math.max(Math.min(axis, inputShape.length - 1), 0);
  const shapeBefore = inputShape.slice(0, axis);
  const shapeAfter = inputShape.slice(axis + 1, inputShape.length);
  const countBefore = shapeBefore.reduce((a, b) => a * b, 1);
  const countAfter = shapeAfter.reduce((a, b) => a * b, 1);
  return [countBefore, inputShape[axis], countAfter];
}

8.9.17. quantizeLinear

scale とゼロポイントバイアスを使用して浮動小数点テンソルを整数テンソルに量子化します（例: "uint8" の場合は output = clamp(roundEven(input / scale) + zeroPoint, 0, 255)）。scale および zeroPoint テンソルはブロック単位でブロードキャストされるため、input テンソルより小さくても構いません。 
partial interface MLGraphBuilder {
  MLOperand quantizeLinear(MLOperand input,
                           MLOperand scale,
                           MLOperand zeroPoint,
                           optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLQuantizeDequantizeLinearSupportLimits quantizeLinear;
};
引数:

戻り値: MLOperand。 量子化された値を含む出力テンソル。

quantizeLinear() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" N 0 から 5
scale input と同じ "float32", "float16" input と同じ 0 から 5
zeroPoint "uint8", "int8", "uint32", "int32" "uint8", "int8" input と同じ 0 から 5
出力 zeroPoint と同じ "uint8", "int8" input と同じ 0 から 5

MLOpSupportLimits には quantizeLinear() 用の次のメンバーがあります。

quantizeLinear, 型は MLQuantizeDequantizeLinearSupportLimits

quantizeLinear() 演算子のサポート制限。

quantizeLinear(input, scale, zeroPoint, options) メソッドの手順は次のとおりです。

  1. this.[[hasBuilt]] が true の場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input、scale、および zeroPoint のいずれかで行った結果が false の場合、TypeError をスローします。

  3. input のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. scale のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  5. scale のdataType が input のdataType と等しくない場合、TypeError をスローします。

  6. zeroPoint のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  7. scale のランクまたは zeroPoint のランクが input のランクと等しくない場合、TypeError をスローします。

  8. scale のshape が zeroPoint のshape と等しくない場合、TypeError をスローします。

  9. scale のshape と input のshape をブロック単位でブロードキャストする処理が false を返した場合、TypeError をスローします。

  10. zeroPoint のshape と input のshape をブロック単位でブロードキャストする処理が false を返した場合、TypeError をスローします。

  11. outputDescriptor を、zeroPoint のdataType と input のshape が与えられたときに MLOperandDescriptor を 作成した結果とします。

  12. グラフの接続を行います。

    1. output を、this と outputDescriptor が与えられたときに MLOperand を 作成した結果とします。

    2. operator を、input、scale、zeroPoint、および options が与えられた "quantizeLinear" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  13. output を返します。

この演算の動作は、ユーザーエージェントが通常はより効率的な実装を備えているものの、他の演算を使用して 次のように一般的にエミュレートできます。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function quantizeLinear(builder, input, scale, zeroPoint, options) {
  // output = clamp(roundEven(input / scale) + zeroPoint, 0, 255)
  // blockwiseExpand は dequantizeLinear で定義されていることに注意してください。

  const floatZeroPoint = builder.cast(zeroPoint, scale.dataType);
  const upsampledScale = blockwiseExpand(builder, scale, input.shape);
  const upsampledZeroPoint =
    blockwiseExpand(builder, floatZeroPoint, input.shape);
  const quantizedInput = builder.roundEven(builder.div(input, upsampledScale));
  const zeroPointAdjustedInput =
    builder.add(quantizedInput, upsampledZeroPoint);
  const clampedInput =
    builder.clamp(zeroPointAdjustedInput, {'minValue': 0, 'maxValue': 255});
  return builder.cast(clampedInput, zeroPoint.dataType);
}

8.9.18. elu

入力テンソルに対して指数線形ユニット 関数（ELU）を要素単位で計算します。計算は式 max(0, x) + alpha * (exp(min(0, x)) - 1) に従います。 
dictionary MLEluOptions : MLOperatorOptions {
  double alpha = 1;
};

partial interface MLGraphBuilder {
  MLOperand elu(MLOperand input, optional MLEluOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits elu;
};

MLEluOptions には次のメンバーがあります。

alpha, 型は double、デフォルトは 1

スカラー乗数。

引数:

戻り値:

elu() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" N 0 から 5
出力 input と同じ "float32", "float16" input と同じ 0 から 5

MLOpSupportLimits には elu() 用の次のメンバーがあります。

elu, 型は MLSingleInputSupportLimits

elu() 演算子のサポート制限。

elu(input, options) メソッドの 手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、TypeError をスローします。

  3. input のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. options.alpha を options.alpha を input のdataType にキャストした 結果に設定します。

  5. グラフの接続を行います。

    1. output を、input が与えられたときに MLOperand をコピーした結果とします。

    2. operator を、options が与えられた "elu" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  6. output を返します。

この演算の動作は、ユーザーエージェントが通常はより効率的な実装を備えているものの、他の演算を使用して 次のように一般的にエミュレートできます。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function elu(builder, input, options) {
  return builder.add(
    builder.max(builder.constant(input.dataType, 0), input),
    builder.mul(
      builder.constant(input.dataType, options.alpha),
      builder.sub(
        builder.exp(builder.min(builder.constant(input.dataType, 0), input)),
        builder.constant(input.dataType, 1))));
}

8.9.19. expand

新しい shape に従って、入力テンソルのサイズ 1 の任意の次元をより大きなサイズへ拡張します。この拡張は [numpy-broadcasting-rule] と整合します。入力テンソルは新しい shape へ単方向にブロードキャスト可能でなければならず、各 次元はサイズ 1 であるか、新しい shape に従って対応する出力次元のサイズと一致しなければなりません。 
partial interface MLGraphBuilder {
  MLOperand expand(MLOperand input,
                   sequence<[EnforceRange] unsigned long> newShape,
                   optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits expand;
};
引数:

戻り値: MLOperand。 サイズ shape が拡張されたテンソル。

expand() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32" N 0 から 5
出力 input と同じ "float32", "float16", "int32" N 0 から 5

MLOpSupportLimits には expand() 用の次のメンバーがあります。

expand, 型は MLSingleInputSupportLimits

expand() 演算子のサポート制限。

expand(input, newShape, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、TypeError をスローします。

  3. outputShape を、 input のshape と newShape を単方向にブロードキャストした結果とします。

    1. それが失敗を返した場合、TypeError をスローします。

  4. outputShape のサイズが 出力テンソルの許可されるランクでない場合（この表に従って）、TypeError をスローします。

  5. outputDescriptor を、input のdataType と outputShape が与えられたときに MLOperandDescriptor を 作成した結果とします。

  6. グラフの接続を行います。

    1. output を、this と outputDescriptor が与えられたときに MLOperand を 作成した結果とします。

    2. operator を、input、newShape、および options が与えられた "expand" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  7. output を返します。

8.9.20. gather

indices に従って、軸に沿って入力テンソルの値を収集します。 
dictionary MLGatherOptions : MLOperatorOptions {
  [EnforceRange] unsigned long axis = 0;
};

partial interface MLGraphBuilder {
  MLOperand gather(MLOperand input,
                   MLOperand indices,
                   optional MLGatherOptions options = {});
};

dictionary MLGatherSupportLimits {
  MLTensorLimits input;
  MLTensorLimits indices;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLGatherSupportLimits gather;
};

MLGatherOptions には次のメンバーがあります。

axis, 型は unsigned long、デフォルトは 0

収集された値を取得する軸。値は [0, N-1] の範囲内でなければならず、ここで N は入力テンソルのランクです。

引数:

戻り値: MLOperand。 ランクが input のランク + indices のランク - 1 に等しい出力 N-D テンソル。

indices パラメーターは gather() に対して、入力は実行時まで判明しないため、グラフのビルド時に許可範囲へクランプ できません。指定されたクランプ動作が基盤プラットフォームによって提供されない場合、実装はコンパイル済みグラフに clamp() を導入できます。同様に、基盤プラットフォームが負のインデックスをサポートしていない場合、実装は コンパイル済みグラフに演算を導入し、次元の末尾からの負のインデックスを正の インデックスへ変換できます。
gather() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32", "int8", "uint8" 1 から N 1 から 5
indices "int32", "uint32", "int64" "int32" N 0 から 5
出力 input と同じ "float32", "float16", "int32", "int8", "uint8" N 0 から 5

MLGatherSupportLimits には次のメンバーがあります。

input, 型は MLTensorLimits

input オペランドの MLTensorLimits。

indices, 型は MLTensorLimits

indices オペランドの MLTensorLimits。

output, 型は MLTensorLimits

出力オペランドの MLTensorLimits。

MLOpSupportLimits には gather() 用の次のメンバーがあります。

gather, 型は MLGatherSupportLimits

gather() 演算子のサポート制限。

gather(input, indices, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input および indices のいずれかで行った結果が false の場合、TypeError をスローします。

  3. indices のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. inputShape を input のshape とし、inputRank を input のランクとします。

  5. indicesShape を indices のshape とします。

  6. axis を options.axis とします。

  7. axis が inputRank 以上の場合、TypeError をスローします。

  8. dimCount を 0 とします。

  9. outputRank を 0 とします。

  10. outputShape を空のリストとします。

  11. inputShape の各 size について反復します。

    1. dimCount が axis と等しい場合、中断します。

    2. outputShape[dimCount] を size に設定します。

    3. dimCount を 1 増加させます。

  12. outputRank を dimCount に設定します。

  13. dimCount を 0 とします。

  14. indicesShape の各 size について反復します。

    1. outputShape[outputRank + dimCount] を size に設定します。

    2. dimCount を 1 増加させます。

  15. outputRank を outputRank + dimCount に設定します。

  16. dimCount を 0 とします。

  17. inputShape の各 size について反復します。

    1. dimCount が axis 以下の場合、続行します。

    2. outputShape[outputRank + dimCount - axis - 1] を size に設定します。

    3. dimCount を 1 増加させます。

  18. desc を、input のdataType と outputShape が与えられたときに MLOperandDescriptor を 作成した結果とします。

  19. グラフの接続を行います。

    1. output を、desc が与えられたときに MLOperand を 作成した結果とします。

    2. operator を、input、indices、および options が与えられた "gather" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input および indices に設定します。

    5. operator の出力を output に設定します。

  20. output を返します。

異なるスライス方式で gather がどのように動作するかの例。 
// shape [4,3] の input:
//   [[ 0,  1,  2],
//    [10, 11, 12],
//    [20, 21, 22],
//    [30, 31, 32]]
const input = builder.constant(
  {dataType: 'float32', shape: [4, 3]},
  new Float32Array([0, 1, 2, 10, 11, 12, 20, 21, 22, 30, 31, 32]));

// axis = 0（デフォルト）
// shape [2] の indices:
//   [3,1]
// shape [2,3] の output:
//   [[30, 31, 32],
//    [10, 11, 12]]

const indices1 =
  builder.constant({dataType: 'uint32', shape: [2]}, new Uint32Array([3, 1]));

const output1 = builder.gather(input, indices1);

// axis = 1
// shape [3] の indices:
//   [2,1,1]
// shape [4,3] の output:
//   [[ 2,  1,  1],
//    [12, 11, 11],
//    [22, 21, 21],
//    [32, 31, 31]]

const indices2 = builder.constant(
  {dataType: 'uint32', shape: [3]}, new Uint32Array([2, 1, 1]));

const output2 = builder.gather(input, indices2, {axis: 1});

// axis = 1
// shape [2,2] の indices:
//   [[0, 1],
//    [1, 2]]
// shape [4,2,2] の output:
//   [[[ 0,  1], [ 1,  2]],
//    [[10, 11], [11, 12]],
//    [[20, 21], [21, 22]],
//    [[30, 31], [31, 32]]]

const indices3 = builder.constant(
  {dataType: 'uint32', shape: [2, 2]}, new Uint32Array([0, 1, 1, 2]));

const output3 = builder.gather(input, indices3, {axis: 1});

8.9.21. gatherElements

indices に従って、軸に沿って入力テンソルの値を収集します。 
partial interface MLGraphBuilder {
  MLOperand gatherElements(MLOperand input,
                           MLOperand indices,
                           optional MLGatherOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLGatherSupportLimits gatherElements;
};
引数:

戻り値: MLOperand。 ランクが input の ランクと等しい出力 N-D テンソル。

gatherElements() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32" 1 から N 1 から 5
indices "int32", "uint32", "int64" "int32" input と同じ 1 から 5
出力 input と同じ "float32", "float16", "int32" input と同じ 1 から 5

MLOpSupportLimits には gatherElements() 用の次のメンバーがあります。

gatherElements, 型は MLGatherSupportLimits

gatherElements() 演算子のサポート制限。

indices パラメーターは gatherElements() に対して、入力は実行時まで判明しないため、グラフのビルド時に許可範囲へクランプ できません。指定されたクランプ動作が基盤プラットフォームによって提供されない場合、実装はコンパイル済みグラフに clamp() を導入できます。同様に、基盤プラットフォームが負のインデックスをサポートしていない場合、実装は コンパイル済みグラフに演算を導入し、次元の末尾からの負のインデックスを正の インデックスへ変換できます。
gatherElements(input, indices, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input および indices のいずれかで行った結果が false の場合、TypeError をスローします。

  3. indices のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. input または indices のいずれかのランクが その許可されるランクでない場合、TypeError をスローします。

  5. axis を options.axis とします。

  6. axis が input のランク以上の場合、TypeError をスローします。

  7. indicesShapeExpected を input のshape のコピーとします。

  8. indicesShapeExpected[axis] を indices のshape[axis] に設定します。

  9. indices のshape が indicesShapeExpected と等しくない場合、 TypeError をスローします。

  10. グラフの接続を行います。

    1. output を、input が与えられたときに MLOperand をコピーした結果とします。

    2. operator を、input、indices、および options が与えられた "gatherElements" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input および indices に設定します。

    5. operator の出力を output に設定します。

  11. output を返します。

異なるスライス方式で gatherElements がどのように動作するかの例。 
// shape [4,3] の input:
//   [[ 0,  1,  2],
//    [10, 11, 12],
//    [20, 21, 22],
//    [30, 31, 32]]
// shape [2,3] の indices:
//   [[3, 1, 1],
//    [2, 0, 3]]
// axis = 0（デフォルト）
// shape [2,3] の output:
//   [[30, 11, 12],
//    [20,  1, 32]]

const input1 = builder.constant(
  {dataType: 'float32', shape: [4, 3]},
  new Float32Array([0, 1, 2, 10, 11, 12, 20, 21, 22, 30, 31, 32]));

const indices1 = builder.constant(
  {dataType: 'uint32', shape: [2, 3]}, new Uint32Array([3, 1, 1, 2, 0, 3]));

const output1 = builder.gatherElements(input1, indices1);

// shape [4,3] の input:
//   [[ 0,  1,  2],
//    [10, 11, 12],
//    [20, 21, 22],
//    [30, 31, 32]]
// shape [4,1] の indices:
//   [[2],
//    [1],
//    [0],
//    [2]],
// axis = 1
// shape [4,1] の output:
//   [[ 2],
//    [11],
//    [20],
//    [32]]

const indices2 = builder.constant(
  {dataType: 'uint32', shape: [4, 1]}, new Uint32Array([2, 1, 0, 2]));

const output2 = builder.gatherElements(input1, indices2, {axis: 1});

// shape [4,2,2] の input:
//   [[[  0,   1],
//     [ 10,  11]],
//    [[100, 101],
//     [110, 111]],
//    [[200, 201],
//     [210, 211]],
//    [[300, 301],
//     [310, 311]],]
// shape [1,2,2] の indices:
//   [[[0, 2],
//     [1, 3]]],
// axis = 0
// shape [1,2,2] の output:
//   [[[  0, 201],
//     [110, 311]]]

const inputData3 = new Float32Array(
  [0, 1, 10, 11, 100, 101, 110, 111, 200, 201, 210, 211, 300, 301, 310, 311]);

const input3 =
  builder.constant({dataType: 'float32', shape: [4, 2, 2]}, inputData3);

const indices3 = builder.constant(
  {dataType: 'uint32', shape: [1, 2, 2]}, new Uint32Array([0, 2, 1, 3]));

const output3 = builder.gatherElements(input3, indices3, {axis: 0});

8.9.22. gatherND

indices に従って入力テンソルのスライスを収集します。 
partial interface MLGraphBuilder {
  MLOperand gatherND(MLOperand input,
                     MLOperand indices,
                     optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLGatherSupportLimits gatherND;
};
引数:

戻り値: MLOperand。 ランクが input の ランク + indices の ランク - indices の shape[-1] - 1 に等しい出力 N-D テンソル。

gatherND() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32", "int8", "uint8" 1 から N 1 から 5
indices "int32", "uint32", "int64" "int32" 1 から N 1 から 5
出力 input と同じ "float32", "float16", "int32", "int8", "uint8" N 0 から 5

MLOpSupportLimits には gatherND() 用の次のメンバーがあります。

gatherND, 型は MLGatherSupportLimits

gatherND() 演算子のサポート制限。

indices パラメーターは gatherND() に対して、入力は実行時まで判明しないため、グラフのビルド時に許可範囲へクランプ できません。指定されたクランプ動作が基盤プラットフォームによって提供されない場合、実装はコンパイル済みグラフに clamp() を導入できます。同様に、基盤プラットフォームが負のインデックスをサポートしていない場合、実装は コンパイル済みグラフに演算を導入し、次元の末尾からの負のインデックスを正の インデックスへ変換できます。
gatherND(input, indices, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input および indices のいずれかで行った結果が false の場合、TypeError をスローします。

  3. indices のdataType が許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. input または indices のいずれかのランクが その許可されるランクでない場合、TypeError をスローします。

  5. inputShape を input のshape とし、inputRank を input のランクとします。

  6. indicesShape を indices のshape とし、indicesRank を indices のランクとします。

  7. input または indices のいずれかのランクが その許可されるランクでない場合、TypeError をスローします。

  8. indexableSize を indicesRank - 1 とします。

  9. coordinateSize を indicesShape[indexableSize] とします。

  10. coordinateSize が inputRank より大きい場合、TypeError をスローします。

  11. outputShape を空のリストとします。

  12. 0 から indexableSize までの範囲（上限を含まない）の各 index について反復します。

    1. indicesShape[index] を outputShape に追加します。

  13. coordinateSize から inputRank までの範囲 （上限を含まない）の各 index について反復します。

    1. inputShape[index] を outputShape に追加します。

  14. outputDesc を、input のdataType と outputShape が与えられたときに MLOperandDescriptor を 作成した結果とします。

  15. グラフの接続を行います。

    1. output を、outputDesc が与えられたときに MLOperand を 作成した結果とします。

    2. operator を、input、indices、および options が与えられた "gatherND" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input および indices に設定します。

    5. operator の出力を output に設定します。

  16. output を返します。

異なるスライス方式で gatherND がどのように動作するかの例。 
// shape [2,2] の input:
//   [[0, 1],
//    [2, 3]]
// shape [3,2] の indices:
//   [[0, 0],
//    [1, 1],
//    [1, 0]]
// shape [3] の output:
//   [0, 3, 2]

const input1 = builder.constant(
  {dataType: 'float32', shape: [2, 2]}, new Float32Array([0, 1, 2, 3]));

const indices1 = builder.constant(
  {dataType: 'uint32', shape: [3, 2]}, new Uint32Array([0, 0, 1, 1, 1, 0]));

const output1 = builder.gatherND(input1, indices1);

// shape [2,2] の input:
//   [[0, 1],
//    [2, 3]]
// shape [2,1] の indices:
//   [[1],
//    [0]]
// shape [2,2] の output:
//   [[2, 3]    <= input 座標 [1, *] からの行 [2, 3]
//    [0, 1]]   <= input 座標 [0, *] からの行 [0, 1]

const indices2 = builder.constant(
  {dataType: 'uint32', shape: [2, 1]}, new Uint32Array([1, 0]));

const output2 = builder.gatherND(input1, indices2);

// shape [2,2,2] の input:
//   [[[0, 1],
//     [2, 3]],
//    [[4, 5],
//     [6, 7]]]
// shape [2,2] の indices:
//   [[0, 1],
//    [1, 0]]
// shape [2,2] の output:
//   [[2, 3],   <= input 座標 [0, 1, *] からの行 [2, 3]
//    [4, 5]]   <= input 座標 [1, 0, *] からの行 [4, 5]

const input2 = builder.constant(
  {dataType: 'float32', shape: [2, 2, 2]},
  new Float32Array([0, 1, 2, 3, 4, 5, 6, 7]));

const indices3 = builder.constant(
  {dataType: 'uint32', shape: [2, 2]}, new Uint32Array([0, 1, 1, 0]));

const output3 = builder.gatherND(input2, indices3);

// shape [2,2,2] の input:
//   [[[0, 1],
//     [2, 3]],
//    [[4, 5],
//     [6, 7]]]
// shape [3,1] の indices:
//   [[1],
//    [0],
//    [1]]
// shape [3,2,2] の output:
//   [[[4, 5],   <= input 座標 [1, *, *] からのブロック [[4, 5], [6, 7]]
//     [6, 7]],
//    [[0, 1],   <= input 座標 [0, *, *] からのブロック [[0, 1], [2, 3]]
//     [2, 3]],
//    [[4, 5],   <= input 座標 [1, *, *] からのブロック [[4, 5], [6, 7]]
//     [6, 7]]]

const indices4 = builder.constant(
  {dataType: 'uint32', shape: [3, 1]}, new Uint32Array([1, 0, 1]));

const output4 = builder.gatherND(input2, indices4);

// shape [2,2,2] の input:
//   [[[0, 1],
//     [2, 3]],
//    [[4, 5],
//     [6, 7]]]
// shape [5,3] の indices:
//   [[0,0,1],
//    [0,1,0],
//    [1,0,0],
//    [1,1,0],
//    [1,1,1]]
// shape [5] の output:
//   [1,2,4,6,7]

const indices5 = builder.constant(
  {dataType: 'uint32', shape: [5, 3]},
  new Uint32Array([0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1]));

const output5 = builder.gatherND(input2, indices5);

8.9.23. gelu

入力テンソルのガウス 誤差線形ユニット関数（GELU）を計算します。計算は式 0.5 * x * (1 + erf(x / sqrt(2))) に従います。 
partial interface MLGraphBuilder {
  MLOperand gelu(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits gelu;
};
引数:

戻り値:

gelu() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" N 0 から 5
出力 input と同じ "float32", "float16" input と同じ 0 から 5

MLOpSupportLimits には gelu() 用の次のメンバーがあります。

gelu, 型は MLSingleInputSupportLimits

gelu() 演算子のサポート制限。

gelu(input, options) メソッドの 手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、TypeError をスローします。

  3. input のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. グラフの接続を行います。

    1. output を、input が与えられたときに MLOperand をコピーした結果とします。

    2. operator を、options が与えられた "gelu" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  5. output を返します。

この演算の動作は、ユーザーエージェントが通常はより効率的な実装を備えているものの、他の演算を使用して 次のように一般的にエミュレートできます。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function gelu(builder, input) {
  return builder.mul(
    builder.mul(input, builder.constant(input.dataType, 0.5)),
    builder.add(
      builder.constant(input.dataType, 1),
      builder.erf(builder.div(
        input, builder.sqrt(builder.constant(input.dataType, 2))))));
}

8.9.24. gemm

Basic Linear Algebra Subprograms の一般行列 乗算を計算します。計算は式 alpha * A * B + beta * C に従います。ここで A は shape [M, K] または [K, M] の 2-D テンソル、B は shape [K, N] または [N, K] の 2-D テンソルであり、 C は shape [M, N] へ単方向にブロードキャスト可能です。A および B は計算前にオプションで転置できます。 
dictionary MLGemmOptions : MLOperatorOptions {
  MLOperand c;
  double alpha = 1.0;
  double beta = 1.0;
  boolean aTranspose = false;
  boolean bTranspose = false;
};

partial interface MLGraphBuilder {
  MLOperand gemm(MLOperand a, MLOperand b, optional MLGemmOptions options = {});
};

dictionary MLGemmSupportLimits {
  MLTensorLimits a;
  MLTensorLimits b;
  MLTensorLimits c;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLGemmSupportLimits gemm;
};

MLGemmOptions には次のメンバーがあります。

c, 型は MLOperand

第 3 入力テンソル。スカラー、または shape [M, N] へ単方向にブロードキャスト可能な shape のいずれかです。指定されていない場合、c がスカラー 0.0 であるかのように計算されます。

alpha, 型は double、デフォルトは 1.0

第 1 入力の乗数。

beta, 型は double、デフォルトは 1.0

第 3 入力 c の乗数。

aTranspose, 型は boolean、デフォルトは false

出力を計算する前に第 1 入力を転置するかどうかを示します。

bTranspose, 型は boolean、デフォルトは false

出力を計算する前に第 2 入力を転置するかどうかを示します。

引数:

戻り値: MLOperand。 すべての入力から計算された積を含む shape [M, N] の出力 2-D テンソル。

gemm() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
a "float32", "float16" "float32", "float16" 2 2
b a と同じ "float32", "float16" 2 2
c a と同じ "float32", "float16" 0 から 2 0 から 2
出力 a と同じ "float32", "float16" 2 2

MLGemmSupportLimits には次のメンバーがあります。

a, 型は MLTensorLimits

a オペランドの MLTensorLimits。

b, 型は MLTensorLimits

b オペランドの MLTensorLimits。

c, 型は MLTensorLimits

c オペランドの MLTensorLimits。

output, 型は MLTensorLimits

出力オペランドの MLTensorLimits。

MLOpSupportLimits には gemm() 用の次のメンバーがあります。

gemm, 型は MLGemmSupportLimits

gemm() 演算子のサポート制限。

gemm(a, b, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と a および b のいずれかで行った結果が false の場合、 TypeError をスローします。

  3. a または b のいずれかのdataType が その許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. a または b のいずれかのランクが その許可されるランクでない場合、TypeError をスローします。

  5. options.alpha を options.alpha を a のdataType にキャストした 結果に設定します。

  6. options.beta を options.beta を a のdataType にキャストした 結果に設定します。

  7. shapeA を a のshape の複製とします。

  8. shapeB を b のshape の複製とします。

  9. options.aTranspose が true の場合、shapeA 内の項目の順序を反転します。

  10. options.bTranspose が true の場合、shapeB 内の項目の順序を反転します。

  11. shapeA[1] が shapeB[0] と等しくない場合、TypeError をスローします。

  12. options.c が存在する場合:

    1. それが shape « shapeA[0], shapeB[1] » へ単方向にブロードキャスト可能でない場合、TypeError をスローします。

    2. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

  13. desc を、a のdataType と « shapeA[0], shapeB[1] » が与えられたときに MLOperandDescriptor を 作成した結果とします。

  14. グラフの接続を行います。

    1. output を、this と desc が与えられたときに MLOperand を 作成した結果とします。

    2. operator を、options が与えられた "gemm" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を a および b に設定します。

    5. options.c が存在する場合、それを operator の入力に追加します。

    6. operator の出力を output に設定します。

  15. output を返します。

この演算の動作は、ユーザーエージェントが通常はより効率的な実装を備えているものの、他の演算を使用して 次のように一般的にエミュレートできます。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function gemm(builder, a, b, options) {
  if (options.aTranspose)
    a = builder.transpose(a);

  if (options.bTranspose)
    b = builder.transpose(b);

  let ab = builder.matmul(
    builder.mul(builder.constant(a.dataType, options.alpha), a), b);
  return (
    options.c ?
      builder.add(
        ab,
        builder.mul(builder.constant(a.dataType, options.beta), options.c)) :
      ab);
}

8.9.25. gru

Gated Recurrent Unit [GRU] リカレントネットワークは、update、reset、および new ゲートを使用して、ネットワークの時間シーケンス全体にわたって出力へ 引き継がれる出力状態を計算します。 
enum MLGruWeightLayout {
  "zrn",  // update-reset-new ゲートの順序
  "rzn"   // reset-update-new ゲートの順序
};

enum MLRecurrentNetworkActivation {
  "relu",
  "sigmoid",
  "tanh"
};

enum MLRecurrentNetworkDirection {
  "forward",
  "backward",
  "both"
};

dictionary MLGruOptions : MLOperatorOptions {
  MLOperand bias;
  MLOperand recurrentBias;
  MLOperand initialHiddenState;
  boolean resetAfter = true;
  boolean returnSequence = false;
  MLRecurrentNetworkDirection direction = "forward";
  MLGruWeightLayout layout = "zrn";
  sequence<MLRecurrentNetworkActivation> activations;
};

partial interface MLGraphBuilder {
  sequence<MLOperand> gru(MLOperand input,
                          MLOperand weight,
                          MLOperand recurrentWeight,
                          [EnforceRange] unsigned long steps,
                          [EnforceRange] unsigned long hiddenSize,
                          optional MLGruOptions options = {});
};

dictionary MLGruSupportLimits {
  MLTensorLimits input;
  MLTensorLimits weight;
  MLTensorLimits recurrentWeight;
  MLTensorLimits bias;
  MLTensorLimits recurrentBias;
  MLTensorLimits initialHiddenState;
  MLTensorLimits output0;
  MLTensorLimits output1;
};

partial dictionary MLOpSupportLimits {
  MLGruSupportLimits gru;
};

MLGruOptions には次のメンバーがあります。

bias, 型は MLOperand

shape [numDirections, 3 * hiddenSize] の 2-D 入力バイアステンソル。テンソル shape の第 2 次元におけるバイアス ベクトルの順序は layout に従って指定されます。

recurrentBias, 型は MLOperand

shape [numDirections, 3 * hiddenSize] の 2-D リカレントバイアステンソル。テンソル shape の第 2 次元における バイアスベクトルの順序は layout に従って指定されます。

initialHiddenState, 型は MLOperand

shape [numDirections, batchSize, hiddenSize] の 3-D 初期隠れ状態テンソル。 指定されていない場合、実装は 0 で埋められたテンソルを使用しなければなりません。

resetAfter, 型は boolean、デフォルトは true

行列乗算の後または前に reset ゲートを適用するかどうかを示します。

returnSequence, 型は boolean、デフォルトは false

最後の時間ステップの出力に加えて、各時間ステップのすべての出力を含むシーケンス全体も 返すかどうかを示します。

direction, 型は MLRecurrentNetworkDirection、デフォルトは "forward"

入力シーケンスの処理方向。"both" に設定した場合、weight および bias テンソル shape の第 1 次元のサイズは 2 でなければならず、入力は 両方向に処理されます。

layout, 型は MLGruWeightLayout、デフォルトは "zrn"

GRU の内部ゲート、具体的には update (z)、reset (r)、および new (n) ゲートの weight および bias ベクトルの順序であり、weight および bias テンソル shape の 第 2 次元によって示されます。

activations, 型は sequence<MLRecurrentNetworkActivation>

一対の活性化関数を指定します。第 1 関数は update および reset ゲートに使用され、第 2 関数は new ゲートに使用されます。指定されていない場合、デフォルトはそれぞれ "sigmoid" および "tanh" 関数です。

引数:

戻り値: sequence<MLOperand>。 第 1 要素は shape [numDirections, batchSize, hiddenSize] の 3-D テンソルであり、ネットワークの最後の時間ステップからのセル 出力です。さらに、returnSequence が true に設定されている場合、第 2 要素は shape [steps, numDirections, batchSize, hiddenSize] の 4-D 出力テンソルであり、時間 シーケンス内の各時間ステップからのすべてのセル出力を含みます。

gru() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" 3 3
weight 同じ input "float32", "float16" 3 3
recurrentWeight 同じ input "float32", "float16" 3 3
bias 同じ input "float32", "float16" 2 2
recurrentBias 同じ input "float32", "float16" 2 2
initialHiddenState 同じ input "float32", "float16" 3 3
outputs[0] 同じ input "float32", "float16" 3 3
outputs[1] if returnSequence が true の場合 同じ input "float32", "float16" 4 4

MLGruSupportLimits には次のメンバーがあります。

input, 型は MLTensorLimits

input オペランドの MLTensorLimits。

weight, 型は MLTensorLimits

weight オペランドの MLTensorLimits。

recurrentWeight, 型は MLTensorLimits

recurrentWeight オペランドの MLTensorLimits。

bias, 型は MLTensorLimits

bias オペランドの MLTensorLimits。

recurrentBias, 型は MLTensorLimits

recurrentBias オペランドの MLTensorLimits。

initialHiddenState, 型は MLTensorLimits

initialHiddenState オペランドの MLTensorLimits。

output0, 型は MLTensorLimits

すべての出力オペランド[0]の MLTensorLimits。

output1, 型は MLTensorLimits

すべての出力オペランド[1]の MLTensorLimits。

MLOpSupportLimits には gru() 用の次のメンバーがあります。

gru, 型は MLGruSupportLimits

gru() 演算子のサポート制限。

gru(input, weight, recurrentWeight, steps, hiddenSize, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input、weight、 recurrentWeight、options.bias （それが存在する場合）、options.recurrentBias （それが存在する場合）、および options.initialHiddenState （それが存在する場合）のいずれかで行った結果が false の場合、TypeError をスローします。

  3. input、weight または recurrentWeight のいずれかのdataType が、その許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. input、weight または recurrentWeight のいずれかのランクが、その許可されるランクでない 場合、TypeError をスローします。

  5. input のshape[0] が steps と等しくない場合、TypeError をスローします。

  6. batchSize を input のshape[1] とします。

  7. inputSize を input のshape[2] とします。

  8. numDirections を options.direction が "both" の場合は 2、それ以外の場合は 1 とします。

  9. weight のshape が « numDirections, 3 * hiddenSize, inputSize » と等しくない場合、TypeError をスローします。

  10. recurrentWeight のshape が « numDirections, 3 * hiddenSize, hiddenSize » と等しくない場合、TypeError をスローします。

  11. hiddenSize * 6 が有効な次元でない場合、TypeError をスローします。

    なぜ hiddenSize * 6 なのか？ 一部の基盤プラットフォームは、bias と recurrentBias を連結した単一の bias テンソルを使用します。 したがって、3 * hiddenSize + 3 * hiddenSize も有効な 次元である必要があります。

  12. options.bias が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

    2. そのshape が « numDirections, 3 * hiddenSize » と等しくない場合、TypeError をスローします。

  13. options.recurrentBias が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

    2. そのshape が « numDirections, 3 * hiddenSize » と等しくない場合、TypeError をスローします。

  14. options.initialHiddenState が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

    2. そのshape が « numDirections, batchSize, hiddenSize » と等しくない場合、TypeError をスローします。

  15. options.activations が存在する場合:

    1. そのサイズが 2 でない場合、TypeError をスローします。

    2. activations を options.activations の複製とします。

  16. それ以外の場合:

    1. activations を « "sigmoid", "tanh" » とします。

  17. 出力 shape を計算します。

    1. desc0 を、input のdataType と « numDirections, batchSize, hiddenSize » が与えられたときに MLOperandDescriptor を作成した結果とします。

    2. options.returnSequence が true の場合:

      1. desc1 を、input のdataType と « steps, numDirections, batchSize, hiddenSize » が与えられたときに MLOperandDescriptor を 作成した結果とします。

  18. グラフの接続を行います。

    1. operator を、weight、recurrentWeight、steps、hiddenSize および options が与えられた "gru" 演算用の演算子とします。

    2. output0 を、this と desc0 が与えられたときに MLOperand を 作成した結果とします。

    3. options.returnSequence が true の場合:

      1. output1 を、this と desc1 が与えられたときに MLOperand を 作成した結果とします。

      2. output をリスト « output0, output1 » とします。

      3. output0.[[operator]] および output1.[[operator]] を operator に設定します。

    4. それ以外の場合:

      1. output をリスト « output0 » とします。

      2. output0.[[operator]] を operator に設定します。

    5. operator の入力を input、weight、および recurrentWeight に設定します。

    6. options.bias が存在する場合、それを operator の入力に追加します。

    7. options.recurrentBias が存在する場合、それを operator の入力に追加します。

    8. options.initialHiddenState が存在する場合、それを operator の入力に追加します。

    9. operator の活性化関数を activations の複製に設定します。

    10. operator の出力を output に設定します。

  19. output を返します。

squeeze() ヘルパーを使用すると、この演算の動作は ユーザーエージェントが通常はより効率的な実装を備えているものの、他の演算の使用から次のように 一般的にエミュレートできます。基盤となるプラットフォームが演算を直接 サポートしていない場合、この分解を実装の指針となるテンプレートとして使用できます。 
function gru(
  builder, input, weight, recurrentWeight, steps, hiddenSize, options) {
  const batchSize = input.shape[1];
  const inputSize = input.shape[2];
  const direction = options.direction || 'forward';
  const numDirections = (direction == 'both' ? 2 : 1);
  let hiddenState = options.initialHiddenState;

  if (!hiddenState) {
    const desc = {
      dataType: 'float32',
      shape: [numDirections, batchSize, hiddenSize]
    };
    const totalSize = numDirections * batchSize * hiddenSize;
    hiddenState = builder.constant(desc, new Float32Array(totalSize).fill(0));
  }

  let currentWeight = [];
  let currentRecurrentWeight = [];
  let currentBias = [];
  let currentRecurrentBias = [];
  let forwardSequence = null;
  let backwardSequence = null;
  let outputHidden = null;

  for (let dir = 0; dir < numDirections; ++dir) {
    currentWeight.push(squeeze(
      builder,
      builder.slice(weight, [dir, 0, 0], [1, 3 * hiddenSize, inputSize])));
    currentRecurrentWeight.push(squeeze(
      builder,
      builder.slice(
        recurrentWeight, [dir, 0, 0], [1, 3 * hiddenSize, hiddenSize])));
    currentBias.push(
      options.bias ?
        (squeeze(
          builder,
          builder.slice(options.bias, [dir, 0], [1, 3 * hiddenSize]))) :
        null);
    currentRecurrentBias.push(
      options.recurrentBias ?
        (squeeze(
          builder,
          builder.slice(
            options.recurrentBias, [dir, 0], [1, 3 * hiddenSize]))) :
        null);
    let currentHidden = squeeze(
      builder,
      builder.slice(hiddenState, [dir, 0, 0], [1, batchSize, hiddenSize]), [0]);

    for (let step = 0; step < steps; ++step) {
      const slice =
        (dir == 1 || direction == 'backward' ? steps - step - 1 : step);
      const currentInput = squeeze(
        builder,
        builder.slice(input, [slice, 0, 0], [1, batchSize, inputSize]), [0]);

      currentHidden = builder.gruCell(
        currentInput,
        currentWeight[dir],
        currentRecurrentWeight[dir],
        currentHidden,
        hiddenSize,
        {
          bias: currentBias[dir],
          recurrentBias: currentRecurrentBias[dir],
          resetAfter: options.resetAfter,
          layout: options.layout,
          activations: options.activations
        });

      if (options.returnSequence) {
        // 2D([batchSize, hiddenSize]) の currentHidden を拡張する
        // 4D([steps, numDirections, batchSize, hiddenSize]) へ
        const expandedHiddenAs4D =
          builder.reshape(currentHidden, [1, 1, batchSize, hiddenSize]);

        if (direction == 'forward' || (dir == 0 && direction == 'both')) {
          forwardSequence = forwardSequence ?
            builder.concat([forwardSequence, expandedHiddenAs4D], 0) :
            expandedHiddenAs4D;
        } else if (
          direction == 'backward' || (dir == 1 && direction == 'both')) {
          backwardSequence = backwardSequence ?
            builder.concat([expandedHiddenAs4D, backwardSequence], 0) :
            expandedHiddenAs4D;
        }
      }
    }

    // 2D([batchSize, hiddenSize]) の currentHidden を拡張する
    // 3D([numDirections, batchSize, hiddenSize]) へ
    const expandedHiddenAs3D =
      builder.reshape(currentHidden, [1, batchSize, hiddenSize]);
    outputHidden = outputHidden ?
      builder.concat([outputHidden, expandedHiddenAs3D], 0) :
      expandedHiddenAs3D;
  }

  if (options.returnSequence) {
    let outputSequence = null;

    if (direction == 'forward') {
      outputSequence = forwardSequence;
    } else if (direction == 'backward') {
      outputSequence = backwardSequence;
    } else if (direction == 'both') {
      // axis 1（numDirections 次元）に沿って連結する
      outputSequence = builder.concat([forwardSequence, backwardSequence], 1);
    }

    return [outputHidden, outputSequence];
  } else {
    return [outputHidden];
  }
}

8.9.26. gruCell

Gated Recurrent Unit [GRU] リカレントネットワークの単一時間ステップであり、update ゲートと reset ゲートを使用して、リカレントネットワークの時間 シーケンス全体にわたって出力へ引き継がれる隠れ状態を計算します。 
dictionary MLGruCellOptions : MLOperatorOptions {
  MLOperand bias;
  MLOperand recurrentBias;
  boolean resetAfter = true;
  MLGruWeightLayout layout = "zrn";
  sequence<MLRecurrentNetworkActivation> activations;
};

partial interface MLGraphBuilder {
  MLOperand gruCell(MLOperand input,
                    MLOperand weight,
                    MLOperand recurrentWeight,
                    MLOperand hiddenState,
                    [EnforceRange] unsigned long hiddenSize,
                    optional MLGruCellOptions options = {});
};

dictionary MLGruCellSupportLimits {
  MLTensorLimits input;
  MLTensorLimits weight;
  MLTensorLimits recurrentWeight;
  MLTensorLimits hiddenState;
  MLTensorLimits bias;
  MLTensorLimits recurrentBias;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLGruCellSupportLimits gruCell;
};

MLGruCellOptions には次のメンバーがあります。

bias, 型は MLOperand

shape [3 * hiddenSize] の 1-D 入力 bias テンソル。テンソル shape の 第 2 次元における bias ベクトルの順序は layout に従って指定されます。

recurrentBias, 型は MLOperand

shape [3 * hiddenSize] の 1-D リカレント bias テンソル。テンソル shape の 第 2 次元における bias ベクトルの順序は layout に従って指定されます。

resetAfter, 型は boolean、デフォルトは true

行列乗算の後または前に reset ゲートを適用するかどうかを示します。

layout, 型は MLGruWeightLayout、デフォルトは "zrn"

GRU の内部ゲート、具体的には update (z)、reset (r)、および new (n) ゲートの weight および bias ベクトルの順序であり、weight および bias テンソル shape の 第 2 次元によって示されます。

activations, 型は sequence<MLRecurrentNetworkActivation>

一対の活性化関数を指定します。第 1 関数は update および reset ゲートに使用され、第 2 関数は new ゲートに使用されます。指定されていない場合、デフォルトはそれぞれ "sigmoid" および "tanh" 関数です。

引数:

戻り値: MLOperand。 shape [batchSize, hiddenSize] の 2-D テンソルであり、リカレントネットワークの単一時間 ステップのセル出力隠れ状態です。

gruCell() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" 2 2
weight 同じ input "float32", "float16" 2 2
recurrentWeight 同じ input "float32", "float16" 2 2
hiddenState 同じ input "float32", "float16" 2 2
bias 同じ input "float32", "float16" 1 1
recurrentBias 同じ input "float32", "float16" 1 1
output 同じ input "float32", "float16" 2 2

MLGruCellSupportLimits には次のメンバーがあります。

input, 型は MLTensorLimits

input オペランドの MLTensorLimits。

weight, 型は MLTensorLimits

weight オペランドの MLTensorLimits。

recurrentWeight, 型は MLTensorLimits

recurrentWeight オペランドの MLTensorLimits。

hiddenState, 型は MLTensorLimits

hiddenState オペランドの MLTensorLimits。

bias, 型は MLTensorLimits

bias オペランドの MLTensorLimits。

recurrentBias, 型は MLTensorLimits

recurrentBias オペランドの MLTensorLimits。

output, 型は MLTensorLimits

output オペランドの MLTensorLimits。

MLOpSupportLimits には gruCell() 用の次のメンバーがあります。

gruCell, 型は MLGruCellSupportLimits

gruCell() 演算子のサポート制限。

gruCell(input, weight, recurrentWeight, hiddenState, hiddenSize, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input、weight、 recurrentWeight、hiddenState、options.bias （それが存在する場合）、および options.recurrentBias （それが存在する場合）のいずれかで行った結果が false の場合、TypeError をスローします。

  3. input、 weight、recurrentWeight、または hiddenState のいずれかのdataType がその許可される データ型のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. input、weight、recurrentWeight または hiddenState のいずれかのランクが、その許可される ランクでない場合（この表に従って）、TypeError をスローします。

  5. batchSize を input のshape[0] とします。

  6. inputSize を input のshape[1] とします。

  7. weight のshape が « 3 * hiddenSize, inputSize » と等しくない場合、 TypeError をスローします。

  8. recurrentWeight のshape が « 3 * hiddenSize, hiddenSize » と等しくない場合、 TypeError をスローします。

  9. hiddenState のshape が « batchSize, hiddenSize » と等しくない場合、 TypeError をスローします。

  10. hiddenSize * 6 が有効な次元でない場合、TypeError をスローします。

    なぜ hiddenSize * 6 なのか？ 一部の基盤プラットフォームは、bias と recurrentBias を連結した単一の bias テンソルを使用します。 したがって、3 * hiddenSize + 3 * hiddenSize も有効な 次元である必要があります。

  11. options.bias が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

    2. そのshape が « 3 * hiddenSize » と等しくない場合、TypeError をスローします。

  12. options.recurrentBias が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

    2. そのshape が « 3 * hiddenSize » と等しくない場合、TypeError をスローします。

  13. options.activations が存在する場合:

    1. そのサイズが 2 でない場合、TypeError をスローします。

    2. activations を options.activations の複製とします。

  14. それ以外の場合:

    1. activations を « "sigmoid", "tanh" » とします。

  15. desc を、input のdataType と « batchSize, hiddenSize » が与えられたときに MLOperandDescriptor を 作成した結果とします。

  16. グラフの接続を行います。

    1. output を、this と desc が与えられたときに MLOperand を 作成した結果とします。

    2. operator を、weight、recurrentWeight、hiddenState、 hiddenSize および options が与えられた "gruCell" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input、weight、 recurrentWeight、および hiddenState に設定します。

    5. options.bias が存在する場合、それを operator の入力に追加します。

    6. options.recurrentBias が存在する場合、それを operator の入力に追加します。

    7. operator の活性化関数を activations の複製に設定します。

    8. operator の出力を output に設定します。

  17. output を返します。

weight layout がデフォルトの "zrn" layout であり、update/reset ゲートと new ゲートの活性化関数が それぞれ sigmoid() および tanh() である場合、この演算の動作は、ユーザーエージェントが通常はより効率的な実装を備えているものの、 他の演算の使用から次のように一般的にエミュレートできます。基盤となるプラットフォームが 演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function gruCell(
  builder, input, weight, recurrentWeight, hiddenState, hiddenSize, options) {
  const one = builder.constant(input.dataType, 1);
  const zero = builder.constant(input.dataType, 0);

  const inputSize = input.shape[1];

  // update ゲート (z)
  let z = builder.sigmoid(builder.add(
    builder.add(
      (options.bias ? builder.slice(options.bias, [0], [hiddenSize]) : zero),
      (options.recurrentBias ?
         builder.slice(options.recurrentBias, [0], [hiddenSize]) :
         zero)),
    builder.add(
      builder.matmul(
        input,
        builder.transpose(
          builder.slice(weight, [0, 0], [hiddenSize, inputSize]))),
      builder.matmul(
        hiddenState,
        builder.transpose(
          builder.slice(recurrentWeight, [0, 0], [hiddenSize, hiddenSize]))))));

  // reset ゲート (r)
  let r = builder.sigmoid(builder.add(
    builder.add(
      (options.bias ? builder.slice(options.bias, [hiddenSize], [hiddenSize]) :
                      zero),
      (options.recurrentBias ?
         builder.slice(options.recurrentBias, [hiddenSize], [hiddenSize]) :
         zero)),
    builder.add(
      builder.matmul(
        input,
        builder.transpose(
          builder.slice(weight, [hiddenSize, 0], [hiddenSize, inputSize]))),
      builder.matmul(
        hiddenState,
        builder.transpose(builder.slice(
          recurrentWeight, [hiddenSize, 0], [hiddenSize, hiddenSize]))))));

  // new ゲート (n)
  let n;
  if (options.resetAfter) {
    n = builder.tanh(builder.add(
      (options.bias ?
         builder.slice(options.bias, [2 * hiddenSize], [hiddenSize]) :
         zero),
      builder.add(
        builder.matmul(
          input,
          builder.transpose(builder.slice(
            weight, [2 * hiddenSize, 0], [hiddenSize, inputSize]))),
        builder.mul(
          r,
          builder.add(
            (options.recurrentBias ?
               builder.slice(
                 options.recurrentBias, [2 * hiddenSize], [hiddenSize]) :
               zero),
            builder.matmul(
              hiddenState,
              builder.transpose(builder.slice(
                recurrentWeight,
                [2 * hiddenSize, 0],
                [hiddenSize, hiddenSize]))))))));
  } else {
    n = builder.tanh(builder.add(
      builder.add(
        (options.bias ?
           builder.slice(options.bias, [2 * hiddenSize], [hiddenSize]) :
           zero),
        (options.recurrentBias ?
           builder.slice(
             options.recurrentBias, [2 * hiddenSize], [hiddenSize]) :
           zero)),
      builder.add(
        builder.matmul(
          input,
          builder.transpose(builder.slice(
            weight, [2 * hiddenSize, 0], [hiddenSize, inputSize]))),
        builder.matmul(
          builder.mul(r, hiddenState),
          builder.transpose(builder.slice(
            recurrentWeight,
            [2 * hiddenSize, 0],
            [hiddenSize, hiddenSize]))))));
  }

  // 新しい隠れ状態を計算する
  return builder.add(
    builder.mul(z, hiddenState), builder.mul(n, builder.sub(one, z)));
}

8.9.27. hardSigmoid

より高速な計算のために sigmoid 関数の代わりに使用される、非滑らかなhard sigmoid 関数を 入力テンソルに対して計算します。 
dictionary MLHardSigmoidOptions : MLOperatorOptions {
  double alpha = 0.2;
  double beta = 0.5;
};

partial interface MLGraphBuilder {
  MLOperand hardSigmoid(MLOperand input, optional MLHardSigmoidOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits hardSigmoid;
};

MLHardSigmoidOptions には次のメンバーがあります。

alpha, 型は double、デフォルトは 0.2

スカラー乗数。

beta, 型は double、デフォルトは 0.5

スカラー加算値。

引数:

戻り値:

hardSigmoid() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" N 0 から 5
output 同じ input "float32", "float16" 同じ input 0 から 5

MLOpSupportLimits には hardSigmoid() 用の次のメンバーがあります。

hardSigmoid, 型は MLSingleInputSupportLimits

hardSigmoid() 演算子のサポート制限。

hardSigmoid(input, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、TypeError をスローします。

  3. input のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. options.alpha を options.alpha を input のdataType にキャストした 結果に設定します。

  5. options.beta を options.beta を input のdataType にキャストした 結果に設定します。

  6. グラフの接続を行います。

    1. output を、input が与えられたときに MLOperand をコピーした結果とします。

    2. operator を、options が与えられた "hardSigmoid" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  7. output を返します。

この演算の動作は、ユーザーエージェントが通常はより効率的な実装を備えているものの、他の演算を使用して 次のように一般的にエミュレートできます。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function hardSigmoid(builder, input, options) {
  return builder.max(
    builder.min(
      builder.add(
        builder.mul(builder.constant(input.dataType, options.alpha), input),
        builder.constant(input.dataType, options.beta)),
      builder.constant(input.dataType, 1)),
    builder.constant(input.dataType, 0));
}

8.9.28. hardSwish

[MobileNetV3] で導入された非線形関数 y = x * max(0, min(6, (x + 3))) / 6 を 入力テンソルに対して要素単位で計算します。 
partial interface MLGraphBuilder {
  MLOperand hardSwish(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits hardSwish;
};
引数:

戻り値:

hardSwish() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" N 0 から 5
output 同じ input "float32", "float16" 同じ input 0 から 5

MLOpSupportLimits には hardSwish() 用の次のメンバーがあります。

hardSwish, 型は MLSingleInputSupportLimits

hardSwish() 演算子のサポート制限。

hardSwish(input, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、TypeError をスローします。

  3. input のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. グラフの接続を行います。

    1. output を、input が与えられたときに MLOperand をコピーした結果とします。

    2. operator を、options が与えられた "hardSwish" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  5. output を返します。

この演算の動作は、ユーザーエージェントが通常はより効率的な実装を備えているものの、他の演算を使用して 次のように一般的にエミュレートできます。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function hardSwish(builder, input, options) {
  return builder.div(
    builder.mul(
      input,
      builder.max(
        builder.constant(input.dataType, 0),
        builder.min(
          builder.constant(input.dataType, 6),
          builder.add(input, builder.constant(input.dataType, 3))))),
    builder.constant(input.dataType, 6));
}

8.9.29. instanceNormalization

[Instance-Normalization] を使用して入力を正規化します。 batchNormalization() ではモデルの学習中、正規化に使用される平均値と分散値が batch 次元内のすべてのサンプルにわたって計算されるのに対し、instance normalization で使用される平均値と分散値は batch 内の各個別サンプルの各入力特徴について動的に計算されます。 
dictionary MLInstanceNormalizationOptions : MLOperatorOptions {
  MLOperand scale;
  MLOperand bias;
  double epsilon = 1e-5;
  MLInputOperandLayout layout = "nchw";
};

partial interface MLGraphBuilder {
  MLOperand instanceNormalization(
    MLOperand input,
    optional MLInstanceNormalizationOptions options = {});
};

dictionary MLNormalizationSupportLimits {
  MLTensorLimits input;
  MLTensorLimits scale;
  MLTensorLimits bias;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLNormalizationSupportLimits instanceNormalization;
};

MLInstanceNormalizationOptions には次のメンバーがあります。

scale, 型は MLOperand

スケーリング値の 1-D テンソルで、そのサイズは チャネル数、すなわち入力の feature 次元のサイズと等しくなります。たとえば、 input テンソルが "nchw" layout の場合、サイズは input の shape[1] と等しくなります。

bias, 型は MLOperand

bias 値の 1-D テンソルで、そのサイズは 入力の feature 次元のサイズと等しくなります。たとえば、input テンソルが "nchw" layout の場合、サイズは input の shape[1] と等しくなります。

epsilon, 型は double、デフォルトは 1e-5

0 除算による計算エラーを防ぐための小さな値。

layout, 型は MLInputOperandLayout、デフォルトは "nchw"

入力の layout 形式。

引数:

戻り値: MLOperand。 input と同じ shape の instance-normalized 4-D テンソル。

instanceNormalization() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" 4 4
scale 同じ input "float32", "float16" 1 1
bias 同じ input "float32", "float16" 1 1
output 同じ input "float32", "float16" 4 4

MLNormalizationSupportLimits には次のメンバーがあります。

input, 型は MLTensorLimits

input オペランドの MLTensorLimits。

scale, 型は MLTensorLimits

scale オペランドの MLTensorLimits。

bias, 型は MLTensorLimits

bias オペランドの MLTensorLimits。

output, 型は MLTensorLimits

output オペランドの MLTensorLimits。

MLOpSupportLimits には instanceNormalization() 用の次のメンバーがあります。

instanceNormalization, 型は MLNormalizationSupportLimits

instanceNormalization() 演算子のサポート制限。

instanceNormalization(input, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input、options.scale （それが存在する場合）、および options.bias （それが存在する場合）のいずれかで行った結果が false の場合、TypeError をスローします。

  3. input のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. input のランクがその許可されるランクでない場合、TypeError をスローします。

  5. options.epsilon を options.epsilon を input のdataType にキャストした 結果に設定します。

  6. axis を options.layout が "nchw" の場合は 1、それ以外の場合は 3 とします。

  7. options.scale が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

    2. そのshape が « input のshape[axis] » と等しくない場合、TypeError をスローします。

  8. options.bias が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

    2. そのshape が « input のshape[axis] » と等しくない場合、TypeError をスローします。

  9. グラフの接続を行います。

    1. output を、input が与えられたときに MLOperand をコピーした結果とします。

    2. operator を、options が与えられた "instanceNormalization" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. options.scale が存在する場合、それを operator の入力に追加します。

    6. options.bias が存在する場合、それを operator の入力に追加します。

    7. operator の出力を output に設定します。

  10. output を返します。

入力テンソルが "nchw" layout の 4-D である場合、この演算の動作は、ユーザー エージェントが通常はより効率的な実装を備えているものの、他の演算の使用から次のように一般的にエミュレートできます。基盤となるプラットフォームが 演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function instanceNormalization(builder, input, options) {
  // 平均値と分散値のリダクションは空間
  // 次元、たとえば入力テンソルの axis 2 と 3 にわたって行われます。
  const reduceOptions = {axes: [2, 3], keepDimensions: true};
  const mean = builder.reduceMean(input, reduceOptions);
  const variance = builder.reduceMean(
    builder.pow(builder.sub(input, mean), builder.constant(input.dataType, 2)),
    reduceOptions);

  // scale と bias の値は入力 feature ごとに適用されます
  // たとえば入力テンソルの axis 1。
  const shape = [1, input.shape[1], 1, 1];
  return builder.add(
    builder.mul(
      builder.reshape(options.scale, shape),
      builder.div(
        builder.sub(input, mean),
        builder.sqrt(builder.add(variance, options.epsilon)))),
    builder.reshape(options.bias, shape));
}

8.9.30. layerNormalization

[Layer-Normalization] を使用して入力を正規化します。batchNormalization() ではモデルの 学習中に平均値と分散値が batch 次元内のすべてのサンプルにわたって計算され、instanceNormalization() では平均値と分散値が batch 内の各個別サンプルの各入力 feature について動的に計算されるのに対し、layer normalization の平均値と分散値は batch 内の各個別サンプルのすべての入力 feature にわたって動的に計算されます。 
dictionary MLLayerNormalizationOptions : MLOperatorOptions {
  MLOperand scale;
  MLOperand bias;
  sequence<[EnforceRange] unsigned long> axes;
  double epsilon = 1e-5;
};

partial interface MLGraphBuilder {
  MLOperand layerNormalization(MLOperand input,
                               optional MLLayerNormalizationOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLNormalizationSupportLimits layerNormalization;
};

MLLayerNormalizationOptions には次のメンバーがあります。

scale, 型は MLOperand

スケーリング値の N-D テンソルで、その shape は axes メンバーによって決定され、axes 内の各値はスケーリング値を持つ入力テンソルの次元を示します。たとえば、axes の値が [1,2,3] の場合、このテンソルの shape は入力 次元 1、2、3 の対応するサイズのリストです。このメンバーが存在しない場合、スケーリング値は 1 とみなされます。

bias, 型は MLOperand

bias 値の N-D テンソルで、その shape は axes メンバーによって決定され、axes 内の各値は bias 値を持つ入力テンソルの次元を示します。たとえば、axes の値が [1,2,3] の場合、このテンソルの shape は入力 次元 1、2、3 の対応するサイズのリストです。このメンバーが存在しない場合、bias 値は 0 とみなされます。

axes, 型は sequence<[EnforceRange] unsigned long>

リダクションする入力次元のインデックス。このメンバーが存在しない場合、 第 1 次元を除くすべての次元が指定されたものとして扱われます（たとえば 4-D 入力テンソルでは、axes = [1,2,3]）。つまり、平均値と分散値のリダクションは、独立した各 batch の すべての入力 feature にわたって計算されます。空の場合、どの次元もリダクションされません。

epsilon, 型は double、デフォルトは 1e-5

0 除算による計算エラーを防ぐための小さな値。

引数:

戻り値: MLOperand。 input と同じ shape の layer-normalized N-D テンソル。

layerNormalization() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" N 0 から 5
scale 同じ input "float32", "float16" N 0 から 5
bias 同じ input "float32", "float16" N 0 から 5
output 同じ input "float32", "float16" 同じ input 0 から 5

MLOpSupportLimits には layerNormalization() 用の次のメンバーがあります。

layerNormalization, 型は MLNormalizationSupportLimits

layerNormalization() 演算子のサポート制限。

layerNormalization(input, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input、options.scale （それが存在する場合）、および options.bias （それが存在する場合）のいずれかで行った結果が false の場合、TypeError をスローします。

  3. input のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. options.axes が存在しない場合、options.axes を新しいリストに設定します。input のランクが 1 より大きい場合は 1 から input のランクまでの範囲（上限を含まない）、それ以外の場合は空のリストとします。

  5. それ以外の場合、options.axes に重複値が含まれるか、またはその項目のいずれかが 0 から input のランクまでの範囲（上限を含まない）にない場合、TypeError をスローします。

  6. options.epsilon を options.epsilon を input のdataType にキャストした 結果に設定します。

  7. options.scale が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

    2. そのランクが options.axes の サイズと等しくない場合、TypeError をスローします。

  8. options.bias が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

    2. そのランクが options.axes の サイズと等しくない場合、TypeError をスローします。

  9. 0 から options.axes の サイズまでの範囲（上限を含まない）の各 index について反復します。

    1. axis を options.axes[index] とします。

    2. axis が input のランク以上の場合、TypeError をスローします。

    3. size を input のshape[axis] とします。

    4. options.scale が存在する場合:

      1. そのshape[index] が size と等しくない場合、TypeError をスローします。

    5. options.bias が存在する場合:

      1. そのshape[index] が size と等しくない場合、TypeError をスローします。

  10. グラフの接続を行います。

    1. output を、input が与えられたときに MLOperand をコピーした結果とします。

    2. operator を、options が与えられた "layerNormalization" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. options.scale が存在する場合、それを operator の入力に追加します。

    6. options.bias が存在する場合、それを operator の入力に追加します。

    7. operator の出力を output に設定します。

  11. output を返します。

axes パラメーターが [1,2,3] に設定されている場合、この演算の動作は ユーザーエージェントが通常はより効率的な 実装を備えているものの、他の演算の使用から次のように一般的にエミュレートできます。基盤となるプラットフォームが演算を直接サポートしていない場合、この 分解を実装の指針となるテンプレートとして使用できます。 
function layerNormalization(builder, input, options) {
  // 平均値と分散値のリダクションは、入力のすべての feature
  // （すなわち、すべてのチャネル）にわたる空間次元で行われます
  // テンソル。
  const reduceOptions = {axes: [1, 2, 3], keepDimensions: true};
  const mean = builder.reduceMean(input, reduceOptions);
  const variance = builder.reduceMean(
    builder.pow(builder.sub(input, mean), builder.constant(input.dataType, 2)),
    reduceOptions);

  // scale および bias テンソルは、axes パラメーターの値で指定された
  // 入力の shape（すなわち [1,2,3]）です。
  return builder.add(
    builder.mul(
      options.scale,
      builder.div(
        builder.sub(input, mean),
        builder.sqrt(builder.add(variance, options.epsilon)))),
    options.bias);
}

8.9.31. leakyRelu

入力テンソルに対して rectified linear 関数の leaky 版を要素単位で計算します。計算は式 max(0, x) + alpha * min(0, x) に従います。 
dictionary MLLeakyReluOptions : MLOperatorOptions {
  double alpha = 0.01;
};

partial interface MLGraphBuilder {
  MLOperand leakyRelu(MLOperand input, optional MLLeakyReluOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits leakyRelu;
};

MLLeakyReluOptions には次のメンバーがあります。

alpha, 型は double、デフォルトは 0.01

スカラー乗数。

引数:

戻り値:

leakyRelu() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" N 0 から 5
output 同じ input "float32", "float16" 同じ input 0 から 5

MLOpSupportLimits には leakyRelu() 用の次のメンバーがあります。

leakyRelu, 型は MLSingleInputSupportLimits

leakyRelu() 演算子のサポート制限。

leakyRelu(input, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、TypeError をスローします。

  3. input のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. options.alpha を options.alpha を input のdataType にキャストした 結果に設定します。

  5. グラフの接続を行います。

    1. output を、input が与えられたときに MLOperand をコピーした結果とします。

    2. operator を、options が与えられた "leakyRelu" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  6. output を返します。

この演算の動作は、ユーザーエージェントが通常はより効率的な実装を備えているものの、他の演算を使用して 次のように一般的にエミュレートできます。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function leakyRelu(builder, input, options) {
  return builder.add(
    builder.max(builder.constant(input.dataType, 0), input),
    builder.mul(
      builder.constant(input.dataType, options.alpha),
      builder.min(builder.constant(input.dataType, 0), input)));
}

8.9.32. linear

入力テンソルに対して線形関数 y = alpha * x + beta を計算します。 
dictionary MLLinearOptions : MLOperatorOptions {
  double alpha = 1;
  double beta = 0;
};

partial interface MLGraphBuilder {
  MLOperand linear(MLOperand input, optional MLLinearOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits linear;
};

MLLinearOptions には次のメンバーがあります。

alpha, 型は double、デフォルトは 1

スカラー乗数。

beta, 型は double、デフォルトは 0

スカラー加算値。

引数:

戻り値:

linear() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" N 0 から 5
output 同じ input "float32", "float16" 同じ input 0 から 5

MLOpSupportLimits には linear() 用の次のメンバーがあります。

linear, 型は MLSingleInputSupportLimits

linear() 演算子のサポート制限。

linear(input, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、TypeError をスローします。

  3. input のdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  4. options.alpha を options.alpha を input のdataType にキャストした 結果に設定します。

  5. options.beta を options.beta を input のdataType にキャストした 結果に設定します。

  6. グラフの接続を行います。

    1. output を、input が与えられたときに MLOperand をコピーした結果とします。

    2. operator を、options が与えられた "linear" 演算用の演算子とします。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  7. output を返します。

この演算の動作は、ユーザーエージェントが通常はより効率的な実装を備えているものの、他の演算を使用して 次のように一般的にエミュレートできます。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function linear(builder, input, options) {
  return builder.add(
    builder.mul(input, builder.constant(input.dataType, options.alpha)),
    builder.constant(input.dataType, options.beta));
}

8.9.33. lstm

Long Short-Term Memory [LSTM] リカレントネットワークは、input、output、forget、および cell ゲートを使用して、ネットワークの 時間シーケンス全体にわたって出力へ引き継がれる出力状態を計算します。 
enum MLLstmWeightLayout {
  "iofg", // input-output-forget-cell ゲートの順序
  "ifgo"  // input-forget-cell-output ゲートの順序
};

dictionary MLLstmOptions : MLOperatorOptions {
  MLOperand bias;
  MLOperand recurrentBias;
  MLOperand peepholeWeight;
  MLOperand initialHiddenState;
  MLOperand initialCellState;
  boolean returnSequence = false;
  MLRecurrentNetworkDirection direction = "forward";
  MLLstmWeightLayout layout = "iofg";
  sequence<MLRecurrentNetworkActivation> activations;
};

partial interface MLGraphBuilder {
  sequence<MLOperand> lstm(MLOperand input,
                           MLOperand weight,
                           MLOperand recurrentWeight,
                           [EnforceRange] unsigned long steps,
                           [EnforceRange] unsigned long hiddenSize,
                           optional MLLstmOptions options = {});
};

dictionary MLLstmSupportLimits {
  MLTensorLimits input;
  MLTensorLimits weight;
  MLTensorLimits recurrentWeight;
  MLTensorLimits bias;
  MLTensorLimits recurrentBias;
  MLTensorLimits peepholeWeight;
  MLTensorLimits initialHiddenState;
  MLTensorLimits initialCellState;
  MLTensorLimits output0;
  MLTensorLimits output1;
  MLTensorLimits output2;
};

partial dictionary MLOpSupportLimits {
  MLLstmSupportLimits lstm;
};

MLLstmOptions には次のメンバーがあります。

bias, 型は MLOperand

shape [numDirections, 4 * hiddenSize] の 2-D 入力 bias テンソル。テンソル shape の第 2 次元における bias ベクトルの順序は layout に従って指定されます。

recurrentBias, 型は MLOperand

shape [numDirections, 4 * hiddenSize] の 2-D リカレント bias テンソル。テンソル shape の第 1 次元における bias ベクトルの順序は layout に従って指定されます。

peepholeWeight, 型は MLOperand

shape [numDirections, 3 * hiddenSize] の peephole 用 2-D weight テンソル。weight ベクトルのパック 順序は、それぞれ input (i)、output (o)、および forget (f) ゲートです。

initialHiddenState, 型は MLOperand

shape [numDirections, batchSize, hiddenSize] の 3-D 初期隠れ状態テンソル。指定 されていない場合、実装は 0 で埋められたテンソルを使用しなければなりません。

initialCellState, 型は MLOperand

shape [numDirections, batchSize, hiddenSize] の 3-D 初期隠れ状態テンソル。指定 されていない場合、実装は 0 で埋められたテンソルを使用しなければなりません。

returnSequence, 型は boolean、デフォルトは false

最後の時間ステップの出力に加えて、各時間ステップのすべての出力を含むシーケンス全体も 返すかどうかを示します。

direction, 型は MLRecurrentNetworkDirection、デフォルトは "forward"

入力シーケンスの処理方向。"both" に設定した場合、weight および bias テンソル shape の第 1 次元のサイズは 2 でなければならず、入力は 両方向に処理されます。

layout, 型は MLLstmWeightLayout、デフォルトは "iofg"

LSTM の内部ゲート、具体的には input (i)、output (o)、forget (f)、および cell (g) ゲートの weight および bias ベクトルの順序であり、weight および bias テンソル shape の第 1 次元によって示されます。

activations, 型は sequence<MLRecurrentNetworkActivation>

3 つの活性化関数のリストで、第 1 の関数は input (i)、forget (f)、および output (o) ゲートに使用され、第 2 の関数は cell (g) ゲートに使用され、最後の関数は出力 cell state をフィルタリングして output ゲートの結果と結合し、出力 hidden state を形成するために使用されます。指定されていない場合、 デフォルトは "sigmoid"、 "tanh"、 および "tanh" 関数のシーケンスです。

引数:

戻り値: sequence<MLOperand>。 第 1 要素は shape [numDirections, batchSize, hiddenSize] の 3-D テンソルであり、ネットワークの最後の時間ステップからの出力 hidden state です。第 2 要素は shape [numDirections, batchSize, hiddenSize] の 3-D テンソルであり、ネットワークの最後の時間ステップからの出力 cell state です。 さらに、returnSequence が true に設定されている場合、第 3 要素は shape [steps, numDirections, batchSize, hiddenSize] の 4-D 出力テンソルであり、時間シーケンス内の各時間ステップからのすべての出力を含みます。

lstm() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" 3 3
weight 同じ input "float32", "float16" 3 3
recurrentWeight 同じ input "float32", "float16" 3 3
bias 同じ input "float32", "float16" 2 2
recurrentBias 同じ input "float32", "float16" 2 2
peepholeWeight 同じ input "float32", "float16" 2 2
initialHiddenState 同じ input "float32", "float16" 3 3
initialCellState 同じ input "float32", "float16" 3 3
outputs[0] 同じ input "float32", "float16" 3 3
outputs[1] 同じ input "float32", "float16" 3 3
outputs[2] if returnSequence が true の場合 同じ input "float32", "float16" 4 4

MLLstmSupportLimits には次のメンバーがあります。

input, 型は MLTensorLimits

input オペランドの MLTensorLimits。

weight, 型は MLTensorLimits

weight オペランドの MLTensorLimits。

recurrentWeight, 型は MLTensorLimits

recurrentWeight オペランドの MLTensorLimits。

bias, 型は MLTensorLimits

bias オペランドの MLTensorLimits。

recurrentBias, 型は MLTensorLimits

recurrentBias オペランドの MLTensorLimits。

peepholeWeight, 型は MLTensorLimits

peepholeWeight オペランドの MLTensorLimits。

initialHiddenState, 型は MLTensorLimits

initialHiddenState オペランドの MLTensorLimits。

initialCellState, 型は MLTensorLimits

initialCellState オペランドの MLTensorLimits。

output0, 型は MLTensorLimits

すべての出力オペランド[0]の MLTensorLimits。

output1, 型は MLTensorLimits

すべての出力オペランド[1]の MLTensorLimits。

output2, 型は MLTensorLimits

すべての出力オペランド[2]の MLTensorLimits。

MLOpSupportLimits には lstm() 用の次のメンバーがあります。

lstm, 型は MLLstmSupportLimits

lstm() 演算子のサポート制限。

lstm(input, weight, recurrentWeight, steps, hiddenSize, options) メソッドの手順は次のとおりです。

  1. this がビルドできない場合、"InvalidStateError" DOMException をスローします。

  2. オペランドを検証する処理を this と input、weight、 recurrentWeight、options.bias （それが存在する場合）、options.recurrentBias （それが存在する場合）、options.peepholeWeight （それが存在する場合）、options.initialHiddenState （それが存在する場合）、および options.initialCellState （それが存在する場合）のいずれかで行った結果が false の場合、TypeError をスローします。

  3. numDirections を options.direction が "both" の場合は 2、それ以外の場合は 1 とします。

  4. input、weight または recurrentWeight のいずれかのdataType がその許可されるデータ型 のいずれでもない場合（この表に従って）、TypeError をスローします。

  5. input、weight または recurrentWeight のいずれかのランクがその許可されるランクでない 場合、TypeError をスローします。

  6. steps が 0 の場合、TypeError をスローします。

  7. input のshape[0] が steps と等しくない場合、TypeError をスローします。

  8. batchSize を input のshape[1] とします。

  9. inputSize を input のshape[2] とします。

  10. weight のshape が « numDirections, 4 * hiddenSize, inputSize » と等しくない場合、TypeError をスローします。

  11. recurrentWeight のshape が « numDirections, 4 * hiddenSize, hiddenSize » と等しくない場合、TypeError をスローします。

  12. hiddenSize * 8 が有効な次元でない場合、TypeError をスローします。

    なぜ hiddenSize * 8 なのか？ 一部の基盤プラットフォームは、bias と recurrentBias を連結した単一の bias テンソルを使用します。 したがって、4 * hiddenSize + 4 * hiddenSize も有効な 次元である必要があります。

  13. options.bias が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

    2. そのshape が « numDirections, 4 * hiddenSize » と等しくない場合、TypeError をスローします。

  14. options.recurrentBias が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

    2. そのshape が « numDirections, 4 * hiddenSize » と等しくない場合、TypeError をスローします。

  15. options.peepholeWeight が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

    2. そのshape が « numDirections, 3 * hiddenSize » と等しくない場合、TypeError をスローします。

  16. options.initialHiddenState が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

    2. そのshape が « numDirections, batchSize, hiddenSize » と等しくない場合、TypeError をスローします。

  17. options.initialCellState が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、TypeError をスローします。

    2. そのshape が « numDirections, batchSize, hiddenSize » と等しくない場合、TypeError をスローします。

  18. options.activations が存在する場合:

    1. そのサイズが 3 でない場合、TypeError をスローします。

    2. activations を options.activations の複製とします。

  19. それ以外の場合:

    1. activations を « "sigmoid", "tanh", "tanh" » とします。

  20. 出力 shape を計算します。

    1. desc を、input のdataType と « numDirections, batchSize, hiddenSize » が与えられたときに MLOperandDescriptor を作成した結果とします。

    2. options.returnSequence が true の場合:

      1. desc2 を、input のdataType と « steps, numDirections, batchSize, hiddenSize » が与えられたときに MLOperandDescriptor を 作成した結果とします。

  21. グラフの接続を行います。

    1. operator を、weight、recurrentWeight、steps、hiddenSize および options が与えられた "lstm" 演算用の演算子とします。

    2. output0 を、this と desc が与えられたときに MLOperand を 作成した結果とします。

    3. output1 を、this と desc が与えられたときに MLOperand を 作成した結果とします。

    4. options.returnSequence が true の場合:

      1. output2 を、this と desc2 が与えられたときに MLOperand を 作成した結果とします。

      2. output をリスト « output0, output1, output2 » とします。

      3. output0.[[operator]]、 output1.[[operator]] および output2.[[operator]] を operator に設定します。

    5. それ以外の場合:

      1. output をリスト « output0, output1 » とします。

      2. output0.[[operator]] および output1.[[operator]] を operator に設定します。

    6. operator の入力を input、weight、および recurrentWeight に設定します。

    7. options.bias が存在する場合、それを operator の入力に追加します。

    8. options.recurrentBias が存在する場合、それを operator の入力に追加します。

    9. options.peepholeWeight が存在する場合、それを operator の入力に追加します。

    10. options.initialHiddenState が存在する場合、それを operator の入力に追加します。

    11. options.initialCellState が存在する場合、それを operator の入力に追加します。

    12. operator の活性化関数を activations の複製に設定します。

    13. operator の出力を output に設定します。

  22. output を返します。

squeeze() ヘルパーを使用すると、この演算の動作は ユーザーエージェントが通常はより効率的な実装を備えているものの、他の演算の使用から次のように 一般的にエミュレートできます。基盤となるプラットフォームが演算を直接 サポートしていない場合、この分解を実装の指針となるテンプレートとして使用できます。 
function lstm(
  builder, input, weight, recurrentWeight, steps, hiddenSize, options) {
  const batchSize = input.shape[1];
  const inputSize = input.shape[2];
  const direction = options.direction || 'forward';
  const numDirections = (direction == 'both' ? 2 : 1);
  let hiddenState = options.initialHiddenState;
  let cellState = options.initialCellState;

  if (!hiddenState) {
    const desc = {
      dataType: 'float32',
      shape: [numDirections, batchSize, hiddenSize]
    };
    const totalSize = numDirections * batchSize * hiddenSize;
    hiddenState = builder.constant(desc, new Float32Array(totalSize).fill(0));
  }

  if (!cellState) {
    const desc = {
      dataType: 'float32',
      shape: [numDirections, batchSize, hiddenSize]
    };
    const totalSize = numDirections * batchSize * hiddenSize;
    cellState = builder.constant(desc, new Float32Array(totalSize).fill(0));
  }

  let currentWeight = [];
  let currentRecurrentWeight = [];
  let currentBias = [];
  let currentRecurrentBias = [];
  let currentPeepholeWeight = [];
  let forwardSequence = null;
  let backwardSequence = null;
  let outputHidden = null;
  let outputCell = null;

  for (let dir = 0; dir < numDirections; ++dir) {
    currentWeight.push(squeeze(
      builder,
      builder.slice(weight, [dir, 0, 0], [1, 4 * hiddenSize, inputSize])));
    currentRecurrentWeight.push(squeeze(
      builder,
      builder.slice(
        recurrentWeight, [dir, 0, 0], [1, 4 * hiddenSize, hiddenSize])));
    currentBias.push(
      options.bias ?
        (squeeze(
          builder,
          builder.slice(options.bias, [dir, 0], [1, 4 * hiddenSize]))) :
        null);
    currentRecurrentBias.push(
      options.recurrentBias ?
        (squeeze(
          builder,
          builder.slice(
            options.recurrentBias, [dir, 0], [1, 4 * hiddenSize]))) :
        null);
    currentPeepholeWeight.push(
      options.peepholeWeight ?
        (squeeze(
          builder,
          builder.slice(
            options.peepholeWeight, [dir, 0], [1, 3 * hiddenSize]))) :
        null);

    let currentHidden = squeeze(
      builder,
      builder.slice(hiddenState, [dir, 0, 0], [1, batchSize, hiddenSize]), [0]);
    let currentCell = squeeze(
      builder,
      builder.slice(cellState, [dir, 0, 0], [1, batchSize, hiddenSize]), [0]);

    for (let step = 0; step < steps; ++step) {
      const slice =
        (dir == 1 || direction == 'backward' ? steps - step - 1 : step);
      const currentInput = squeeze(
        builder,
        builder.slice(input, [slice, 0, 0], [1, batchSize, inputSize]), [0]);

      [currentHidden, currentCell] = builder.lstmCell(
        currentInput,
        currentWeight[dir],
        currentRecurrentWeight[dir],
        currentHidden,
        currentCell,
        hiddenSize,
        {
          bias: currentBias[dir],
          recurrentBias: currentRecurrentBias[dir],
          peepholeWeight: currentPeepholeWeight[dir],
          layout: options.layout,
          activations: options.activations
        });

      if (options.returnSequence) {
        // 2D([batchSize, hiddenSize]) の currentHidden を拡張する
        // 4D([steps, numDirections, batchSize, hiddenSize]) へ
        const expandedHiddenAs4D =
          builder.reshape(currentHidden, [1, 1, batchSize, hiddenSize]);

        if (direction == 'forward' || (dir == 0 && direction == 'both')) {
          forwardSequence = forwardSequence ?
            builder.concat([forwardSequence, expandedHiddenAs4D], 0) :
            expandedHiddenAs4D;
        } else if (
          direction == 'backward' || (dir == 1 && direction == 'both')) {
          backwardSequence = backwardSequence ?
            builder.concat([expandedHiddenAs4D, backwardSequence], 0) :
            expandedHiddenAs4D;
        }
      }
    }

    // 2D([batchSize, hiddenSize]) の currentHidden を拡張する
    // 3D([numDirections, batchSize, hiddenSize]) へ
    const expandedHiddenAs3D =
      builder.reshape(currentHidden, [1, batchSize, hiddenSize]);
    outputHidden = outputHidden ?
      builder.concat([outputHidden, expandedHiddenAs3D], 0) :
      expandedHiddenAs3D;

    // 2D([batchSize, hiddenSize]) の currentCell を拡張する
    // 3D([numDirections, batchSize, hiddenSize]) へ
    const expandedCellAs3D =
      builder.reshape(currentCell, [1, batchSize, hiddenSize]);
    outputCell = outputCell ?
      builder.concat([outputCell, expandedCellAs3D], 0) :
      expandedCellAs3D;
  }

  if (options.returnSequence) {
    let outputSequence = null;

    if (direction == 'forward') {
      outputSequence = forwardSequence;
    } else if (direction == 'backward') {
      outputSequence = backwardSequence;
    } else if (direction == 'both') {
      // axis 1（numDirections 次元）に沿って連結する
      outputSequence = builder.concat([forwardSequence, backwardSequence], 1);
    }

    return [outputHidden, outputCell, outputSequence];
  } else {
    return [outputHidden, outputCell];
  }
}

8.9.34. lstmCell

セル状態、入力、出力、および forget ゲートを使用する Long Short-Term Memory [LSTM] リカレントネットワークの単一時間ステップであり、ネットワークの 時系列全体にわたって出力へ引き継がれる次の時間ステップのセル状態と隠れ状態を 計算します。 
dictionary MLLstmCellOptions : MLOperatorOptions {
  MLOperand bias;
  MLOperand recurrentBias;
  MLOperand peepholeWeight;
  MLLstmWeightLayout layout = "iofg";
  sequence<MLRecurrentNetworkActivation> activations;
};

partial interface MLGraphBuilder {
  sequence<MLOperand> lstmCell(MLOperand input,
                               MLOperand weight,
                               MLOperand recurrentWeight,
                               MLOperand hiddenState,
                               MLOperand cellState,
                               [EnforceRange] unsigned long hiddenSize,
                               optional MLLstmCellOptions options = {});
};

dictionary MLLstmCellSupportLimits {
  MLTensorLimits input;
  MLTensorLimits weight;
  MLTensorLimits recurrentWeight;
  MLTensorLimits hiddenState;
  MLTensorLimits cellState;
  MLTensorLimits bias;
  MLTensorLimits recurrentBias;
  MLTensorLimits peepholeWeight;
  MLTensorLimits output0;
  MLTensorLimits output1;
};

partial dictionary MLOpSupportLimits {
  MLLstmCellSupportLimits lstmCell;
};

MLLstmCellOptions には次のメンバーがあります:

bias, 型は MLOperand

shape [4 * hiddenSize] の 1-D 入力バイアステンソル。テンソル shape の 第 1 次元におけるバイアスベクトルの順序は layout に従って指定されます。

recurrentBias, 型は MLOperand

shape [4 * hiddenSize] の 1-D リカレントバイアステンソル。テンソル shape の 第 1 次元におけるバイアスベクトルの順序は layout に従って指定されます。

peepholeWeight, 型は MLOperand

shape [3 * hiddenSize] の peephole 用 1-D weight テンソル。weight ベクトルのパック順序は、 それぞれ input (i)、output (o)、および forget (f) ゲートです。

layout, 型は MLLstmWeightLayout、デフォルトは "iofg"

LSTM の内部ゲート、具体的には input (i)、output (o)、forget (f)、および cell (g) ゲートの weight および bias ベクトルの順序であり、weight および bias テンソル shape の第 1 次元によって示されます。

activations, 型は sequence<MLRecurrentNetworkActivation>

3 つの活性化関数のリスト。第 1 の関数は input (i)、forget (f)、および output (o) ゲートに使用され、第 2 の関数は cell (g) ゲートに使用され、最後の関数は出力セル状態をフィルタリングして output ゲートの結果と結合し、出力隠れ状態を形成するために使用されます。指定されていない場合、 デフォルトは "sigmoid"、 "tanh"、 および "tanh" 関数のシーケンスです。

引数:

戻り値: sequence<MLOperand>。 第 1 要素はリカレントネットワークの現在の時間ステップの出力隠れ状態です。 次の要素は出力セル状態です。両方の要素は shape [batchSize, hiddenSize] の 2-D テンソルです。

lstmCell() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" 2 2
weight 同じ input "float32", "float16" 2 2
recurrentWeight 同じ input "float32", "float16" 2 2
hiddenState 同じ input "float32", "float16" 2 2
cellState 同じ input "float32", "float16" 2 2
bias 同じ input "float32", "float16" 1 1
recurrentBias 同じ input "float32", "float16" 1 1
peepholeWeight 同じ input "float32", "float16" 1 1
outputs[0] 同じ input "float32", "float16" 2 2
outputs[1] 同じ input "float32", "float16" 2 2

MLLstmCellSupportLimits には次のメンバーがあります:

input, 型は MLTensorLimits

MLTensorLimits は input オペランド用です。

weight, 型は MLTensorLimits

MLTensorLimits は weight オペランド用です。

recurrentWeight, 型は MLTensorLimits

MLTensorLimits は recurrentWeight オペランド用です。

hiddenState, 型は MLTensorLimits

MLTensorLimits は hiddenState オペランド用です。

cellState, 型は MLTensorLimits

MLTensorLimits は cellState オペランド用です。

bias, 型は MLTensorLimits

MLTensorLimits は bias オペランド用です。

recurrentBias, 型は MLTensorLimits

MLTensorLimits は recurrentBias オペランド用です。

peepholeWeight, 型は MLTensorLimits

MLTensorLimits は peepholeWeight オペランド用です。

output0, 型は MLTensorLimits

MLTensorLimits はすべての出力オペランド[0]用です。

output1, 型は MLTensorLimits

MLTensorLimits はすべての出力オペランド[1]用です。

MLOpSupportLimits には lstmCell() 用の次のメンバーがあります:

lstmCell, 型は MLLstmCellSupportLimits

演算子 lstmCell() のサポート制限。

この lstmCell(input, weight, recurrentWeight, hiddenState, cellState, hiddenSize, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input、weight、 recurrentWeight、hiddenState、cellState、 options.bias （それが存在する場合）、options.recurrentBias （それが存在する場合）、および options.peepholeWeight （それが存在する場合）のいずれかで行った結果が false の場合、スローします、TypeError を。

  3. input、weight、recurrentWeight、hiddenState または cellState の dataType のいずれかが、その許可されるデータ型のいずれでもない場合（この表に従って）、スローします、TypeError を。

  4. input、weight、recurrentWeight、hiddenState または cellState のいずれかのランクが その許可されるランクでない場合、スローします、TypeError を。

  5. batchSize を input のshape[0] とします。

  6. inputSize を input のshape[1] とします。

  7. weight のshape が « 4 * hiddenSize, inputSize » と等しくない場合、 スローします、TypeError を。

  8. recurrentWeight のshape が « 4 * hiddenSize, hiddenSize » と等しくない場合、 スローします、TypeError を。

  9. hiddenState のshape が « batchSize, hiddenSize » と等しくない場合、 スローします、TypeError を。

  10. cellState のshape が « batchSize, hiddenSize » と等しくない場合、 スローします、TypeError を。

  11. hiddenSize * 8 が有効な次元でない場合、スローします、TypeError を。

    なぜ hiddenSize * 8 なのか？ 一部の基盤プラットフォームでは、bias と recurrentBias を連結した単一の bias テンソルを扱います。 したがって、4 * hiddenSize + 4 * hiddenSize も有効な 次元である必要があります。

  12. options.bias が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、スロー します、TypeError を。

    2. そのshape が « 4 * hiddenSize » と等しくない場合、スロー します、TypeError を。

  13. options.recurrentBias が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、スロー します、TypeError を。

    2. そのshape が « 4 * hiddenSize » と等しくない場合、スロー します、TypeError を。

  14. options.peepholeWeight が存在する場合:

    1. そのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、スロー します、TypeError を。

    2. そのshape が « 3 * hiddenSize » と等しくない場合、スロー します、TypeError を。

  15. options.activations が存在する場合:

    1. そのサイズが 3 でない場合、スロー します、TypeError を。

    2. activations を options.activations の複製 とします。

  16. それ以外の場合:

    1. activations を « "sigmoid", "tanh", "tanh" » とします。

  17. desc を新しい MLOperandDescriptor とします。

  18. desc.shape をリスト « batchSize, hiddenSize » に設定します。

  19. desc.dataType を input のdataType に設定します。

  20. グラフの接続を行います:

    1. output0 を、MLOperand を 作成した結果とし、this と desc を与えます。

    2. output1 を、MLOperand を 作成した結果とし、this と desc を与えます。

    3. output をリスト « output0, output1 » とします。

    4. operator を "lstmCell" 演算用の演算子とし、 weight、recurrentWeight、hiddenState、 cellState、hiddenSize および options を与えます。

    5. output0.[[operator]] および output1.[[operator]] を operator に設定します。

    6. operator の入力を input、weight、 recurrentWeight、hiddenState、および cellState に設定します。

    7. options.bias が存在する場合、それを operator の入力に追加します。

    8. options.recurrentBias が存在する場合、それを operator の入力に追加します。

    9. options.peepholeWeight が存在する場合、それを operator の入力に追加します。

    10. operator の活性化関数を activations の複製に設定します。

    11. operator の出力を output に設定します。

  21. output を返します。

weight layout がデフォルトの "iofg" layout であり、input/forget/output ゲートおよび cell ゲート/出力隠れ状態用の cell state のフィルターの活性化関数がそれぞれ sigmoid() と tanh() である場合、この演算の動作は、ユーザーエージェントが通常はより効率的な実装を備えているものの、 他の演算の使用から次のように一般的にエミュレートできます。基盤となるプラットフォームが 演算を直接サポートしていない場合、この分解を実装の指針となるテンプレートとして 使用できます。 
function lstmCell(
  builder,
  input,
  weight,
  recurrentWeight,
  hiddenState,
  cellState,
  hiddenSize,
  options) {
  const zero = builder.constant(input.dataType, 0);

  const inputSize = input.shape[1];

  // input ゲート (i)
  let i = builder.sigmoid(builder.add(
    builder.mul(
      cellState,
      (options.peepholeWeight ?
         builder.slice(options.peepholeWeight, [0], [hiddenSize]) :
         zero)),
    builder.add(
      builder.add(
        (options.bias ? builder.slice(options.bias, [0], [hiddenSize]) : zero),
        (options.recurrentBias ?
           builder.slice(options.recurrentBias, [0], [hiddenSize]) :
           zero)),
      builder.add(
        builder.matmul(
          input,
          builder.transpose(
            builder.slice(weight, [0, 0], [hiddenSize, inputSize]))),
        builder.matmul(
          hiddenState,
          builder.transpose(builder.slice(
            recurrentWeight, [0, 0], [hiddenSize, hiddenSize])))))));

  // forget ゲート (f)
  let f = builder.sigmoid(builder.add(
    builder.mul(
      cellState,
      (options.peepholeWeight ?
         builder.slice(options.peepholeWeight, [2 * hiddenSize], [hiddenSize]) :
         zero)),
    builder.add(
      builder.add(
        (options.bias ?
           builder.slice(options.bias, [2 * hiddenSize], [hiddenSize]) :
           zero),
        (options.recurrentBias ?
           builder.slice(
             options.recurrentBias, [2 * hiddenSize], [hiddenSize]) :
           zero)),
      builder.add(
        builder.matmul(
          input,
          builder.transpose(builder.slice(
            weight, [2 * hiddenSize, 0], [hiddenSize, inputSize]))),
        builder.matmul(
          hiddenState,
          builder.transpose(builder.slice(
            recurrentWeight,
            [2 * hiddenSize, 0],
            [hiddenSize, hiddenSize])))))));

  // cell ゲート (g)
  let g = builder.tanh(builder.add(
    builder.add(
      (options.bias ?
         builder.slice(options.bias, [3 * hiddenSize], [hiddenSize]) :
         zero),
      (options.recurrentBias ?
         builder.slice(options.recurrentBias, [3 * hiddenSize], [hiddenSize]) :
         zero)),
    builder.add(
      builder.matmul(
        input,
        builder.transpose(
          builder.slice(weight, [3 * hiddenSize, 0], [hiddenSize, inputSize]))),
      builder.matmul(
        hiddenState,
        builder.transpose(builder.slice(
          recurrentWeight, [3 * hiddenSize, 0], [hiddenSize, hiddenSize]))))));

  // output ゲート (o)
  let o = builder.sigmoid(builder.add(
    builder.mul(
      cellState,
      (options.peepholeWeight ?
         builder.slice(options.peepholeWeight, [hiddenSize], [hiddenSize]) :
         zero)),
    builder.add(
      builder.add(
        (options.bias ?
           builder.slice(options.bias, [hiddenSize], [hiddenSize]) :
           zero),
        (options.recurrentBias ?
           builder.slice(options.recurrentBias, [hiddenSize], [hiddenSize]) :
           zero)),
      builder.add(
        builder.matmul(
          input,
          builder.transpose(
            builder.slice(weight, [hiddenSize, 0], [hiddenSize, inputSize]))),
        builder.matmul(
          hiddenState,
          builder.transpose(builder.slice(
            recurrentWeight, [hiddenSize, 0], [hiddenSize, hiddenSize])))))));

  // 出力セル状態 (ct)
  let ct = builder.add(builder.mul(f, cellState), builder.mul(i, g));

  // 出力隠れ状態 (ht)
  let ht = builder.mul(o, builder.tanh(ct));

  return [ht, ct];
}

8.9.35. matmul

2 つの入力テンソルの行列積を計算します。 
partial interface MLGraphBuilder {
  MLOperand matmul(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLBinarySupportLimits matmul;
};
引数:

戻り値: MLOperand。 2 つの入力テンソルの行列 積を含む出力テンソル。

2 つの入力テンソルの行列積を次のように計算します:
matmul() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
a "float32", "float16" "float32", "float16" 2 から N 2 から 5
b 同じ a "float32", "float16" 2 から N 2 から 5
output 同じ a "float32", "float16" 2 から N 2 から 5

MLOpSupportLimits には matmul() 用の次のメンバーがあります:

matmul, 型は MLBinarySupportLimits

演算子 matmul() のサポート制限。

この matmul(a, b, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と a および b のいずれかで行った結果が false の場合、 スローします、TypeError を。

  3. a または b のいずれかのdataType が その許可されるデータ型のいずれでもない場合（この表に従って）、スローします、TypeError を。

  4. 出力 shape を計算します:

    1. shapeA を a の複製 のshape とします。

    2. rankA を a のランクとします。

    3. shapeB を b の複製 のshape とします。

    4. rankB を b のランクとします。

    5. rankA または rankB のいずれかが 2 未満の場合、スローします、TypeError を。

    6. colsA を shapeA[rankA - 1] とします。

    7. rowsA を shapeA[rankA - 2] とします。

    8. colsB を shapeB[rankB - 1] とします。

    9. rowsB を shapeB[rankB - 2] とします。

    10. colsA が rowsB と等しくない場合、スロー します、TypeError を。

    11. batchShapeA を shapeA の複製とし、 空間次元（最後の 2 項目）は削除します。

    12. batchShapeB を shapeB の複製とし、 空間次元（最後の 2 項目）は削除します。

    13. outputShape を、双方向にブロードキャストする batchShapeA と batchShapeB の結果とします。それが failure を返した場合、スローします、TypeError を。

    14. 追加します « rowsA, colsB » を outputShape に。

    15. desc を、MLOperandDescriptor を作成する 処理に a のdataType と outputShape を与えた結果とします。

  5. グラフの接続を行います:

    1. output を、MLOperand を 作成する処理に this と desc を与えた結果とします。

    2. operator を "matmul" 演算用の演算子とし、 options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を a および b に設定します。

    5. operator の出力を output に設定します。

  6. output を返します。

8.9.36. pad

テンソルの端を定数値または鏡像値で拡張します。 
enum MLPaddingMode {
  "constant",
  "edge",
  "reflection"
};

dictionary MLPadOptions : MLOperatorOptions {
  MLPaddingMode mode = "constant";
  MLNumber value = 0;
};

partial interface MLGraphBuilder {
  MLOperand pad(MLOperand input,
                sequence<[EnforceRange] unsigned long> beginningPadding,
                sequence<[EnforceRange] unsigned long> endingPadding,
                optional MLPadOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits pad;
};

MLPadOptions には次のメンバーがあります:

mode, 型は MLPaddingMode、デフォルトは "constant"

テンソルをパディングするさまざまな方法。

value, 型は MLNumber、デフォルトは 0

mode が "constant" に設定されている場合のパディング値。

引数:

戻り値: MLOperand。 パディングされた出力テンソル。出力テンソルの各次元は次のように計算できます:

output size = beginning padding + input size + ending padding

pad() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16" N 0 から 5
output 同じ input "float32", "float16" 同じ input 0 から 5

MLOpSupportLimits には pad() 用の次のメンバーがあります:

pad, 型は MLSingleInputSupportLimits

演算子 pad() のサポート制限。

この pad(input, beginningPadding, endingPadding, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. beginningPadding のサイズと endingPadding のサイズが どちらも input のランクと等しくない場合、スローします、TypeError を。

  4. desc を input.[[descriptor]] のコピーとします。

  5. outputShape を input のshape のコピーとします。

  6. 各 index について 範囲 0 から outputShape のランクまで、 上限を含まず反復します:

    1. options.mode に応じて分岐します:

      "constant"

      何もしません。

      "edge"

      何もしません。

      "reflection"

      1. beginningPadding[index] が outputShape[index] 以上の場合、スローします、TypeError を。

      2. endingPadding[index] が outputShape[index] 以上の場合、スローします、TypeError を。

    2. outputShape[index] に beginningPadding[index] の値を加えます。

    3. outputShape[index] に endingPadding[index] の値を加えます。

  7. outputShape 内のいずれかの項目が有効な次元でない場合、スローします、TypeError を。

  8. options.value を、キャストする処理の結果に設定します options.value を input のdataType に。

  9. desc.shape を outputShape に設定します。

  10. グラフの接続を行います:

    1. output を、MLOperand を 作成する処理に this と desc を与えた結果とします。

    2. operator を "padding" 演算用の演算子とし、 beginningPadding、endingPadding および options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  11. output を返します。

constant、edge、および reflection パディングの例: 
// input: [[1,2,3], [4,5,6]]
const input = builder.constant(
  {dataType: 'float32', shape: [2, 3]}, new Float32Array([1, 2, 3, 4, 5, 6]));

const beginningPadding = [1, 2];
const endingPadding = [1, 2];

// "constant" パディング:
//    [[0,0,0,0,0,0,0],
//     [0,0,1,2,3,0,0],
//     [0,0,4,5,6,0,0],
//     [0,0,0,0,0,0,0]]
builder.pad(input, beginningPadding, endingPadding);

// "edge" パディング:
//    [[1,1,1,2,3,3,3],
//     [1,1,1,2,3,3,3],
//     [4,4,4,5,6,6,6],
//     [4,4,4,5,6,6,6]]
builder.pad(input, beginningPadding, endingPadding, {mode: 'edge'});

// "reflection" パディング:
//    [[6,5,4,5,6,5,4],
//     [3,2,1,2,3,2,1],
//     [6,5,4,5,6,5,4],
//     [3,2,1,2,3,2,1]]
builder.pad(input, beginningPadding, endingPadding, {mode: 'reflection'});

8.9.37. プーリング演算

入力テンソル上を移動するウィンドウ内のすべての要素にわたってプーリング演算を計算します。 
enum MLRoundingType {
  "floor",
  "ceil"
};

dictionary MLPool2dOptions : MLOperatorOptions {
  sequence<[EnforceRange] unsigned long> windowDimensions;
  sequence<[EnforceRange] unsigned long> padding;
  sequence<[EnforceRange] unsigned long> strides;
  sequence<[EnforceRange] unsigned long> dilations;
  MLInputOperandLayout layout = "nchw";
  MLRoundingType outputShapeRounding = "floor";
  sequence<[EnforceRange] unsigned long> outputSizes;
};

partial interface MLGraphBuilder {
  MLOperand averagePool2d(MLOperand input, optional MLPool2dOptions options = {});
  MLOperand l2Pool2d(MLOperand input, optional MLPool2dOptions options = {});
  MLOperand maxPool2d(MLOperand input, optional MLPool2dOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits averagePool2d;
  MLSingleInputSupportLimits l2Pool2d;
  MLSingleInputSupportLimits maxPool2d;
};

MLPool2dOptions には次のメンバーがあります:

windowDimensions, 型は sequence<[EnforceRange] unsigned long>

長さ 2 のリスト: [windowHeight, windowWidth]。 スライディングウィンドウの次元を指定します。 ウィンドウ次元のデフォルト値は入力 shape の高さと幅の次元です。

padding, 型は sequence<[EnforceRange] unsigned long>

長さ 4 のリスト: [beginningHeight, endingHeight, beginningWidth, endingWidth]。 畳み込み入力の各空間 次元の先頭と末尾に追加される行と列を指定します。 デフォルト値は [0,0,0,0] です。

strides, 型は sequence<[EnforceRange] unsigned long>

長さ 2 のリスト: [strideHeight, strideWidth]。 畳み込み入力の各空間次元に対するスライディングウィンドウのストライドを指定します。 デフォルト値は [1,1] です。

dilations, 型は sequence<[EnforceRange] unsigned long>

長さ 2 のリスト: [dilationHeight, dilationWidth]。畳み込みフィルター（kernel）に適用される各 空間次元の dilation 係数を指定します。 デフォルト値は [1,1] です。

layout, 型は MLInputOperandLayout、デフォルトは "nchw"

入力および出力テンソルの layout 形式を次のように指定します:

  • "nchw"

    • 入力テンソル: [batches, inputChannels, height, width]

    • 出力テンソル: [batches, outputChannels, height, width]

  • "nhwc":

    • 入力テンソル: [batches, height, width, inputChannels]

    • 出力テンソル: [batches, height, width, outputChannels]

outputShapeRounding, 型は MLRoundingType、デフォルトは "floor"

完全なウィンドウ結果または部分的なウィンドウ結果のどちらが必要かに応じて、出力 shape の計算に使用される 丸め関数。

outputSizes, 型は sequence<[EnforceRange] unsigned long>

長さ 2 のリスト: [outputHeight, outputWidth] 出力テンソルの 2 つの空間次元のサイズを指定します。 出力サイズが明示的に指定されている場合、outputShapeRounding は無視されます。 指定されていない場合、出力サイズは自動的に計算されます。

引数:

戻り値: MLOperand。 リダクションの 結果を含む出力 4-D テンソル。論理 shape は layout の値に従って解釈されます。 より具体的には、outputShapeRounding が "floor" の場合、出力テンソルの単一次元の空間次元は次のように計算できます:

output size = floor(1 + (input size - filter size + beginning padding + ending padding) / stride)

または outputShapeRounding が "ceil" の場合:

output size = ceil(1 + (input size - filter size + beginning padding + ending padding) / stride)

averagePool2d()/l2Pool2d() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" 4 4
output 同じ input "float32", "float16" 4 4
maxPool2d() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16" 4 4
output 同じ input "float32", "float16" 4 4

MLOpSupportLimits にはプーリング演算用の次のメンバーがあります:

averagePool2d, 型は MLSingleInputSupportLimits

演算子 averagePool2d() のサポート制限。

l2Pool2d, 型は MLSingleInputSupportLimits

演算子 l2Pool2d() のサポート制限。

maxPool2d, 型は MLSingleInputSupportLimits

演算子 maxPool2d() のサポート制限。

max pooling 演算のようなグローバルプーリング演算は、 ウィンドウ次元が入力 shape の空間次元（最後の 2 次元）であるプーリングの変種です。次のようになります。 
// 'global' max pooling
builder.maxPool2d(input);
次の プーリング演算を作成するには、文字列 op、MLOperand input、MLPool2dOptions options、およびオプションのリスト allowedDataTypes が与えられた場合、次の手順を実行します:

  1. 表明: op は "averagePool2d"、"l2Pool2d"、 "maxPool2d" のいずれかです。

  2. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  3. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  4. allowedDataTypes が与えられ、それが含まない input のdataType を場合、スローします、TypeError を。

  5. input のランクが 4 でない場合、スローします、TypeError を。

  6. options.layout に応じて分岐します:

    "nchw"

    « batches, channels, inputHeight, inputWidth » を input のshape とします。

    "nhwc"

    « batches, inputHeight, inputWidth, channels » を input のshape とします。

  7. options.windowDimensions が存在しない場合、options.windowDimensions を « inputHeight, inputWidth » に設定します。

  8. options.windowDimensions の サイズが 2 でない場合、スローします、TypeError を。

  9. options.windowDimensions 内のいずれかの項目が 0 に等しい場合、スローします、TypeError を。

  10. options.outputSizes が存在するか、または options.padding が存在しない場合、options.padding をリスト « 0, 0, 0, 0 » に設定します。

  11. options.padding の サイズが 4 でない場合、スローします、TypeError を。

  12. options.strides が存在しない場合、options.strides をリスト « 1, 1 » に設定します。

  13. options.strides の サイズが 2 でない場合、スローします、TypeError を。

  14. options.strides 内のいずれかの項目が 0 の場合、スローします、TypeError を。

  15. options.outputSizes が存在する場合:

    1. そのサイズが 2 でない場合、スロー します、TypeError を。

    2. その項目が、options.strides の同じ次元（index）にある項目 より小さくない場合、スローします、TypeError を。

  16. options.dilations が存在しない場合、options.dilations をリスト « 1, 1 » に設定します。

  17. options.dilations の サイズが 2 でない場合、スローします、TypeError を。

  18. options.dilations 内のいずれかの項目が 0 の場合、スローします、TypeError を。

  19. desc を input.[[descriptor]] のコピーとします。

  20. 出力 shape を計算します:

    1. « windowHeight, windowWidth » を options.windowDimensions とします。

    2. « calculatedOutputHeight, calculatedOutputWidth » を、 conv2d 出力 サイズを計算する処理に inputHeight、inputWidth、 windowHeight、windowWidth、options.padding、 options.strides、 および options.dilations を与えた結果とします。

    3. options.outputSizes が存在する場合:

      1. « outputHeight, outputWidth » を options.outputSizes とします。

      2. outputHeight が floor( calculatedOutputHeight ) と等しく、かつ outputWidth が floor( calculatedOutputWidth ) と等しい場合でもなく、outputHeight が ceil( calculatedOutputHeight ) と等しく、かつ outputWidth が ceil( calculatedOutputWidth ) と等しい場合でもない場合、スローします、TypeError を。

    4. それ以外の場合:

      1. « outputHeight, outputWidth » を « calculatedOutputHeight, calculatedOutputWidth » とします。

      2. options.outputShapeRounding に応じて分岐します:

        "floor"

        1. outputWidth を floor(outputWidth) に設定します。

        2. outputHeight を floor(outputHeight) に設定します。

        "ceil"

        1. outputWidth を ceiling(outputWidth) に設定します。

        2. outputHeight を ceiling(outputHeight) に設定します。

    5. outputHeight または outputWidth のいずれかが有効な 次元でない場合、スロー します、TypeError を。

    6. options.layout に応じて分岐します:

      "nchw"

      outputShape を « batches, channels, outputHeight, outputWidth » とします。

      "nhwc"

      outputShape を « batches, outputHeight, outputWidth, channels » とします。

    7. desc.shape を outputShape に設定します。

  21. グラフの接続を行います:

    1. output を、MLOperand を 作成する処理に this と desc を与えた結果とします。

    2. operator を op 演算用の演算子とし、 options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  22. output を返します。

次のプーリングアルゴリズムがサポートされています。
この averagePool2d(input, options) メソッドの手順は次のとおりです:

  1. output を、プーリング 演算を作成する処理に "averagePool2d"、input、options、および « "float32", "float16" » を与えた結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

この l2Pool2d(input, options) メソッドの手順は次のとおりです:

  1. output を、プーリング 演算を作成する処理に "l2Pool2d"、input、options、および « "float32", "float16" » を与えた結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

この maxPool2d(input, options) メソッドの手順は次のとおりです:

  1. output を、プーリング 演算を作成する処理に "maxPool2d"、input および options を与えた結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

8.9.37.1. averagePool2d
feature map のパッチの平均値を計算し、それを使用してプールされた feature map を作成します。詳細については § 8.9.37 プーリング演算を参照してください。
8.9.37.2. l2Pool2d
入力 feature map の領域に L2 ノルム関数を適用します。L2 ノルムは、 その要素の二乗和の平方根です。詳細については § 8.9.37 プーリング演算を 参照してください。
8.9.37.3. maxPool2d
feature map のパッチの最大値を計算し、それを使用してプールされた feature map を作成します。詳細については § 8.9.37 プーリング演算を参照してください。

8.9.38. prelu

入力テンソルに対して要素単位でrectified linear 関数の パラメトリック版（Parametric ReLU）を計算します。Parametric ReLU は leaky ReLU の一種であり、0.01 のようなスカラーの傾きを持つ代わりに、傾き（ leakage の係数）をこの演算のモデル学習フェーズ中に学習されるパラメーターにします。計算は 式 max(0, x) + slope * min(0, x) に従います。

この演算はブロードキャスト されます、[numpy-broadcasting-rule] に従って。入力テンソルは双方向にブロードキャスト可能でなければなりません。出力テンソルのランク は入力テンソルの最大ランクです。 出力テンソルの各次元について、そのサイズは入力テンソルのその次元に沿った最大サイズです。

partial interface MLGraphBuilder {
  MLOperand prelu(MLOperand input,
                  MLOperand slope,
                  optional MLOperatorOptions options = {});
};

dictionary MLPreluSupportLimits {
  MLTensorLimits input;
  MLTensorLimits slope;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLPreluSupportLimits prelu;
};
引数:

戻り値:

prelu() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16", "int64", "int32", "int8" "float32", "float16" N 0 から 5
slope 同じ input "float32", "float16" N 0 から 5
output 同じ input "float32", "float16" N 0 から 5

MLPreluSupportLimits には次のメンバーがあります:

input, 型は MLTensorLimits

MLTensorLimits は input オペランド用です。

slope, 型は MLTensorLimits

MLTensorLimits は slope オペランド用です。

output, 型は MLTensorLimits

MLTensorLimits は output オペランド用です。

MLOpSupportLimits には prelu() 用の次のメンバーがあります:

prelu, 型は MLPreluSupportLimits

演算子 prelu() のサポート制限。

この prelu(input, slope, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input および slope のいずれかで行った結果が false の場合、スローします、TypeError を。

  3. input または slope のいずれかのdataType がその許可されるデータ型のいずれでもない場合（この表に従って）、スローします、TypeError を。

  4. outputShape を、双方向にブロードキャストする slope のshape と input のshape の結果とします。

    1. それが failure を返した場合、スロー します、TypeError を。

  5. descriptor を、MLOperandDescriptor を 作成する処理に input のdataType と outputShape を与えた結果とします。

  6. グラフの接続を行います:

    1. output を、MLOperand を 作成する処理に this と descriptor を与えた結果とします。

    2. operator を "prelu" 演算用の演算子とし、 slope および options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input および slope に設定します。

    5. operator の出力を output に設定します。

  7. output を返します。

この演算の動作は、他の演算の使用から次のように一般的にエミュレートできます。 ただし、ユーザーエージェントは通常、より効率的な実装を備えています。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function prelu(builder, input, slope) {
  return builder.add(
    builder.max(builder.constant(input.dataType, 0), input),
    builder.mul(
      slope, builder.min(builder.constant(input.dataType, 0), input)));
}

8.9.39. リダクション演算

入力テンソルをすべての次元に沿って、または axes 配列パラメーターで指定された軸に沿ってリダクションします。指定された各軸について、そのインデックスを持つ次元がリダクションされます。つまり、結果のテンソルには keepDimensions が指定されていない限り、その次元は含まれません。結果のテンソルの値は、リダクションされた次元全体のすべての入力値を パラメーターとして受け取る、指定されたリダクション関数を使用して計算されます。 
dictionary MLReduceOptions : MLOperatorOptions {
  sequence<[EnforceRange] unsigned long> axes;
  boolean keepDimensions = false;
};

partial interface MLGraphBuilder {
  MLOperand reduceL1(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceL2(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceLogSum(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceLogSumExp(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceMax(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceMean(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceMin(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceProduct(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceSum(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceSumSquare(MLOperand input, optional MLReduceOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits reduceL1;
  MLSingleInputSupportLimits reduceL2;
  MLSingleInputSupportLimits reduceLogSum;
  MLSingleInputSupportLimits reduceLogSumExp;
  MLSingleInputSupportLimits reduceMax;
  MLSingleInputSupportLimits reduceMean;
  MLSingleInputSupportLimits reduceMin;
  MLSingleInputSupportLimits reduceProduct;
  MLSingleInputSupportLimits reduceSum;
  MLSingleInputSupportLimits reduceSumSquare;
};

MLReduceOptions には次のメンバーがあります:

axes, 型は sequence<[EnforceRange] unsigned long>

リダクションする次元。これは、入力テンソル内のどの値を リダクション関数で使用するかも指定します。リスト内の軸は [0, N-1] の範囲内でなければならず、N は入力テンソルのランクです。

存在しない場合、すべての次元がリダクションされます。リダクション関数への入力値は 入力テンソル内のすべての値です。

存在し、空でない場合、リダクション関数への入力値は 入力テンソルの指定された次元に対するすべての値です。

存在し、空の場合、どの次元もリダクションされず、出力テンソルの形状は 入力テンソルの形状と同じです。リダクション関数はテンソル内の各値に 個別に適用されます。

keepDimensions, 型は boolean、デフォルトは false

true の場合、出力は入力と同じランクを持ち、リダクションされたすべての次元のサイズを 1 に設定します。

引数:

戻り値: MLOperand。 出力 N-D テンソルのランクは 0 から input の ランクまでの範囲（両端を含む）であり、 axes と keepDimensions に依存します。 入力オペランドがスカラーの場合、リダクション関数はスカラー値に適用され、出力も スカラーです。

reduceL1()/reduceSum()/reduceSumSquare() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16", "int32", "uint32", "int64", "uint64" "float32", "float16", "int32" N 0 から 5
output 同じ input "float32", "float16", "int32" N 0 から 5
reduceL2()/reduceLogSum()/reduceLogSumExp()/reduceMean() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" N 0 から 5
output 同じ input "float32", "float16" N 0 から 5
reduceMax()/reduceMin() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32" N 0 から 5
output 同じ input "float32", "float16", "int32" N 0 から 5
reduceProduct() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16", "int32", "uint32", "int64", "uint64" "float32", "float16" N 0 から 5
output 同じ input "float32", "float16" N 0 から 5

MLOpSupportLimits にはリダクション演算用の次のメンバーがあります:

reduceL1, 型は MLSingleInputSupportLimits

演算子 reduceL1() のサポート制限。

reduceL2, 型は MLSingleInputSupportLimits

演算子 reduceL2() のサポート制限。

reduceLogSum, 型は MLSingleInputSupportLimits

演算子 reduceLogSum() のサポート制限。

reduceLogSumExp, 型は MLSingleInputSupportLimits

演算子 reduceLogSumExp() のサポート制限。

reduceMax, 型は MLSingleInputSupportLimits

演算子 reduceMax() のサポート制限。

reduceMean, 型は MLSingleInputSupportLimits

演算子 reduceMean() のサポート制限。

reduceMin, 型は MLSingleInputSupportLimits

演算子 reduceMin() のサポート制限。

reduceProduct, 型は MLSingleInputSupportLimits

演算子 reduceProduct() のサポート制限。

reduceSum, 型は MLSingleInputSupportLimits

演算子 reduceSum() のサポート制限。

reduceSumSquare, 型は MLSingleInputSupportLimits

演算子 reduceSumSquare() のサポート制限。

リダクションの種類:
リダクション出力サイズを計算するには、 リストである 符号なし整数 inputShape、オプションのリストである符号なし整数 axes、および boolean keepDimensions が与えられた場合、次の手順を実行します。これらは 符号なし整数の新しいリスト、 または failure を返します。

  1. inputRank を inputShape のサイズとします。

  2. axes が与えられていない場合、axes を範囲 0 から inputRank まで（上限を含まない）とします。

  3. それ以外の場合、axes に重複値が含まれているか、その項目のいずれかが 範囲 0 から inputRank まで（上限を含まない）にない場合、 failure を返します。

  4. keepDimensions が true の場合:

    1. outputShape を inputShape の複製 とします。

    2. 各 axis について axes を反復します:

      1. outputShape[axis] を 1 に設定します。

  5. それ以外の場合:

    1. outputShape を空のリストとします。

    2. 各 index について 範囲 0 から inputRank まで（上限を含まない）を反復します:

      1. axes が index を含まない場合、inputShape[index] を追加します、outputShape に。

  6. outputShape を返します。

リダクション演算を作成するには、文字列 op、MLOperand input、MLReduceOptions options、およびオプションのリスト allowedDataTypes が与えられた場合、次の手順を実行します:

  1. 表明: op は "reduceL1"、"reduceL2"、 "reduceLogSum"、"reduceLogSumExp"、"reduceMax"、"reduceMean"、"reduceMin"、"reduceProduct"、 "reduceSum"、"reduceSumSquare" のいずれかです。

  2. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  3. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  4. allowedDataTypes が与えられ、それが含まない input のdataType を場合、スローします、TypeError を。

  5. outputShape を、リダクション出力 サイズを計算する処理に input の形状、options.axes （それが存在する場合）、および options.keepDimensions を与えた結果とします。 それが failure を返した場合、スローします、TypeError を。

  6. desc を、MLOperandDescriptor を 作成する処理に input のdataType と outputShape を与えた結果とします。

  7. グラフの接続を行います:

    1. output を、MLOperand を 作成する処理に this と desc を与えた結果とします。

    2. operator を op 演算用の演算子とし、 options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  8. output を返します。

次のリダクションアルゴリズムがサポートされています。
この reduceL1(input, options) メソッドの手順は次のとおりです:

  1. output を、リダクション演算を作成する 処理に "reduceL1"、input、options、および « "float32", "float16", "int32", "uint32", "int64", "uint64" » を与えた結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

この reduceL2(input, options) メソッドの手順は次のとおりです:

  1. output を、リダクション演算を作成する 処理に "reduceL2"、input、options、および « "float32", "float16" » を与えた結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

この reduceLogSum(input, options) メソッドの手順は次のとおりです:

  1. output を、リダクション演算を作成する 処理に "reduceLogSum"、input、options、および « "float32", "float16" » を与えた結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

この reduceLogSumExp(input, options) メソッドの手順は次のとおりです:

  1. output を、リダクション演算を作成する 処理に "reduceLogSumExp"、input、options、および « "float32", "float16" » を与えた結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

この reduceMax(input, options) メソッドの手順は次のとおりです:

  1. output を、リダクション演算を作成する 処理に "reduceMax"、input および options を与えた結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

この reduceMean(input, options) メソッドの手順は次のとおりです:

  1. output を、リダクション演算を作成する 処理に "reduceMean"、input、options、および « "float32", "float16" » を与えた結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

この reduceMin(input, options) メソッドの手順は次のとおりです:

  1. output を、リダクション演算を作成する 処理に "reduceMin"、input および options を与えた結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

この reduceProduct(input, options) メソッドの手順は次のとおりです:

  1. output を、リダクション演算を作成する 処理に "reduceProduct"、input、options、および « "float32", "float16", "int32", "uint32", "int64", "uint64" » を与えた結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

この reduceSum(input, options) メソッドの手順は次のとおりです:

  1. output を、リダクション演算を作成する 処理に "reduceSum"、input、options、および « "float32", "float16", "int32", "uint32", "int64", "uint64" » を与えた結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

この reduceSumSquare(input, options) メソッドの手順は次のとおりです:

  1. output を、リダクション演算を作成する 処理に "reduceSumSquare"、input、options、および « "float32", "float16", "int32", "uint32", "int64", "uint64" » を与えた結果とします。

    1. それがエラーをスローした場合、そのエラーを再度スローします。

  2. output を返します。

いくつかのリダクション演算の動作は、他の演算の使用から次のように一般的にエミュレートできます。 ただし、ユーザーエージェントは通常、より効率的な実装を備えています。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function reduceLogSum(builder, input, options) {
  return builder.log(builder.reduceSum(input, options));
}

function reduceLogSumExp(builder, input, options) {
  return builder.log(builder.reduceSum(builder.exp(input), options));
}

function reduceSumSquare(builder, input, options) {
  return builder.reduceSum(builder.pow(input, 2), options);
}
一部の基盤プラットフォームは keepDimensions のようなオプションを直接サポートしていません。これは基盤となるテンソルデータには影響せず、形状のみに影響します。たとえば、入力形状が [2, 3, 4]、軸が 1、かつ keepDimensions が true の場合、期待される出力形状は [2, 1 ,4] です。基盤プラットフォームがリダクションされた 次元を保持しない場合、出力形状は [2, 4] になります。実装は no-op の reshape を [2, 1, 4] に導入できます。同様に、keepDimensions が false であっても、基盤プラットフォームが常にリダクションされた次元を保持する場合、同様の no-op reshape を導入できます。

8.9.40. relu

入力テンソルの整流線形関数を 計算します。 
partial interface MLGraphBuilder {
  MLOperand relu(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits relu;
};
引数:

戻り値:

relu() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16", "int64", "int32", "int8" "float32", "float16" N 0 から 5
output 同じ input "float32", "float16" 同じ input 0 から 5

MLOpSupportLimits には relu() 用の次のメンバーがあります:

relu, 型は MLSingleInputSupportLimits

演算子 relu() のサポート制限。

この relu(input, options) メソッドの 手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. input のdataType がその許可されるデータ型のいずれでもない場合 （この表に従って）、スローします、TypeError を。

  4. グラフの接続を行います:

    1. output を、MLOperand をコピーする処理に input を与えた結果とします。

    2. operator を "relu" 演算用の演算子とし、 options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  5. output を返します。

この演算の動作は、他の演算の使用から次のように一般的にエミュレートできます。 ただし、ユーザーエージェントは通常、より効率的な実装を備えています。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function relu(builder, input) {
  return builder.max(builder.constant(input.dataType, 0), input);
}

8.9.41. resample2d

軸とスケーリング係数に従って、テンソル値をソース次元からデスティネーション次元へリサンプリング します。 
enum MLInterpolationMode {
  "nearest-neighbor",
  "linear"
};

dictionary MLResample2dOptions : MLOperatorOptions {
  MLInterpolationMode mode = "nearest-neighbor";
  sequence<float> scales;
  sequence<[EnforceRange] unsigned long> sizes;
  sequence<[EnforceRange] unsigned long> axes;
};

partial interface MLGraphBuilder {
  MLOperand resample2d(MLOperand input, optional MLResample2dOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits resample2d;
};
引数:

戻り値: MLOperand。 出力 4-D テンソル。

MLResample2dOptions には次のメンバーがあります:

mode, 型は MLInterpolationMode、デフォルトは "nearest-neighbor"

出力テンソルの値を埋めるために使用される補間アルゴリズム。

両方のアルゴリズムは、各空間軸について計算された次の入力から開始します（axes に基づく）。 ここで inputSize は input テンソルの形状によって与えられ、 outputSize は sizes または scales によって与えられ、 outputCoordinate は計算される出力テンソル内の要素を識別します。 

scale = outputSize / inputSize
unclampedCoordinate = (outputCoordinate + 0.5) / scale - 0.5
inputCoordinate = clamp(unclampedCoordinate, 0, inputSize - 1)
出力テンソル内の指定された outputCoordinate.x および outputCoordinate.y の位置について、 上記の式は有理数の inputCoordinate.x および inputCoordinate.y を与えます。
nearest-neighbor

上で計算された inputCoordinate.x および inputCoordinate.y は、 次のように出力テンソル値を計算するため、nearest-neighbor サンプリングアルゴリズムへの入力として 使用されます:

x = ceil(inputCoordinate.x - 0.5)
y = ceil(inputCoordinate.y - 0.5)
output tensor value = input tensor value at (x, y)
linear

上で計算された inputCoordinate.x および inputCoordinate.y は、 次のように出力テンソル値を計算するため、双線形サンプリングアルゴリズムへの入力として使用されます: 

x0 = floor(inputCoordinate.x)
x1 = ceil(inputCoordinate.x)
y0 = floor(inputCoordinate.y)
y1 = ceil(inputCoordinate.y)
vx0y0 = input tensor value at (x0, y0)
vx1y0 = input tensor value at (x1, y0)
vx0y1 = input tensor value at (x0, y1)
vx1y1 = input tensor value at (x1, y1)
tx = inputCoordinate.x - x0
ty = inputCoordinate.y - y0

vy0 = vx0y0 * (1 - tx) + vx1y0 * tx
vy1 = vx0y1 * (1 - tx) + vx1y1 * tx
output tensor value = vy0 * (1 - ty) + vy1 * ty
scales, 型は sequence<float>

長さ 2 のリスト。 axes の各入力次元に対するスケーリング係数を指定します: [scaleForFirstAxis, scaleForSecondAxis]。 デフォルト値は [1.0, 1.0] です。

sizes, 型は sequence<[EnforceRange] unsigned long>

長さ 2 のリスト。 axes の各入力次元に対するターゲットサイズを指定します: [sizeForFirstAxis, sizeForSecondAxis]。sizes が指定されている場合、scales は無視されます。これは、スケーリング係数の値が入力のターゲットサイズから導出されるためです。

axes, 型は sequence<[EnforceRange] unsigned long>

長さ 2 のリスト。 補間アルゴリズムを適用する入力テンソルの 2 つの次元を指定します。 デフォルト値は [2, 3] です。

resample2d() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16", "uint8", "int8" "float32", "float16" 4 4
output 同じ input "float32", "float16" 4 4

MLOpSupportLimits には resample2d() 用の次のメンバーがあります:

resample2d, 型は MLSingleInputSupportLimits

演算子 resample2d() のサポート制限。

この resample2d(input, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. input のdataType がその許可されるデータ型のいずれでもない場合 （この表に従って）、スローします、TypeError を。

  4. input のランクがその許可されるランクでない場合、スローします、TypeError を。

  5. options.scales が存在しない場合、それをリスト « 1.0, 1.0 » に設定します。

  6. それ以外の場合、その項目のいずれかが 0 以下であるか、そのサイズが 2 でない場合、スローします、TypeError を。

  7. options.sizes が存在する場合、そのサイズが 2 でないか、 その項目のいずれかが 0 の場合、スローします、TypeError を。

  8. options.axes が存在しない場合、それをリスト « 2, 3 » に設定します。

  9. それ以外の場合、options.axes に重複値が含まれているか、その項目のいずれかが 範囲 0 から input のランクまで（上限を含まない）にない場合、スローします、TypeError を。

  10. 出力形状を計算します:

    1. inputDescriptor を input.[[descriptor]] とします。

    2. outputShape を inputDescriptor.shape の複製 とします。

    3. 各 index について 範囲 0 から options.axes の サイズまで（上限を含まない）を反復します:

      1. options.sizes が存在する場合、size を options.sizes[index] とします。

      2. それ以外の場合、size を floor(input の形状[options.axes[index]] * options.scales[index]) とします。

      3. size が有効な次元でない場合、スローします、TypeError を。

      4. outputShape[options.axes[index]] を size に設定します。

    4. desc を、MLOperandDescriptor を作成する 処理に inputDescriptor.dataType と outputShape を与えた結果とします。

  11. グラフの接続を行います:

    1. output を、MLOperand を 作成する処理に this と desc を与えた結果とします。

    2. operator を "resample2d" 演算用の演算子とし、 options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  12. output を返します。

具体的なサンプリングアルゴリズムは、既存の機械学習フレームワークで広く使用されているものに基づいています。たとえば、 次の [4, 4] 入力テンソル（空間次元のみを考慮）から linear リサンプリングを実行する場合: 
[   0   1   2   3  ]
[   0   1   2   3  ]
[  12  13  14  15  ]
[  12  13  14  15  ]

[8, 8] 出力テンソルの場合、期待される値は次のとおりです:

[   0   0.25   0.75   1.25   1.75   2.25   2.75   3  ]
[   0   0.25   0.75   1.25   1.75   2.25   2.75   3  ]
[   0   0.25   0.75   1.25   1.75   2.25   2.75   3  ]
[   3   3.25   3.75   4.25   4.75   5.25   5.75   6  ]
[   9   9.25   9.75  10.25  10.75  11.25  11.75  12  ]
[  12  12.25  12.75  13.25  13.75  14.25  14.75  15  ]
[  12  12.25  12.75  13.25  13.75  14.25  14.75  15  ]
[  12  12.25  12.75  13.25  13.75  14.25  14.75  15  ]

これには、サンプリングが均等に分布し、対称であり、画像の ミラーリングに対して堅牢で、隅の値が整列するという便利な特性があります。

8.9.42. reshape

テンソルの形状を新しい形状に変更します。Reshape はテンソルの内容をコピーまたは変更しません。単に 後続の演算に対するテンソルの論理形状を変更します。 
partial interface MLGraphBuilder {
  MLOperand reshape(MLOperand input,
                    sequence<[EnforceRange] unsigned long> newShape,
                    optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits reshape;
};
引数:

戻り値: MLOperand。 出力テンソル。出力 テンソルの値は入力テンソルの値と同じです。出力 テンソルの形状は newShape によって指定されます。

reshape() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32", "int8", "uint8" N 0 から 5
output 同じ input "float32", "float16", "int32", "int8", "uint8" N 0 から 5

MLOpSupportLimits には reshape() 用の次のメンバーがあります:

reshape, 型は MLSingleInputSupportLimits

演算子 reshape() のサポート制限。

この reshape(input, newShape, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. newShape のサイズが出力テンソルの許可されるランクでない場合（この表に従って）、スローします、TypeError を。

  4. outputShape を unsigned long の空の配列とします。

  5. newShape のサイズが 0 の場合、outputShape を空のリスト に設定してスカラーとします。

  6. newShape 内のいずれかの項目が有効な次元でない場合、スローします、TypeError を。

  7. inputElementCount を input の項目すべての積とします、 形状内の。空の次元では inputElementCount は 1 になります。

  8. newShape 内のすべての値の積が inputElementCount と等しくない場合、 スローします、TypeError を。

  9. desc を input.[[descriptor]] のコピーとします。

  10. desc.shape を newShape に設定します。

  11. グラフの接続を行います:

    1. output を、MLOperand を 作成する処理に this と desc を与えた結果とします。

    2. operator を "reshape" 演算用の演算子とし、 options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  12. output を返します。

8.9.43. reverse

指定された軸に沿ってテンソルを反転します。 
dictionary MLReverseOptions : MLOperatorOptions {
  sequence<[EnforceRange] unsigned long> axes;
};

partial interface MLGraphBuilder {
  MLOperand reverse(MLOperand input, optional MLReverseOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits reverse;
};

MLReverseOptions には次のメンバーがあります:

axes, 型は sequence<[EnforceRange] unsigned long>

反転する入力次元のインデックス。このメンバーが存在しない場合、 すべての次元が反転されるものとして扱われます。明示的に空として渡された場合、どの次元も反転されません。

引数:

戻り値:

reverse() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32" N 0 から 5
output 同じ input "float32", "float16", "int32" 同じ input 0 から 5

MLOpSupportLimits には reverse() 用の次のメンバーがあります:

reverse, 型は MLSingleInputSupportLimits

演算子 reverse() のサポート制限。

この reverse(input, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. input のdataType がその許可されるデータ型のいずれでもない場合 （この表に従って）、スローします、TypeError を。

  4. inputRank を input のランクとします。

  5. axes が与えられていない場合、axes を範囲 0 から inputRank まで（上限を含まない）とします。

  6. それ以外の場合、axes に重複値が含まれているか、その要素のいずれかが範囲 0 から inputRank まで（上限を含まない）にない場合、 failure を返します。

  7. グラフの接続を行います:

    1. output を、MLOperand をコピーする処理に input を与えた結果とします。

    2. operator を "reverse" 演算用の演算子とし、 options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  8. output を返します。

8.9.44. scatterElements

indices に従って、updates テンソルの値を入力テンソルのコピー上へ軸に沿って scatter します。 
dictionary MLScatterOptions : MLOperatorOptions {
  [EnforceRange] unsigned long axis = 0;
};

partial interface MLGraphBuilder {
  MLOperand scatterElements(MLOperand input,
                            MLOperand indices,
                            MLOperand updates,
                            optional MLScatterOptions options = {});
};

dictionary MLScatterSupportLimits {
  MLTensorLimits input;
  MLTensorLimits indices;
  MLTensorLimits updates;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLScatterSupportLimits scatterElements;
};

MLScatterOptions には次のメンバーがあります:

axis, 型は unsigned long、デフォルトは 0

scatter された値を取得する軸。その値は [0, N-1] の範囲内でなければならず、 N は入力テンソルのランクです。

引数:

戻り値: MLOperand。 出力 N-D テンソルのランクは input の ランクに等しいです。

scatterElements() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32" 1 から N 1 から 5
indices "int32", "uint32", "int64" "int32" 同じ input 1 から 5
updates 同じ input "float32", "float16", "int32" 同じ input 1 から 5
output 同じ input "float32", "float16", "int32" 同じ input 1 から 5

MLScatterSupportLimits には次のメンバーがあります:

input, 型は MLTensorLimits

MLTensorLimits は input オペランド用です。

indices, 型は MLTensorLimits

MLTensorLimits は indices オペランド用です。

updates, 型は MLTensorLimits

MLTensorLimits は updates オペランド用です。

output, 型は MLTensorLimits

MLTensorLimits は output オペランド用です。

MLOpSupportLimits には scatterElements() 用の次のメンバーがあります:

scatterElements, 型は MLScatterSupportLimits

演算子 scatterElements() のサポート制限。

indices パラメーターを scatterElements() に渡す場合、入力は実行時まで不明であるため、グラフのビルド時に許可範囲へクランプすることはできません。 指定されたクランプ動作が基盤プラットフォームによって提供されない場合、実装は clamp() をコンパイル済みグラフに導入できます。同様に、基盤プラットフォームが負のインデックスをサポートしない場合、実装は 次元の末尾からの負のインデックスを正の インデックスに変換する演算をコンパイル済みグラフに導入できます。
この scatterElements(input, indices, updates, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input、indices、 updates のいずれかで行った結果が false の場合、スローします、TypeError を。

  3. indices のdataType がその許可されるデータ型のいずれでもない場合 （この表に従って）、スローします、TypeError を。

  4. updates のdataType が input のdataType と等しくない場合、スローします、TypeError を。

  5. input、indices、または updates のいずれかのランクが その許可されるランクでない場合、 スローします、TypeError を。

  6. axis を options.axis とします。

  7. axis が input のランク以上の場合、スローします、TypeError を。

  8. indicesShapeExpected を input の形状のコピーとします。

  9. indicesShapeExpected[axis] を indices の形状[axis] に設定します。

  10. indices の形状が indicesShapeExpected と等しくない場合、スローします、TypeError を。

  11. updates の形状が indices の等しくない形状場合、スローします、TypeError を。

  12. グラフの接続を行います:

    1. output を、MLOperand をコピーする処理に input を与えた結果とします。

    2. operator を "scatterElements" 演算用の演算子とし、 input、indices、updates、および options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input、indices、 および updates に設定します。

    5. operator の出力を output に設定します。

  13. output を返します。

異なるスライス方式で scatterElements がどのように動作するかの例。 
// shape [4,3] の input:
//   [[ 0,  1,  2],
//    [10, 11, 12],
//    [20, 21, 22],
//    [30, 31, 32]]
// shape [2,3] の indices:
//   [[3, 1, 1],
//    [2, 0, 3]]
// shape [2,3] の updates:
//   [[-1, -2, -3],
//    [-4, -5, -6]]
// axis = 0 (デフォルト)
// shape [4,3] の output:
//   [[ 0, -5,  2],
//    [10, -2, -3],
//    [-4, 21, 22],
//    [-1, 31, -6]]

const input1 = builder.constant(
  {dataType: 'float32', shape: [4, 3]},
  new Float32Array([0, 1, 2, 10, 11, 12, 20, 21, 22, 30, 31, 32]));

const indices1 = builder.constant(
  {dataType: 'uint32', shape: [2, 3]}, new Uint32Array([3, 1, 1, 2, 0, 3]));

const updates1 = builder.constant(
  {dataType: 'float32', shape: [2, 3]},
  new Uint32Array([-1, -2, -3, -4, -5, -6]));

const output1 = builder.scatterElements(input1, indices1, updates1);

// shape [4,3] の input:
//   [[ 0,  1,  2],
//    [10, 11, 12],
//    [20, 21, 22],
//    [30, 31, 32]]
// shape [4,1] の indices:
//   [[2],
//    [1],
//    [0],
//    [2]],
// shape [4,1] の updates:
//   [[-1],
//    [-2],
//    [-3],
//    [-4]],
// axis = 1
// shape [4,3] の output:
//   [[ 0,  1, -1],
//    [10, -2, 12],
//    [-3, 21, 22],
//    [30, 31, -4]]

const indices2 = builder.constant(
  {dataType: 'uint32', shape: [4, 1]}, new Uint32Array([2, 1, 0, 2]));

const updates2 = builder.constant(
  {dataType: 'float32', shape: [4, 1]}, new Uint32Array([-1, -2, -3, -4]));

const output2 = builder.scatterElements(input1, indices2, updates2, {axis: 1});

// shape [4,2,2] の input:
//   [[[  0,   1],
//     [ 10,  11]],
//    [[100, 101],
//     [110, 111]],
//    [[200, 201],
//     [210, 211]],
//    [[300, 301],
//     [310, 311]],]
// shape [1,2,2] の indices:
//   [[[0, 2],
//     [1, 3]]],
// shape [1,2,2] の updates:
//   [[[-1, -2],
//     [-3, -4]]],
// axis = 0
// shape [4,2,2] の output:
//   [[[ -1,   1],
//     [ 10,  11]],
//    [[100, 101],
//     [ -3, 111]],
//    [[200,  -2],
//     [210, 211]],
//    [[300, 301],
//     [310,  -4]],]

const inputData3 = new Float32Array(
  [0, 1, 10, 11, 100, 101, 110, 111, 200, 201, 210, 211, 300, 301, 310, 311]);

const input3 =
  builder.constant({dataType: 'float32', shape: [4, 2, 2]}, inputData3);

const indices3 = builder.constant(
  {dataType: 'uint32', shape: [1, 2, 2]}, new Uint32Array([0, 2, 1, 3]));

const updates3 = builder.constant(
  {dataType: 'float32', shape: [1, 2, 2]}, new Uint32Array([-1, -2, -3, -4]));

const output3 = builder.scatterElements(input3, indices3, updates3, {axis: 0});

8.9.45. scatterND

indices に従って、updates テンソルの値のスライスを入力テンソルのコピー上に scatter します。 
partial interface MLGraphBuilder {
  MLOperand scatterND(MLOperand input,
                      MLOperand indices,
                      MLOperand updates,
                      optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLScatterSupportLimits scatterND;
};
引数:

戻り値: MLOperand。 出力 N-D テンソルのランクは input の ランク + indices の ランク - indices の shape[-1] - 1 に等しいです。

scatterND() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32" 1 から N 1 から 5
indices "int32", "uint32", "int64" "int32" 1 から N 1 から 5
updates 同じ input "float32", "float16", "int32" N 0 から 5
output 同じ input "float32", "float16", "int32" 1 から N 1 から 5

MLOpSupportLimits には scatterND() 用の次のメンバーがあります:

scatterND, 型は MLScatterSupportLimits

演算子 scatterND() のサポート制限。

indices パラメーターを scatterND() に渡す場合、入力は実行時まで不明であるため、グラフのビルド時に許可範囲へクランプすることはできません。 指定されたクランプ動作が基盤プラットフォームによって提供されない場合、実装は clamp() をコンパイル済みグラフに導入できます。 同様に、基盤プラットフォームが負のインデックスをサポートしない場合、実装は 次元の末尾からの負のインデックスを正の インデックスに変換する演算をコンパイル済みグラフに導入できます。
この scatterND(input, indices, updates, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input、indices、および updates のいずれかで行った結果が false の場合、スローします、TypeError を。

  3. indices のdataType が許可されるデータ型のいずれでもない場合 （この表に従って）、スローします、TypeError を。

  4. updates のdataType が input のdataType と等しくない場合、スローします、TypeError を。

  5. input、indices、または updates のいずれかのランクが、その許可されるランクでない場合、 スローします、TypeError を。

  6. inputShape を input の形状とし、inputRank を input のランクとします。

  7. indicesShape を indices の形状とし、indicesRank を indices のランクとします。

  8. indexableSize を indicesRank - 1 とします。

  9. coordinateSize を indicesShape[indexableSize] とします。

  10. coordinateSize が inputRank より大きい場合、スローします、TypeError を。

  11. expectedUpdatesShape を空のリストとします。

  12. 各 index について 範囲 0 から indexableSize まで（上限を含まない）を反復します:

    1. 追加します indicesShape[index] を expectedUpdatesShape に。

  13. 各 index について 範囲 coordinateSize から inputRank まで（上限を含まない）を反復します:

    1. 追加します inputShape[index] を expectedUpdatesShape に。

  14. updates の形状が expectedUpdatesShape と等しくない場合、スローします、TypeError を。

  15. outputShape を input の形状のコピーとします。

  16. outputDesc を、MLOperandDescriptor を 作成する処理に input のdataType と outputShape を与えた結果とします。

  17. グラフの接続を行います:

    1. output を、MLOperand を 作成する処理に outputDesc を与えた結果とします。

    2. operator を "scatterND" 演算用の演算子とし、 input、indices、updates、および options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input、indices、 および updates に設定します。

    5. operator の出力を output に設定します。

  18. output を返します。

異なるスライス方式で scatterND がどのように動作するかの例。 
// shape [8] の input:
//   [0, 1, 2, 3, 4, 5, 6, 7]
// shape [4, 1] の indices:
//   [[4],
//    [3],
//    [1],
//    [7]]
// shape [4] の updates:
//   [-1, -2, -3, -4]
// shape [8] の output:
//   [0, -3, 2, -2, -1, 5, 6, -4]

const input1 = builder.constant(
  {dataType: 'float32', shape: [8]},
  new Float32Array([0, 1, 2, 3, 4, 5, 6, 7]));

const indices1 = builder.constant(
  {dataType: 'uint32', shape: [4, 1]}, new Uint32Array([4, 3, 1, 7]));

const updates1 = builder.constant(
  {dataType: 'uint32', shape: [4]}, new Uint32Array([-1, -2, -3, -4]));

const output1 = builder.scatterND(input1, indices1, updates1);

// shape [2,2] の input:
//   [[0, 1],
//    [2, 3]]
// shape [2,2] の indices:
//   [[0, 0],
//    [1, 1]]
// shape [2] の updates:
//   [-1, -2]
// shape [2,2] の output:
//   [[-1,  1],   <= -1 を出力座標 [0, 0] に書き込む
//    [ 2, -2]]   <= -2 を出力座標 [1, 1] に書き込む

const input2 = builder.constant(
  {dataType: 'float32', shape: [2, 2]}, new Float32Array([0, 1, 2, 3]));

const indices2 = builder.constant(
  {dataType: 'uint32', shape: [2, 2]}, new Uint32Array([0, 0, 1, 1]));

const updates2 =
  builder.constant({dataType: 'uint32', shape: [2]}, new Uint32Array([-1, -2]));

const output2 = builder.scatterND(input2, indices2, updates2);

// shape [3,2] の input:
//   [[0, 1],
//    [2, 3],
//    [4, 5]]
// shape [2,1] の indices:
//   [[2],
//    [0]]
// shape [2,2] の updates:
//   [[-1, -2],
//    [-3, -4]]
// shape [3,2] の output:
//   [[-3 ,-4],    <= [-3, -4] を出力座標 [0, *] に書き込む
//    [ 2,  3],
//    [-1, -2]]    <= [-1, -2] を出力座標 [2, *] に書き込む

const input3 = builder.constant(
  {dataType: 'float32', shape: [3, 2]}, new Float32Array([0, 1, 2, 3, 4, 5]));

const indices3 = builder.constant(
  {dataType: 'uint32', shape: [2, 1]}, new Uint32Array([1, 0]));

const updates3 = builder.constant(
  {dataType: 'uint32', shape: [2, 2]}, new Uint32Array([-1, -2, -3, 4]));

const output3 = builder.scatterND(input3, indices3, updates3);

// shape [2,2,2] の input:
//   [[[0, 1],
//     [2, 3]],
//    [[4, 5],
//     [6, 7]]]
// shape [2,2] の indices:
//   [[0, 1],
//    [1, 0]]
// shape [2,2] の updates:
//   [[-1, -2],
//    [-3, -4]]
// shape [2,2,2] の output:
//   [[[ 0,  1],
//     [-1, -2]],   <= [-1, -2] を出力座標 [0, 1, *] に書き込む
//    [[-3, -4],    <= [-3, -4] を出力座標 [1, 0, *] に書き込む
//     [ 6,  7]]]

const input4 = builder.constant(
  {dataType: 'float32', shape: [2, 2, 2]},
  new Float32Array([0, 1, 2, 3, 4, 5, 6, 7]));

const indices4 = builder.constant(
  {dataType: 'uint32', shape: [2, 2]}, new Uint32Array([0, 1, 1, 0]));

const updates4 = builder.constant(
  {dataType: 'uint32', shape: [2, 2]}, new Uint32Array([-1, -2, -3, 4]));

const output4 = builder.scatterND(input4, indices4, updates4);

8.9.46. sigmoid

入力テンソルのシグモイド関数を計算します。 計算は式 1 / (exp(-x) + 1) に従います。 
partial interface MLGraphBuilder {
  MLOperand sigmoid(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits sigmoid;
};
引数:

戻り値:

sigmoid() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" N 0 から 5
output 同じ input "float32", "float16" 同じ input 0 から 5

MLOpSupportLimits には sigmoid() 用の次のメンバーがあります:

sigmoid, 型は MLSingleInputSupportLimits

演算子 sigmoid() のサポート制限。

この sigmoid(input, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. input のdataType がその許可されるデータ型のいずれでもない場合 （この表に従って）、スローします、TypeError を。

  4. グラフの接続を行います:

    1. output を、MLOperand をコピーする処理に input を与えた結果とします。

    2. operator を "sigmoid" 演算用の演算子とし、 options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  5. output を返します。

この演算の動作は、他の演算の使用から次のように一般的にエミュレートできます。 ただし、ユーザーエージェントは通常、より効率的な実装を備えています。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function sigmoid(builder, input) {
  return builder.div(
    builder.constant(input.dataType, 1),
    builder.add(
      builder.exp(builder.neg(input)), builder.constant(input.dataType, 1)));
}

8.9.47. slice

入力テンソルのスライスを生成します。 
dictionary MLSliceOptions : MLOperatorOptions {
  sequence<[EnforceRange] unsigned long> strides;
};

partial interface MLGraphBuilder {
  MLOperand slice(MLOperand input,
                  sequence<[EnforceRange] unsigned long> starts,
                  sequence<[EnforceRange] unsigned long> sizes,
                  optional MLSliceOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits slice;
};

MLSliceOptions には次のメンバーがあります:

strides, 型は sequence<[EnforceRange] unsigned long>

各軸に沿って各入力をステップするためのストライド。 strides 配列の長さは入力テンソルのランクと等しくなければなりません。 デフォルトは、すべて 1 からなる長さランクの配列です。 たとえば 3-D テンソルでは [1,1,1] です。 ストライドは 0 より大きくなければなりません。

引数:

戻り値: MLOperand。 入力テンソルと同じランクを持ち、各次元の指定された 開始インデックスと終了インデックスに従ってテンソル値を切り出した出力テンソル。

slice() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32", "int8", "uint8" N 0 から 5
output 同じ input "float32", "float16", "int32", "int8", "uint8" 同じ input 0 から 5

MLOpSupportLimits には slice() 用の次のメンバーがあります:

slice, 型は MLSingleInputSupportLimits

演算子 slice() のサポート制限。

この slice(input, starts, sizes, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. sizes の項目のいずれかが 0 の場合、 スローします、TypeError を。

  4. starts のサイズと sizes のサイズの両方が input のランクと等しくない場合、スローします、TypeError を。

  5. strides を新しいリストとします。

  6. options.strides が存在する場合:

    1. strides を options.strides に設定します。

    2. strides のサイズが input のランクと等しくない場合、スローします、 TypeError を。

  7. inputShape を input の形状とし、inputRank を input のランクとします。

  8. outputShape を新しいリストとします。

  9. 各 index について 範囲 0 から inputRank まで（上限を含まない）を反復します:

    1. inputSize を inputShape[index] とします。

    2. inputSliceSize を sizes[index] とします。

    3. strides[index] が空でない場合はそれを stride とし、それ以外の場合は 1 とします:

    4. inputSliceSize が 0 の場合、スローします、 TypeError を。

      0 サイズの次元が許可される場合、これらの手順を改訂します。[Issue #391]

    5. stride が 1 未満の場合、スローします、 TypeError を。

    6. starts[index] が inputSize より大きい場合、スローします、TypeError を。

    7. starts[index] + inputSliceSize が inputSize より大きい場合、スローします、 TypeError を。

    8. inputSliceSize % stride != 0 の場合は outputSizeRoundingExcess を 1、それ以外の場合は 0 とします。

    9. outputSize を floor(inputSliceSize / stride) + outputSizeRoundingExcess とします:

    10. 追加します outputSize を outputShape に。

  10. outputDesc を、MLOperandDescriptor を 作成する処理に input のdataType と outputShape を与えた結果とします。

  11. グラフの接続を行います:

    1. output を、MLOperand を 作成する処理に outputDesc を与えた結果とします。

    2. operator を "slice" 演算用の演算子とし、 starts、sizes、および options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  12. output を返します。

8.9.48. softmax

指定された軸に沿って N-D 入力テンソルのsoftmax 値を 計算します。 
partial interface MLGraphBuilder {
  MLOperand softmax(MLOperand input,
                    [EnforceRange] unsigned long axis,
                    optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits softmax;
};
引数:

戻り値:

softmax() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" 1 から N 1 から 5
output 同じ input "float32", "float16" 同じ input 1 から 5

MLOpSupportLimits には softmax() 用の次のメンバーがあります:

softmax, 型は MLSingleInputSupportLimits

演算子 softmax() のサポート制限。

この softmax(input, axis, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. input のdataType がその許可されるデータ型のいずれでもない場合 （この表に従って）、スローします、TypeError を。

  4. axis が input のランク以上の場合、スローします、TypeError を。

  5. グラフの接続を行います:

    1. output を、MLOperand をコピーする処理に input を与えた結果とします。

    2. operator を "softmax" 演算用の演算子とし、 axis および options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  6. output を返します。

この演算の動作は、他の演算の使用から次のように一般的にエミュレートできます。 ただし、ユーザーエージェントは通常、より効率的な実装を備えています。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function softmax(builder, input, axis) {
  // このサンプルでは、数値的安定性を高めるため、入力値自体の指数ではなく、
  // 最大値までの距離の指数を計算する、よく知られた実装上の工夫 [1] を
  // 使用します。
  // 結果の数値的安定性を向上させます。
  // [1]: https://cs231n.github.io/linear-classify/#softmax
  const maxX = builder.reduceMax(input, {axes: [axis], keepDimensions: true});
  const expX = builder.exp(builder.sub(input, maxX));
  return builder.div(
    expX, builder.reduceSum(expX, {axes: [axis], keepDimensions: true}));
}

8.9.49. softplus

入力テンソルのsoftplus 関数 を計算します。計算は式 ln(1 + exp(x)) に従います。 
partial interface MLGraphBuilder {
  MLOperand softplus(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits softplus;
};
引数:

戻り値:

softplus() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" N 0 から 5
output 同じ input "float32", "float16" 同じ input 0 から 5

MLOpSupportLimits には softplus() 用の次のメンバーがあります:

softplus, 型は MLSingleInputSupportLimits

演算子 softplus() のサポート制限。

この softplus(input, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. input のdataType がその許可されるデータ型のいずれでもない場合 （この表に従って）、スローします、TypeError を。

  4. グラフの接続を行います:

    1. output を、MLOperand をコピーする処理に input を与えた結果とします。

    2. operator を "softplus" 演算用の演算子とし、 options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  5. output を返します。

この演算の動作は、他の演算の使用から次のように一般的にエミュレートできます。 ただし、ユーザーエージェントは通常、より効率的な実装を備えています。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function softplus(builder, input) {
  return builder.log(
    builder.add(builder.exp(input), builder.constant(input.dataType, 1)));
}

8.9.50. softsign

入力テンソルのsoftsign 関数を 計算します。計算は式 x / (1 + |x|) に従います。 
partial interface MLGraphBuilder {
  MLOperand softsign(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits softsign;
};
この演算の動作は、他の演算の使用から次のように一般的にエミュレートできます。 ただし、ユーザーエージェントは通常、より効率的な実装を備えています。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function softsign(builder, input) {
  return builder.div(
    input,
    builder.add(builder.constant(input.dataType, 1), builder.abs(input)));
}
引数:

戻り値:

softsign() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" N 0 から 5
output 同じ input "float32", "float16" 同じ input 0 から 5

MLOpSupportLimits には softsign() 用の次のメンバーがあります:

softsign, 型は MLSingleInputSupportLimits

演算子 softsign() のサポート制限。

この softsign(input, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. input のdataType がその許可されるデータ型のいずれでもない場合 （この表に従って）、スローします、TypeError を。

  4. グラフの接続を行います:

    1. output を、MLOperand をコピーする処理に input を与えた結果とします。

    2. operator を "softsign" 演算用の演算子とし、 options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  5. output を返します。

8.9.51. split

指定された軸に沿って入力テンソルを複数のサブテンソルに分割します。 
dictionary MLSplitOptions : MLOperatorOptions {
  [EnforceRange] unsigned long axis = 0;
};

partial interface MLGraphBuilder {
  sequence<MLOperand> split(
      MLOperand input,
      ([EnforceRange] unsigned long or sequence<[EnforceRange] unsigned long>) splits,
      optional MLSplitOptions options = {});
};

dictionary MLSplitSupportLimits {
  MLTensorLimits input;
  MLTensorLimits outputs;
};

partial dictionary MLOpSupportLimits {
  MLSplitSupportLimits split;
};
引数:

戻り値: sequence<MLOperand>。 分割された出力テンソル。splits が unsigned long の場合、 出力のサイズは splits と等しくなります。 各出力テンソルの形状は input と同じですが、 axis の次元サイズは input の axis に沿った次元サイズを splits で割った商と等しくなります。 splits が sequence<unsigned long> の場合、 出力のサイズは splits のサイズと等しくなります。 i 番目の出力テンソルの形状は input と同じですが、 axis に沿っては 次元サイズが splits[i] です。

MLSplitOptions には次のメンバーがあります:

axis, 型は unsigned long、デフォルトは 0

分割する次元。その値は [0, N-1] の範囲内でなければならず、N は入力 テンソルのランクです。

split() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32" 1 から N 1 から 5
outputs 同じ input "float32", "float16", "int32" 同じ input 1 から 5

MLSplitSupportLimits には次のメンバーがあります:

input, 型は MLTensorLimits

MLTensorLimits は input オペランド用です。

outputs, 型は MLTensorLimits

MLTensorLimits はすべての出力オペランド用です。

MLOpSupportLimits には split() 用の次のメンバーがあります:

split, 型は MLSplitSupportLimits

演算子 split() のサポート制限。

この split(input, splits, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. axis を options.axis とします。

  4. axis が input のランク以上の場合、スローします、TypeError を。

  5. splits が unsigned long の場合:

    1. splits が有効なテンソル数でない場合、スローします、TypeError を。

    2. input の形状[axis] % splits が 0 でない場合、スローします、TypeError を。

    3. それ以外の場合、splitCount を splits とします。

  6. splits がsequence<unsigned long> の場合:

    1. splits のサイズが 有効なテンソル数でない場合、スローします、TypeError を。

    2. その項目のいずれかが 0 と等しい場合、スローします、 TypeError を。

      0 サイズの次元が許可される場合、上記の手順を改訂します。[Issue #391]

    3. その項目の合計が input の形状[axis] と等しくない場合、スローします、TypeError を。

    4. それ以外の場合、splitCount を splits のサイズとします。

  7. グラフの接続を行います:

    1. operator を "split" 演算用の演算子とし、 splits および options を与えます。

    2. outputs を新しいリストとします。

    3. 各 index について 範囲 0 から splitCount まで（上限を含まない）を反復します:

      1. operand を、MLOperand を コピーする処理に input を与えた結果とします。

      2. splits が unsigned long の場合、newDimension を operand の形状[axis] / splits とします。

      3. それ以外の場合、newDimension を splits[index] とします。

      4. operand の形状[axis] を newDimension に設定します。

      5. operand.[[operator]] を operator に設定します。

      6. 追加します operand を outputs に。

    4. operator の入力を input に設定します。

    5. operator の出力を outputs に設定します。

  8. outputs を返します。

この演算の動作は、他の演算の使用から次のように一般的にエミュレートできます。 ただし、ユーザーエージェントは通常、より効率的な実装を備えています。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function split(builder, input, splits, options) {
  // このサンプルでは、splits パラメーターが配列である場合を示します。
  const outputs = [];
  const inputShape = input.shape;
  const inputRank = inputShape.length;
  let starts = Array(inputRank).fill(0);
  let sizes = inputShape;
  let start = 0;
  for (const size of splits) {
    starts[options.axis] = start;
    sizes[options.axis] = size;
    outputs.push(builder.slice(input, starts, sizes));
    start += size;
  }
  return outputs;
}

8.9.52. tanh

入力テンソルの双曲線正接関数を 計算します。計算は式 (exp(2 * x) - 1) / (exp(2 * x) + 1) に従います。 
partial interface MLGraphBuilder {
  MLOperand tanh(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits tanh;
};
引数:

戻り値:

tanh() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input "float32", "float16" "float32", "float16" N 0 から 5
output 同じ input "float32", "float16" 同じ input 0 から 5

MLOpSupportLimits には tanh() 用の次のメンバーがあります:

tanh, 型は MLSingleInputSupportLimits

演算子 tanh() のサポート制限。

この tanh(input, options) メソッドの 手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. input のdataType がその許可されるデータ型のいずれでもない場合 （この表に従って）、スローします、TypeError を。

  4. グラフの接続を行います:

    1. output を、MLOperand をコピーする処理に input を与えた結果とします。

    2. operator を "tanh" 演算用の演算子とし、 options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  5. output を返します。

この演算の動作は、他の演算の使用から次のように一般的にエミュレートできます。 ただし、ユーザーエージェントは通常、より効率的な実装を備えています。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function tanh(builder, input) {
  return builder.div(
    builder.sub(
      builder.exp(builder.mul(builder.constant(input.dataType, 2), input)),
      builder.constant(input.dataType, 1)),
    builder.add(
      builder.exp(builder.mul(builder.constant(input.dataType, 2), input)),
      builder.constant(input.dataType, 1)));
}

8.9.53. tile

各次元に沿って、指定された回数だけテンソルを繰り返します。 
partial interface MLGraphBuilder {
  MLOperand tile(MLOperand input,
                 sequence<unsigned long> repetitions,
                 optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits tile;
};
引数:

戻り値: MLOperand。 反転された N-D テンソル。

tile() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32" N 0 から 5
output 同じ input "float32", "float16", "int32" 同じ input 0 から 5

MLOpSupportLimits には tile() 用の次のメンバーがあります:

tile, 型は MLSingleInputSupportLimits

演算子 tile() のサポート制限。

この tile(input, repetitions, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. repetitions のサイズが input のランクと等しくない場合、スローします、TypeError を。

  4. repetitions の値に 0 が含まれている場合、スローします、TypeError を。

    0 サイズの 次元が許可される場合、これらの手順を改訂します。[Issue #391]

  5. outputShape を input の形状のコピーとします。

  6. 各 index について 範囲 0 から outputShape のサイズまで（上限を含まない）を反復します:

    1. outputShape[index] を outputShape[index] * repetitions[index] に設定します。

  7. outputDescriptor を、MLOperandDescriptor を 作成する処理に input のdataType と outputShape を与えた結果とします。

  8. グラフの接続を行います:

    1. output を、MLOperand を 作成する処理に outputDescriptor を与えた結果とします。

    2. operator を "tile" 演算用の演算子とし、 options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  9. output を返します。

8.9.54. transpose

permutation に従って入力テンソルの次元を並べ替えます。 
dictionary MLTransposeOptions : MLOperatorOptions {
  sequence<[EnforceRange] unsigned long> permutation;
};

partial interface MLGraphBuilder {
  MLOperand transpose(MLOperand input, optional MLTransposeOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits transpose;
};

MLTransposeOptions には次のメンバーがあります:

permutation, 型は sequence<[EnforceRange] unsigned long>

出力形状の並べ替えに使用される値。 デフォルトは [N-1, ..., 0] です。ここで N は入力テンソルのランクで、たとえば 3-D テンソルでは [2,1,0] です。 これらのデフォルト値により、出力は入力を転置したテンソルになります。指定する場合、 値の数は入力テンソルのランクと同じでなければならず、値は重複なく 0 から N-1 の範囲内でなければなりません。

引数:

戻り値: MLOperand。 並べ替えまたは転置された N-D テンソル。

transpose() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16", "int32" N 0 から 5
output 同じ input "float32", "float16", "int32" 同じ input 0 から 5

MLOpSupportLimits には transpose() 用の次のメンバーがあります:

transpose, 型は MLSingleInputSupportLimits

演算子 transpose() のサポート制限。

この transpose(input, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. options.permutation が存在しない場合、options.permutation を input の形状のすべてのインデックスを逆順にしたシーケンスとします。

  4. それ以外の場合、options.permutation が存在する場合:

    1. そのサイズが input のランクと等しくない場合、 スローします、TypeError を。

    2. その項目が範囲 0 から input のランクまで（上限を含まない）にない場合、スローします、 TypeError を。

    3. 重複値が含まれている場合、スローします、 TypeError を。

  5. グラフの接続を行います:

    1. output を、MLOperand をコピーする処理に input を与えた結果とします。

    2. operator を "transpose" 演算用の演算子とし、 options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  6. output を返します。

8.9.55. triangular

2-D テンソル（行列）が与えられた場合、入力テンソルの上三角部分または下三角部分のいずれかを含む 2-D テンソルを返します。入力テンソルが 2 より多い次元を持つ場合、それは行列のバッチとして扱われ、 結果は同じ形状を持ちます。 
dictionary MLTriangularOptions : MLOperatorOptions {
  boolean upper = true;
  [EnforceRange] long diagonal = 0;
};

partial interface MLGraphBuilder {
  MLOperand triangular(MLOperand input, optional MLTriangularOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits triangular;
};

MLTriangularOptions には次のメンバーがあります:

upper, 型は boolean、デフォルトは true

入力行列の上部または下部のどちらを出力に保持するかを示します。true は上部を保持することを示します。

diagonal, 型は long、デフォルトは 0

入力行列の主対角線より上または下の対角線を何本保持または 除外するかを指定します。値 0 は、主対角線以外の対角線には影響しないことを意味します。

引数:

戻り値: MLOperand。 三角行列、または入力と同じ形状を持つ行列のバッチを表す 出力テンソル。

triangular() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
input 任意 "float32", "float16" 2 から N 2 から 5
output 同じ input "float32", "float16" 同じ input 2 から 5

MLOpSupportLimits には triangular() 用の次のメンバーがあります:

triangular, 型は MLSingleInputSupportLimits

演算子 triangular() のサポート制限。

この triangular(input, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と input で行った結果が false の場合、スローします、TypeError を。

  3. input のランクがその許可されるランクのいずれでもない場合（この表に従って）、スローします、TypeError を。

  4. グラフの接続を行います:

    1. output を、MLOperand をコピーする処理に input を与えた結果とします。

    2. operator を "triangular" 演算用の演算子とし、 options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を input に設定します。

    5. operator の出力を output に設定します。

  5. output を返します。

異なる diagonal 設定で triangular がどのように動作するかの例。 
// input:
//   [[7, 1, 2],
//    [9, 4, 8],
//    [2, 6, 3]]
const input = builder.constant(
  {dataType: 'float32', shape: [3, 3]},
  new Float32Array([7, 1, 2, 9, 4, 8, 2, 6, 3]));

// 上三角行列:
//   [[7, 1, 2],
//    [0, 4, 8],
//    [0, 0, 3]]
const upper = builder.triangular(input);

// 追加の 1 組の対角線を除外した上三角行列:
//   [[0, 1, 2],
//    [0, 0, 8],
//    [0, 0, 0]]
const upperPositive = builder.triangular(input, {diagonal: 1});

// 追加の 1 組の対角線を保持した上三角行列:
//   [[7, 1, 2],
//    [9, 4, 8],
//    [0, 6, 3]]
const upperNegative = builder.triangular(input, {diagonal: -1});

// 下三角行列:
//   [[7, 0, 0],
//    [9, 4, 0],
//    [2, 6, 3]]
const lower = builder.triangular(input, {upper: false});

// 追加の 1 組の対角線を保持した下三角行列:
//   [[7, 1, 0],
//    [9, 4, 8],
//    [2, 6, 3]]
const lowerPositive = builder.triangular(input, {upper: false, diagonal: 1});

// 追加の 1 組の対角線を除外した下三角行列:
//   [[0, 0, 0],
//    [9, 0, 0],
//    [2, 6, 0]]
const lowerNegative = builder.triangular(input, {upper: false, diagonal: -1})

// 2 つのバッチを持つ下三角行列:
//   [[[7, 0, 0],
//     [9, 4, 0],
//     [2, 6, 3]],
//    [[1, 0, 0],
//     [4, 5, 0],
//     [7, 8, 9]]]
const lowerWithBatches = builder.triangular(input, {upper: false});

8.9.56. where

trueValue または falseValue テンソルから、condition テンソルの対応する値に応じて値を選択します。ここで非ゼロは true、ゼロは false です。condition テンソルは多くの場合、要素単位の論理演算のいずれかの出力です。

この演算は、[numpy-broadcasting-rule] に従ってブロードキャスト されます。入力テンソルは双方向にブロードキャスト可能でなければなりません。出力テンソルのランク は入力テンソルの最大ランクです。 出力テンソルの各次元について、そのサイズは入力テンソルのその次元に沿った最大サイズです。

partial interface MLGraphBuilder {
  MLOperand where(MLOperand condition,
                  MLOperand trueValue,
                  MLOperand falseValue,
                  optional MLOperatorOptions options = {});
};

dictionary MLWhereSupportLimits {
  MLTensorLimits condition;
  MLTensorLimits trueValue;
  MLTensorLimits falseValue;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLWhereSupportLimits where;
};
引数:

戻り値: MLOperand。 trueValue または falseValue テンソルのいずれかから要素単位で選択された値を含む出力テンソル。

where() のテンソル制限
オペランド 許可される データ型 必須 データ型 許可されるランク 必須ランク
condition "uint8" "uint8" N 0 から 5
trueValue 任意 "float32", "float16", "int32" N 0 から 5
falseValue 同じ trueValue "float32", "float16", "int32" N 0 から 5
output 同じ trueValue "float32", "float16", "int32" N 0 から 5

MLWhereSupportLimits には次のメンバーがあります:

condition, 型は MLTensorLimits

MLTensorLimits は condition オペランド用です。

trueValue, 型は MLTensorLimits

MLTensorLimits は trueValue オペランド用です。

falseValue, 型は MLTensorLimits

MLTensorLimits は falseValue オペランド用です。

output, 型は MLTensorLimits

MLTensorLimits は output オペランド用です。

MLOpSupportLimits には where() 用の次のメンバーがあります:

where, 型は MLWhereSupportLimits

演算子 where() のサポート制限。

この where(condition, trueValue, falseValue, options) メソッドの手順は次のとおりです:

  1. this がビルドできない場合、スローします、 "InvalidStateError" DOMException を。

  2. オペランドを検証する処理を this と condition、trueValue、および falseValue のいずれかで行った結果が false の場合、スローします、TypeError を。

  3. condition、 trueValue、または falseValue のいずれかのdataType がその許可されるデータ型のいずれでもない場合 （この表に従って）、スローします、TypeError を。

  4. outputShape を、双方向にブロードキャストする trueValue の形状と falseValue の形状の結果とします。

    1. それが failure を返した場合、スローします、 TypeError を。

  5. outputShape を、双方向にブロードキャストする condition の形状と outputShape の結果に設定します。

    1. それが failure を返した場合、スローします、 TypeError を。

  6. descriptor を、MLOperandDescriptor を 作成する処理に trueValue のdataType と outputShape を与えた結果とします。

  7. グラフの接続を行います:

    1. output を、MLOperand を 作成する処理に this と descriptor を与えた結果とします。

    2. operator を "where" 演算用の演算子とし、 condition、trueValue、falseValue、および options を与えます。

    3. output.[[operator]] を operator に設定します。

    4. operator の入力を condition、 trueValue および falseValue に設定します。

    5. operator の出力を output に設定します。

  8. output を返します。

この演算の動作は、他の演算の使用から次のように一般的にエミュレートできます。 ただし、ユーザーエージェントは通常、より効率的な実装を備えています。基盤となる プラットフォームが演算を直接サポートしていない場合、この分解を 実装の指針となるテンプレートとして使用できます。 
function where(builder, condition, trueValue, falseValue) {
  const c = builder.clamp(condition, {'minValue': 0, 'maxValue': 1});
  builder.add(
    builder.mul(trueValue, builder.cast(c, trueValue.dataType)),
    builder.mul(
      falseValue, builder.cast(builder.logicalNot(c), falseValue.dataType)));
}

9. アルゴリズム

9.1. ブロードキャスト

ブロードキャストは、 WebNN がグラフ構築および計算中に異なる形状のテンソルをどのように扱うかを説明します。これは [NumPy] の影響を強く受け、[numpy-broadcasting-rule] に従います。大まかに言えば、より小さいテンソルに対する 演算をより大きいテンソルの形状全体に「ブロードキャスト」できるようにし、同じ データをコピーせずに繰り返し適用できるようにします。

最も単純な例は、add() や mul() のような要素単位の 二項演算を使用して、スカラー定数を N 次元テンソルに適用することです。 スカラー定数の複数のコピーを含む一致する N 次元テンソルを割り当てて値を設定する必要はなく、 これらの要素単位演算ではスカラー定数を直接使用し、 N 次元テンソル全体にスカラー値をブロードキャストできます。以下の考慮事項により、同じ ロジックが他の次元のテンソルにも適用されます。

入力テンソルの形状は互換でなければなりません。あるテンソルは、最初のテンソルを 最後（最右）の次元から開始して、サイズ 1 の軸に沿って繰り返すか、新しい次元にわたって繰り返すことで「引き伸ばせる」場合、別のテンソルへ単方向に ブロードキャスト可能です。 たとえば、[4] テンソルは 5 回繰り返すことで [5, 4] テンソルへブロードキャストできます。 [1] テンソルは、最後の次元で 4 回、前の次元で 5 回繰り返すことで [5,4] テンソルへ ブロードキャストできます。単方向ブロードキャストは、expand() のようにターゲットテンソルの形状が明示的に与えられる演算で重要です。

2 つのテンソルは、最後の次元から開始してさまざまな次元にわたり相互に 「引き伸ばす」（繰り返す）ことができる場合、双方向にブロードキャスト可能です。たとえば、 [5,1] テンソルは、最初のテンソルを最後の次元で 6 回、2 番目のテンソルを前の次元で 5 回 繰り返すことにより、[1,6] テンソルと双方向にブロードキャストできます。演算結果は [5,6] テンソルになります。双方向ブロードキャストは要素単位の 演算に便利です。

テンソルは、すべての次元を整数倍でターゲットテンソルの形状までアップサンプリングできる場合、ブロック単位でブロードキャスト可能です。たとえば、[4,5] テンソルは、 正確な倍数（16 % 4 = 0、10 % 5 = 0）であるため、第 1 次元の各要素を 4 回、最後の次元の各要素を 2 回繰り返すことで [16,10] テンソルまでブロック単位でブロードキャストできます（たとえば、最後の次元の値 [1,2,3,4,5] は [1,1,2,2,3,3,4,4,5,5] に繰り返されます）。しかし、 [4,5] テンソルは、両方の次元で余りが 0 でないため（9 % 4 = 1、3 % 5 = 3）、 [9,3] テンソルとは互換ではありません。ブロック単位ブロードキャストは、 メモリを節約するために大きなブロック内で共通値を共有するのに役立ちます。両方のテンソルは同じランクを持つことが期待され、 出力形状は単に、小さい方がアップサンプリングされるターゲットテンソルの形状です。

一部の演算では、特別な意味を持つブロードキャストが許可されます。たとえば、matmul() は入力テンソルの最後の 2 次元を行列の行と列として扱い、第 1 行列の列数は 第 2 行列の行数と等しくなければなりません。行列 乗算は追加の次元にわたって双方向にブロードキャストされ、入力テンソルを 乗算する行列のスタックとして扱います。

形状を単方向にブロードキャストするには、shapeFrom および shapeTo について次の手順を実行します。shapeFrom と shapeTo は、 テンソルの次元を表す正の整数のリストであり、 この手順は正の整数の新しいリスト、 または failure を返します。

  1. sizeFrom を shapeFrom のサイズとします。

  2. sizeTo を shapeTo のサイズとします。

  3. sizeFrom > sizeTo の場合、failure を返します。

  4. paddedShapeFrom を shapeFrom の複製とします。

  5. paddedShapeFrom のサイズが sizeTo 未満である間、1 を paddedShapeFrom に先頭追加します。

  6. outputShape を新しいリストとします。

  7. 各 index について 範囲 0 から sizeTo まで（上限を含まない）を反復します:

    1. dimFrom を paddedShapeFrom[index] とします。

    2. dimTo を shapeTo[index] とします。

    3. dimTo が dimFrom と等しくなく、かつ dimFrom が 1 と等しくない場合、failure を返します。

    4. 追加します dimTo を outputShape に。

  8. outputShape を返します。

shapeFrom は shapeTo に単方向にブロードキャスト可能です。これは、shapeFrom と shapeTo を単方向にブロードキャストする処理が failure にならない場合です。

形状を双方向にブロードキャストするには、shapeA および shapeB について次の手順を実行します。shapeA と shapeB は、 テンソルの次元を表す正の整数のリストであり、 この手順は正の整数の新しいリスト、 または failure を返します。

  1. sizeA を shapeA のサイズとします。

  2. sizeB を shapeB のサイズとします。

  3. outputSize を sizeA と sizeB の最大値とします。

  4. paddedA を shapeA の複製とします。

  5. paddedA のサイズが outputSize 未満である間、1 を paddedA に先頭追加します。

  6. paddedB を shapeB の複製とします。

  7. paddedB のサイズが outputSize 未満である間、1 を paddedB に先頭追加します。

  8. outputShape を新しいリストとします。

  9. 各 index について 範囲 0 から outputSize まで（上限を含まない）を反復します:

    1. dimA を paddedA[index] とします。

    2. dimB を paddedB[index] とします。

    3. dimA が dimB と等しくなく、かつ dimA が 1 と等しくなく、かつ dimB が 1 と等しくない場合、failure を返します。

    4. 追加します dimA と dimB の最大値を outputShape に。

  10. outputShape を返します。

shapeA は shapeB に双方向にブロードキャスト可能です。これは、shapeA と shapeB を双方向にブロードキャストする処理が failure にならない場合です。

形状をブロック単位でブロードキャストするには、shapeFrom および shapeTo について次の手順を実行します。shapeFrom と shapeTo は、 テンソルの次元を表す正の整数のリストであり、 この手順は true または false を返します。

  1. shapeFrom のサイズが shapeTo のサイズと等しくない場合、false を返します。

  2. 各 index について 範囲 0 から shapeTo のサイズまで（上限を含まない）を反復します:

    1. shapeTo[index] が shapeFrom[index] で正確に割り切れない場合、false を返します。

  3. true を返します。

shapeFrom は shapeTo にブロック単位でブロードキャスト可能です。これは、shapeFrom と shapeTo をブロック単位で ブロードキャストする処理が true を返す場合です。

9.2. キャスト

明示的な数値キャストは、MLNumber または double として渡されたパラメーターを、入力または出力 MLOperandDataType の MLOperand に一致するよう変換する必要があるアルゴリズムで使用されます。

数値 x を指定された MLOperandDataType dataType にキャストするには、 次の手順を実行します。これらは数値を返します。

  1. dataType に応じて分岐します:

    "float32"

    ConvertToFloat(x, 32) を返します。

    "float16"

    ConvertToFloat(x, 16) を返します。

    "int64"

    ConvertToInt(x, 64, "signed") を返します。

    "uint64"

    ConvertToInt(x, 64, "unsigned") を返します。

    "int32"

    ConvertToInt(x, 32, "signed") を返します。

    "uint32"

    ConvertToInt(x, 32, "signed") を返します。

    "int8"

    ConvertToInt(x, 8, "signed") を返します。

    "uint8"

    ConvertToInt(x, 8, "unsigned") を返します。

注: キャストへの入力は、Infinity、-Infinity、NaN という特殊値を含む、 範囲と精度に制限のない抽象数です。出力も抽象数ですが、 指定された型で正確に表現可能です。

ConvertToFloat(x, bitLength) の手順は次のとおりです:

  1. x が NaN の場合、NaN を返します。

  2. bitLength に応じて分岐します:

    32

    1. upperBound を 2128 とします。

    2. lowerBound を -2128 とします。

    3. S を [IEEE-754-2019] binary32 浮動小数点値の集合（-0 を除く）とし、特殊値 upperBound および lowerBound を追加します。

    16

    1. upperBound を 216 とします。

    2. lowerBound を -216 とします。

    3. S を [IEEE-754-2019] binary16 浮動小数点値の集合（-0 を除く）とし、特殊値 upperBound および lowerBound を追加します。

  3. y を S 内で x に最も近い数とし、2 つの等距離の値がある場合は、 仮数部が偶数の数を選択します。この目的では、2 つの特殊値 lowerBound および upperBound は偶数の仮数部を持つものとみなします。

  4. y が upperBound の場合、+Infinity を返します。

  5. y が lowerBound の場合、-Infinity を返します。

  6. y が +0 で、x が負の場合、-0 を返します。

  7. y を返します。

注: これは [WEBIDL] の定義に基づきますが、 16-bit 浮動小数点値を対象に含めるよう拡張されています。

ConvertToInt(x, bitLength, signedness) の手順は次のとおりです:

  1. signedness が "unsigned" の場合:

    1. lowerBound を 0 とします。

    2. upperBound を 2bitLength - 1 とします。

  2. それ以外の場合:

    1. lowerBound を -(2bitLength - 1) とします。

    2. upperBound を 2bitLength - 1 - 1 とします。

  3. x が -0 の場合、x を +0 に設定します。

  4. x が NaN の場合、+0 を返します。

  5. x を min(max(x, lowerBound), upperBound) に設定します。

  6. x を最も近い整数に丸め、2 つの整数のちょうど中間にある場合は偶数の整数を選び、 -0 ではなく +0 を選びます。

  7. x を返します。

注: これは [WEBIDL] の定義に基づきますが、次の 相違点があります: 64-bit 整数を特別扱いせず、入力 x は抽象 数であり、クランプは常に実行されます。

9.3. その他

リスト A は、A のサイズが B の サイズと等しく、 A 内の各項目が B 内の同じインデックスにある項目と等しい場合、リスト B と等しいです。

[INFRA] に定義が 利用可能になったら、これを削除します。[whatwg/infra Issue #664]

10. 例

次のビルドグラフが与えられた場合: 
constant1 ---+
             +--- Add ---> intermediateOutput1 ---+
input1    ---+                                    |
                                                  +--- Mul---> output
constant2 ---+                                    |
             +--- Add ---> intermediateOutput2 ---+
input2    ---+
次のコードはこのグラフを実装します: 
// 4 次元のテンソルを使用します。
const TENSOR_SHAPE = [1, 2, 2, 2];
const TENSOR_SIZE = 8;

const context = await navigator.ml.createContext();
const builder = new MLGraphBuilder(context);

// MLOperandDescriptor オブジェクトを作成します。
const desc = {
  dataType: 'float32',
  shape: TENSOR_SHAPE
};

// constant1 は値 0.5 を持つ定数 MLOperand です。
const constantBuffer1 = new Float32Array(TENSOR_SIZE).fill(0.5);
const constant1 = builder.constant(desc, constantBuffer1);

// input1 は入力 MLOperand の 1 つです。その値は
// 実行前に設定されます。
const input1 = builder.input('input1', desc);

// constant2 は値 0.5 を持つ別の定数 MLOperand です。
const constantBuffer2 = new Float32Array(TENSOR_SIZE).fill(0.5);
const constant2 = builder.constant(desc, constantBuffer2);

// input2 は別の入力 MLOperand です。その値は実行前に設定されます。
const input2 = builder.input('input2', desc);

// intermediateOutput1 は最初の Add 演算の出力です。
const intermediateOutput1 = builder.add(constant1, input1);

// intermediateOutput2 は 2 番目の Add 演算の出力です。
const intermediateOutput2 = builder.add(constant2, input2);

// output は Mul 演算の出力 MLOperand です。
const output = builder.mul(intermediateOutput1, intermediateOutput2);

11. 演算子のエミュレーション

このセクションは非規範的です。

他のニューラルネットワーク推論 API に存在する演算は、多くの場合、WebNN に存在する演算を使用して エミュレートできます。

11.1. squeeze

squeeze 演算は、 入力の指定されたサイズ 1 のすべての次元を削除したテンソルを返します。これは reshape() 演算を使用して次のように一般的に実装できます: 
function squeeze(builder, input, axes) {
  if (!axes)
    axes = [];
  if (!axes.length)
    input.shape.forEach((item, i) => {
      axes.push(i);
    });
  const shape = Array.from(input.shape);
  for (let axis of axes.sort().reverse())
    if (axis < shape.length && shape[axis] == 1)
      shape.splice(axis, 1);
  return builder.reshape(input, shape);
}

11.2. unsqueeze

unsqueeze 演算は、 指定された位置にサイズ 1 の次元を挿入した新しいテンソルを返します。これは reshape() 演算を使用して次のように一般的に実装できます: 
function unsqueeze(builder, input, axes) {
  const shape = Array.from(input.shape);
  for (let axis of axes.sort())
    shape.splice(axis, 0, 1);
  return builder.reshape(input, shape);
}

11.3. flatten

flatten 演算は、 入力を 1 次元テンソルに reshape します。これは reshape() 演算を使用して次のように一般的に実装できます: 
function flatten(builder, input, axis) {
  if (axis > input.shape.length)
    return input;
  const before = axis.slice(0, axis).reduce((a, b) => a * b, 1);
  const after = axis.slice(axis, input.shape.length).reduce((a, b) => a * b, 1);
  return builder.reshape(input, [before, after]);
}

12. 付録

12.1. MLOperandDataType と ArrayBufferView の互換性

MLOperandDataType ArrayBufferView
float32 Float32Array
float16 Float16Array
int64 BigInt64Array
uint64 BigUint64Array
int32 Int32Array
uint32 Uint32Array
int8 Int8Array
uint8 Uint8Array

Float16Array は、その設計が完了していることを示す ECMA Stage 3 にあります。 ネイティブ実装に先行してこの型を有効にしたい実装者は、生の ビットを Uint16Array 経由で渡すことでこの型をエミュレートできます。 [Issue webnn#373]

13. 謝辞

この仕様は Android Neural Networks API C API の概念に従っています。

ユースケースについて、Tomoyuki Shimizu、Ningxin Hu、Zhiqiang Yu、Belem Zhang に 感謝します。

API 仕様への貢献について、Nikhil Thorat、Daniel Smilkov、Ganesan Ramalingam、Rafael Cintron、 Benjamin Poulain に感謝します。

この仕様について、Web アーキテクチャへの適合性、設計の一貫性、開発者の使いやすさの観点からレビューしていただいた Sangwhan Moon および W3C Technical Architecture Group に感謝します。

アルゴリズムを追加し、この仕様を快適にナビゲートできるようにしてくださった Zoltan Kis に感謝します。 仕様を現代的な編集慣行に合わせてくださった Joshua Bell に感謝します。丁寧なレビューとコメントをしてくださった Ningxin Hu、Lisha Guo、Shiyi Zou、Mingming Xu、Junwei Fu、Bruce Dai、Bin Miao に感謝します。

プライバシーおよびセキュリティのレビューとフィードバックについて W3C Privacy Interest Group に感謝します。

セキュリティレビューと質問について Alex Gough および Chrome Security チームに感謝します。

ONNX から得た実践的なガイドラインと知見を共有してくださった Michal Karzynski に感謝します。

フィードバックとプライバシー上の考慮事項について Kaustubha Govind および Chrome のプライバシーレビュアーに感謝します。

Chromium 実装のレビューとフィードバックについて Jiewei Qian に感謝します。

transformer サポートを調査し、推奨事項を提供する作業を行った Dwayne Robinson、Joshua Lochner、Wanming Lin に感謝します。 演算子の適合性と web-platform-tests 実装のレビューを提供してくださった Dwayne と Wanming にも 改めて感謝します。

web-platform-tests を仕様と並行して進化させ続ける継続的な貢献について Feng Dai に感謝します。

レビューと提案について Fuqiao Xue および W3C Internationalization Activity に感謝します。

14. 変更

このセクションは非規範的です。

このセクションでは、前回の主要公開以降にこの仕様へ加えられた変更を変更のクラスの観点から記録します。

候補勧告スナップショット 2024 年 4 月 11 日 と 2026 年 1 月 22 日 の間の詳細な変更

新機能（class 4）

新機能を追加しないその他の変更（class 3）

文書の解釈に機能的な影響を与えない変更（class 2）

横断的（class 2 および class 3）

編集上の変更（class 2）

適合性

文書の 表記規則

適合性要件は、 説明的な表明と RFC 2119 の用語の組み合わせで表現されます。 キーワード “MUST”、“MUST NOT”、“REQUIRED”、“SHALL”、“SHALL NOT”、“SHOULD”、“SHOULD NOT”、“RECOMMENDED”、 “MAY”、および “OPTIONAL” は、 この文書の規範的な部分において、 RFC 2119 に記載されているとおりに解釈されるものとします。 ただし、可読性のため、 この仕様ではこれらの語が常にすべて大文字で表記されるわけではありません。

この仕様のすべてのテキストは、非規範的であると明示的に示されたセクション、例、および注記を除き、 規範的です。[RFC2119]

この仕様の例は、“for example” という語で導入されるか、 規範的なテキストから class="example" によって区別されます。 次のようになります:

これは参考例の一例です。

参考注記は “Note” という語で始まり、 規範的なテキストから class="note" によって区別されます。 次のようになります:

注: これは参考注記です。

適合 アルゴリズム

アルゴリズムの一部として命令形で表現された要件 （"先頭の空白文字をすべて除去する" または "false を返してこれらの手順を中止する" など）は、 アルゴリズムを導入する際に使用されたキーワード （"must"、"should"、"may" など）の意味で解釈されるものとします。

アルゴリズムまたは具体的な手順として表現された適合性要件は、 最終結果が同等である限り、 どのような方法でも実装できます。 特に、この仕様で定義されるアルゴリズムは 理解しやすいことを意図しており、 高性能であることを意図していません。 実装者には最適化が推奨されます。

索引

この仕様で定義される 用語

参照先で定義される 用語

参考文献

規範的参考文献

[ECMASCRIPT]
ECMAScript 言語仕様. URL: https://tc39.es/ecma262/multipage/
[HTML]
Anne van Kesteren; et al. HTML 標準. 現行標準. URL: https://html.spec.whatwg.org/multipage/
[INFRA]
Anne van Kesteren; Domenic Denicola. Infra 標準. 現行標準. URL: https://infra.spec.whatwg.org/
[NUMPY-BROADCASTING-RULE]
SciPy コミュニティ. NumPy の一般的な ブロードキャスト規則. 2019 年 7 月. URL: https://numpy.org/doc/stable/user/basics.broadcasting.html#general-broadcasting-rules
[PERMISSIONS-POLICY-1]
Ian Clelland. Permissions Policy. 2026 年 6 月 18 日. WD. URL: https://www.w3.org/TR/permissions-policy-1/
[RFC2119]
S. Bradner. 要求レベルを 示すために RFC で使用するキーワード. 1997 年 3 月. 現行のベストプラクティス. URL: https://datatracker.ietf.org/doc/html/rfc2119
[WEBGPU]
Kai Ninomiya; Brandon Jones; Jim Blandy. WebGPU. 2026 年 8 月 12 日. CRD. URL: https://www.w3.org/TR/webgpu/
[WEBIDL]
Edgar Chen; Timothy Gu. Web IDL 標準. 現行 標準. URL: https://webidl.spec.whatwg.org/

非規範的参考文献

[Batch-Normalization]
Sergey Ioffe; Christian Szegedy. バッチ正規化: 内部共変量シフトを低減することによるディープネットワーク学習の高速化. 2015 年 3 月. URL: https://arxiv.org/abs/1502.03167
[ContextualLoss]
Roey Mechrez; Itamar Talmi; Lihi Zelnik-Manor. 位置合わせされていない データによる画像変換のためのコンテキスト損失. 2018 年 7 月. URL: https://arxiv.org/abs/1803.02077
[DeepLabv3+]
Liang-Chieh Chen; et al. セマンティック画像セグメンテーションのための Atrous Separable Convolution を用いたエンコーダー・デコーダー. 2018 年 8 月. URL: https://arxiv.org/abs/1802.02611
[DeepMoji]
Bjarke Felbo; et al. 数百万の絵文字出現を用いて 感情、情動、皮肉を検出するための任意ドメイン表現を学習する. 2017 年 10 月 . URL: https://arxiv.org/abs/1708.00524
[ELU]
Djork-Arné Clevert; Thomas Unterthiner; Sepp Hochreiter. 指数線形ユニット (ELU) による高速かつ高精度なディープネットワーク学習. 2016 年 2 月. URL: https://arxiv.org/abs/1511.07289
[Error-Function]
Larry C. Andrews. 工学者のための数学の 特殊関数. 1998. URL: https://books.google.com/books?id=2CAqsF-RebgC&pg=PA110
[FaceForensics++]
Andreas Rössler; et al. FaceForensics++. 2019 年 1 月. URL: https://github.com/ondyari/FaceForensics
[FaceNet]
Florian Schroff; Dmitry Kalenichenko; James Philbin. FaceNet: 顔認識および クラスタリングのための統一埋め込み. 2015 年 6 月. URL: https://arxiv.org/abs/1503.03832
[FAN]
Adrian Bulat; Georgios Tzimiropoulos. 2D および 3D 顔位置合わせ問題の 解決まであとどれほどか？ (および 230,000 個の 3D 顔 ランドマークのデータセット). 2017 年 9 月. URL: https://arxiv.org/abs/1703.07332
[GNMT]
Minh-Thang Luong; Eugene Brevdo; Rui Zhao. ニューラル機械 翻訳 (seq2seq) チュートリアル. 2017 年 5 月. URL: https://github.com/tensorflow/nmt
[GPT2]
Alec Radford; et al. 言語 モデルは教師なしマルチタスク学習器である. 2019 年 2 月. URL: https://d4mucfpksywv.cloudfront.net/better-language-models/language-models.pdf
[GRU]
Kyunghyun Cho; et al. 統計的機械翻訳のための RNN Encoder–Decoder を用いたフレーズ表現の学習. 2014 年 9 月. URL: https://arxiv.org/pdf/1406.1078.pdf
[HR-TIME-3]
Yoav Weiss. 高精度時間. 2026 年 3 月 24 日. WD. URL: https://www.w3.org/TR/hr-time-3/
[IEEE-754-2019]
浮動小数点 算術に関する IEEE 標準. 2019 年 7 月 22 日. URL: https://ieeexplore.ieee.org/document/8766229
[IM2TXT]
Oriol Vinyals; et al. Show and Tell: 2015 MSCOCO 画像キャプショニングチャレンジから得られた教訓. 2016 年 9 月. URL: https://arxiv.org/abs/1609.06647
[Instance-Normalization]
Dmitry Ulyanov; Andrea Vedaldi; Victor Lempitsky. インスタンス 正規化: 高速なスタイル変換に欠けていた要素. 2016 年 7 月. URL: https://arxiv.org/abs/1607.08022
[Layer-Normalization]
Jimmy Lei Ba; Jamie Ryan Kiros; Geoffrey E. Hinton. レイヤー 正規化. 2016 年 7 月. URL: https://arxiv.org/abs/1607.06450
[LDM]
Robin Rombach; et al. 潜在拡散モデルによる 高解像度画像合成. 2022 年 4 月. URL: https://arxiv.org/abs/2112.10752
[LeakyReLU]
Andrew L. Maas; Awni Y. Hannun; Andrew Y. Ng. Rectifier 非線形性によるニューラルネットワーク音響モデルの改善. 2013 年 6 月. URL: https://pdfs.semanticscholar.org/367f/2c63a6f6a10b3b64b8729d601e69337ee3cc.pdf
[LLAMA-2-7B]
Hugo Touvron; et al. Llama 2: オープンな基盤モデルと ファインチューニング済みチャットモデル. 2023 年 7 月. URL: https://arxiv.org/abs/2307.09288
[LSTM]
Sepp Hochreiter; Jürgen Schmidhuber. 長 短期記憶. 1997 年 11 月. URL: https://doi.org/10.1162/neco.1997.9.8.1735
[m2m100_418M]
Angela Fan; et al. 英語中心を超えた多言語 機械翻訳. 2020 年 10 月. URL: https://arxiv.org/abs/2010.11125
[MaskR-CNN]
Kaiming He; et al. Mask R-CNN. 2018 年 1 月. URL: https://arxiv.org/abs/1703.06870
[MobileNetV3]
Andrew Howard; et al. MobileNetV3 の探索. 2019 年 11 月. URL: https://arxiv.org/pdf/1905.02244
[MODELS]
Web 向け機械学習コミュニティグループ. 第 1 波のモデル. 2020. URL: https://github.com/webmachinelearning/webnn/blob/master/op_compatibility/first_wave_models.md
[NumPy]
SciPy コミュニティ. NumPy. 2019 年 7 月. URL: https://numpy.org/doc/stable/
[OpenNMT]
Guillaume Klein; et al. OpenNMT: オープンソースの ニューラル機械翻訳ツールキット. 2017 年 3 月. URL: https://arxiv.org/abs/1701.02810
[PairedCycleGAN]
Huiwen Chang; et al. PairedCycleGAN: メイクの適用と除去のための非対称スタイル変換. 2018 年 6 月. URL: http://openaccess.thecvf.com/content_cvpr_2018/html/Chang_PairedCycleGAN_Asymmetric_Style_CVPR_2018_paper.html
[PoseNet]
Dan Oved. TensorFlow.js を用いたブラウザーでのリアルタイム 人体姿勢推定. 2018 年 5 月. URL: https://medium.com/tensorflow/real-time-human-pose-estimation-in-the-browser-with-tensorflow-js-7dd0bc881cd5
[POWERFUL-FEATURES]
Mike West. セキュアコンテキスト. 2023 年 11 月 10 日. CRD. URL: https://www.w3.org/TR/secure-contexts/
[Prefix-sum]
Wikipedia コミュニティ. 累積和. 2025 年 1 月. URL: https://en.wikipedia.org/wiki/Prefix_sum
[RNNoise]
Jean-Marc Valin. 音声ノイズ 低減のためのリカレントニューラルネットワーク. 2017 年 9 月. URL: https://github.com/xiph/rnnoise
[SECURITY-PRIVACY-QUESTIONNAIRE]
Theresa O'Connor; Peter Snyder; Simone Onofri. 自己レビュー質問票: セキュリティ とプライバシー. 2025 年 4 月 18 日. NOTE. URL: https://www.w3.org/TR/security-privacy-questionnaire/
[SegAny]
Alexander Kirillov; et al. あらゆるものをセグメント化する. 2023 年 4 月. URL: https://arxiv.org/abs/2304.02643
[SRGAN]
Christian Ledig; et al. 生成的敵対ネットワークを用いた写真のようにリアルな単一画像 超解像. 2017 年 5 月. URL: https://arxiv.org/abs/1609.04802
[SSD]
Wei Liu; et al. SSD: Single Shot MultiBox Detector. 2016 年 12 月. URL: https://arxiv.org/abs/1512.02325
[T5-SMALL]
Colin Raffel; et al. 統一された Text-to-Text Transformer による 転移学習の限界の探究. 2020 年 6 月. URL: https://jmlr.org/papers/volume21/20-074/20-074.pdf
[UTR36]
Mark Davis; Michel Suignard. Unicode セキュリティ上の考慮事項. 2014 年 9 月 19 日. Unicode 技術報告 #36. URL: https://www.unicode.org/reports/tr36/tr36-15.html
[UTS55]
Robin Leroy; Mark Davis. Unicode ソース コードの取り扱い. 2024 年 1 月 29 日. Unicode 技術標準 #55. URL: https://www.unicode.org/reports/tr55/tr55-5.html
[Video-Summarization-with-LSTM]
Ke Zhang; et al. 長 短期記憶による動画要約. 2016 年 10 月. URL: http://www-scf.usc.edu/~zhan355/ke_eccv2016.pdf
[WASM-JS-API-2]
. Ms2ger; Ryan Hunt. WebAssembly JavaScript インターフェイス. 2026 年 8 月 12 日. CRD. URL: https://www.w3.org/TR/wasm-js-api-2/
[WCAG]
Michael Cooper; et al. Web コンテンツアクセシビリティガイドライン (WCAG) 2.2. 2024 年 12 月 12 日. REC. URL: https://www.w3.org/TR/WCAG22/
[WEBMACHINELEARNING-ETHICS]
Anssi Kostiainen. Web 機械学習の倫理原則. 2024 年 1 月 8 日. DNOTE. URL: https://www.w3.org/TR/webmachinelearning-ethics/
[Whisper]
Alec Radford; et al. 大規模な弱教師あり学習による 堅牢な音声認識. 2022 年 12 月. URL: https://arxiv.org/abs/2212.04356
[YOLO]
Joseph Redmon; et al. You Only Look Once: 統一された リアルタイム物体検出. 2016 年 5 月. URL: https://arxiv.org/abs/1506.02640

IDL 索引

interface mixin NavigatorML {
  [SecureContext, SameObject] readonly attribute ML ml;
};
Navigator includes NavigatorML;
WorkerNavigator includes NavigatorML;

enum MLPowerPreference {
  "default",
  "high-performance",
  "low-power"
};

dictionary MLContextOptions {
  MLPowerPreference powerPreference = "default";
  boolean accelerated = true;
};

[SecureContext, Exposed=(Window, Worker)]
interface ML {
  Promise<MLContext> createContext(optional MLContextOptions options = {});
  Promise<MLContext> createContext(GPUDevice gpuDevice);
};

typedef record<USVString, MLTensor> MLNamedTensors;

dictionary MLContextLostInfo {
  DOMString message;
};

[SecureContext, Exposed=(Window, Worker)]
interface MLContext {
  undefined dispatch(MLGraph graph, MLNamedTensors inputs, MLNamedTensors outputs);

  Promise<MLTensor> createTensor(MLTensorDescriptor descriptor);
  Promise<MLTensor> createExportableTensor(
    MLTensorDescriptor descriptor, GPUDevice gpuDevice);
  Promise<MLTensor> createConstantTensor(
    MLOperandDescriptor descriptor, AllowSharedBufferSource inputData);

  Promise<ArrayBuffer> readTensor(MLTensor tensor);
  Promise<undefined> readTensor(MLTensor tensor, AllowSharedBufferSource outputData);

  undefined writeTensor(MLTensor tensor, AllowSharedBufferSource inputData);

  GPUBuffer exportToGPU(MLTensor tensor);

  MLOpSupportLimits opSupportLimits();

  undefined destroy();

  readonly attribute boolean accelerated;
  readonly attribute Promise<MLContextLostInfo> lost;
};

dictionary MLOpSupportLimits {
  MLInputOperandLayout preferredInputLayout;
  [EnforceRange] unsigned long long maxTensorByteLength;
  MLTensorLimits input;
  MLTensorLimits constant;
  MLTensorLimits output;
};

dictionary MLRankRange {
  unsigned long min;
  unsigned long max;
};

typedef sequence<MLOperandDataType> MLDataTypeList;

dictionary MLTensorLimits {
  MLDataTypeList dataTypes;
  MLRankRange rankRange;
};

dictionary MLBinarySupportLimits {
  MLTensorLimits a;
  MLTensorLimits b;
  MLTensorLimits output;
};

dictionary MLSingleInputSupportLimits {
  MLTensorLimits input;
  MLTensorLimits output;
};

[SecureContext, Exposed=(Window, Worker)]
interface MLGraph {
  undefined destroy();
};

enum MLInputOperandLayout {
  "nchw",
  "nhwc"
};

enum MLOperandDataType {
  "float32",
  "float16",
  "int32",
  "uint32",
  "int64",
  "uint64",
  "int8",
  "uint8"
};

dictionary MLOperandDescriptor {
  required MLOperandDataType dataType;
  required sequence<[EnforceRange] unsigned long> shape;
};

[SecureContext, Exposed=(Window, Worker)]
interface MLOperand {
  readonly attribute MLOperandDataType dataType;
  readonly attribute FrozenArray<unsigned long> shape;
};

dictionary MLOperatorOptions {
  USVString label = "";
};

typedef (bigint or unrestricted double) MLNumber;

dictionary MLTensorDescriptor : MLOperandDescriptor {
  boolean readable = false;
  boolean writable = false;
};

[SecureContext, Exposed=(Window, Worker)]
interface MLTensor {
  readonly attribute MLOperandDataType dataType;
  readonly attribute FrozenArray<unsigned long> shape;
  readonly attribute boolean readable;
  readonly attribute boolean writable;
  readonly attribute boolean constant;

  undefined destroy();
};

typedef record<USVString, MLOperand> MLNamedOperands;

[SecureContext, Exposed=(Window, Worker)]
interface MLGraphBuilder {
  // Construct the graph builder from the context.
  constructor(MLContext context);

  // Create an operand for a graph input.
  MLOperand input(USVString name, MLOperandDescriptor descriptor);

  // Create an operand for a graph constant.
  MLOperand constant(MLOperandDescriptor descriptor,
                     AllowSharedBufferSource buffer);

  // Create a scalar operand from the specified number of the specified type.
  MLOperand constant(MLOperandDataType dataType, MLNumber value);

  // Create an operand from a specified constant tensor.
  MLOperand constant(MLTensor tensor);

  // Compile the graph up to the specified output operands asynchronously.
  Promise<MLGraph> build(MLNamedOperands outputs);
};

dictionary MLArgMinMaxOptions : MLOperatorOptions {
  boolean keepDimensions = false;
  MLOperandDataType outputDataType = "int32";
};

partial interface MLGraphBuilder {
  MLOperand argMin(MLOperand input, [EnforceRange] unsigned long axis,
                   optional MLArgMinMaxOptions options = {});
  MLOperand argMax(MLOperand input, [EnforceRange] unsigned long axis,
                   optional MLArgMinMaxOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits argMin;
  MLSingleInputSupportLimits argMax;
};

dictionary MLBatchNormalizationOptions : MLOperatorOptions {
  MLOperand scale;
  MLOperand bias;
  [EnforceRange] unsigned long axis = 1;
  double epsilon = 1e-5;
};

partial interface MLGraphBuilder {
  MLOperand batchNormalization(MLOperand input, MLOperand mean, MLOperand variance,
                               optional MLBatchNormalizationOptions options = {});
};

dictionary MLBatchNormalizationSupportLimits {
  MLTensorLimits input;
  MLTensorLimits mean;
  MLTensorLimits variance;
  MLTensorLimits scale;
  MLTensorLimits bias;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLBatchNormalizationSupportLimits batchNormalization;
};

partial interface MLGraphBuilder {
  MLOperand cast(MLOperand input,
                 MLOperandDataType dataType,
                 optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits cast;
};

dictionary MLClampOptions : MLOperatorOptions {
  MLNumber minValue;
  MLNumber maxValue;
};

partial interface MLGraphBuilder {
  MLOperand clamp(MLOperand input, optional MLClampOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits clamp;
};

partial interface MLGraphBuilder {
  MLOperand concat(sequence<MLOperand> inputs,
                   [EnforceRange] unsigned long axis,
                   optional MLOperatorOptions options = {});
};

dictionary MLConcatSupportLimits {
  MLTensorLimits inputs;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLConcatSupportLimits concat;
};

enum MLConv2dFilterOperandLayout {
  "oihw",
  "hwio",
  "ohwi",
  "ihwo"
};

dictionary MLConv2dOptions : MLOperatorOptions {
  sequence<[EnforceRange] unsigned long> padding;
  sequence<[EnforceRange] unsigned long> strides;
  sequence<[EnforceRange] unsigned long> dilations;
  [EnforceRange] unsigned long groups = 1;
  MLInputOperandLayout inputLayout = "nchw";
  MLConv2dFilterOperandLayout filterLayout = "oihw";
  MLOperand bias;
};

partial interface MLGraphBuilder {
  MLOperand conv2d(MLOperand input,
                   MLOperand filter,
                   optional MLConv2dOptions options = {});
};

dictionary MLConv2dSupportLimits {
  MLTensorLimits input;
  MLTensorLimits filter;
  MLTensorLimits bias;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLConv2dSupportLimits conv2d;
};

enum MLConvTranspose2dFilterOperandLayout {
  "iohw",
  "hwoi",
  "ohwi"
};

dictionary MLConvTranspose2dOptions : MLOperatorOptions {
  sequence<[EnforceRange] unsigned long> padding;
  sequence<[EnforceRange] unsigned long> strides;
  sequence<[EnforceRange] unsigned long> dilations;
  sequence<[EnforceRange] unsigned long> outputPadding;
  sequence<[EnforceRange] unsigned long> outputSizes;
  [EnforceRange] unsigned long groups = 1;
  MLInputOperandLayout inputLayout = "nchw";
  MLConvTranspose2dFilterOperandLayout filterLayout = "iohw";
  MLOperand bias;
};

partial interface MLGraphBuilder {
  MLOperand convTranspose2d(MLOperand input, MLOperand filter,
                            optional MLConvTranspose2dOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLConv2dSupportLimits convTranspose2d;
};

dictionary MLCumulativeSumOptions : MLOperatorOptions {
  boolean exclusive = false;
  boolean reversed = false;
};

partial interface MLGraphBuilder {
  MLOperand cumulativeSum(MLOperand input,
                          unsigned long axis,
                          optional MLCumulativeSumOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits cumulativeSum;
};

partial interface MLGraphBuilder {
  MLOperand add(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
  MLOperand sub(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
  MLOperand mul(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
  MLOperand div(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
  MLOperand max(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
  MLOperand min(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
  MLOperand pow(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLBinarySupportLimits add;
  MLBinarySupportLimits sub;
  MLBinarySupportLimits mul;
  MLBinarySupportLimits div;
  MLBinarySupportLimits max;
  MLBinarySupportLimits min;
  MLBinarySupportLimits pow;
};

partial interface MLGraphBuilder {
  MLOperand equal(MLOperand a,
                  MLOperand b,
                  optional MLOperatorOptions options = {});
  MLOperand notEqual(MLOperand a,
                     MLOperand b,
                     optional MLOperatorOptions options = {});
  MLOperand greater(MLOperand a,
                    MLOperand b,
                    optional MLOperatorOptions options = {});
  MLOperand greaterOrEqual(MLOperand a,
                           MLOperand b,
                           optional MLOperatorOptions options = {});
  MLOperand lesser(MLOperand a,
                   MLOperand b,
                   optional MLOperatorOptions options = {});
  MLOperand lesserOrEqual(MLOperand a,
                          MLOperand b,
                          optional MLOperatorOptions options = {});
  MLOperand logicalNot(MLOperand a, optional MLOperatorOptions options = {});
  MLOperand logicalAnd(MLOperand a,
                       MLOperand b,
                       optional MLOperatorOptions options = {});
  MLOperand logicalOr(MLOperand a,
                      MLOperand b,
                      optional MLOperatorOptions options = {});
  MLOperand logicalXor(MLOperand a,
                       MLOperand b,
                       optional MLOperatorOptions options = {});
  MLOperand isNaN(MLOperand a, optional MLOperatorOptions options = {});
  MLOperand isInfinite(MLOperand a, optional MLOperatorOptions options = {});
};

dictionary MLLogicalNotSupportLimits {
  MLTensorLimits a;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLBinarySupportLimits equal;
  MLBinarySupportLimits notEqual;
  MLBinarySupportLimits greater;
  MLBinarySupportLimits greaterOrEqual;
  MLBinarySupportLimits lesser;
  MLBinarySupportLimits lesserOrEqual;
  MLLogicalNotSupportLimits logicalNot;
  MLBinarySupportLimits logicalAnd;
  MLBinarySupportLimits logicalOr;
  MLBinarySupportLimits logicalXor;
  MLLogicalNotSupportLimits isNaN;
  MLLogicalNotSupportLimits isInfinite;
};

partial interface MLGraphBuilder {
  MLOperand abs(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand ceil(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand cos(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand erf(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand exp(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand floor(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand identity(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand log(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand neg(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand reciprocal(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand roundEven(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand sin(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand sign(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand sqrt(MLOperand input, optional MLOperatorOptions options = {});
  MLOperand tan(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits abs;
  MLSingleInputSupportLimits ceil;
  MLSingleInputSupportLimits cos;
  MLSingleInputSupportLimits erf;
  MLSingleInputSupportLimits exp;
  MLSingleInputSupportLimits floor;
  MLSingleInputSupportLimits identity;
  MLSingleInputSupportLimits log;
  MLSingleInputSupportLimits neg;
  MLSingleInputSupportLimits reciprocal;
  MLSingleInputSupportLimits roundEven;
  MLSingleInputSupportLimits sin;
  MLSingleInputSupportLimits sign;
  MLSingleInputSupportLimits sqrt;
  MLSingleInputSupportLimits tan;
};

partial interface MLGraphBuilder {
  MLOperand dequantizeLinear(MLOperand input,
                             MLOperand scale,
                             MLOperand zeroPoint,
                             optional MLOperatorOptions options = {});
};

dictionary MLQuantizeDequantizeLinearSupportLimits {
  MLTensorLimits input;
  MLTensorLimits scale;
  MLTensorLimits zeroPoint;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLQuantizeDequantizeLinearSupportLimits dequantizeLinear;
};

partial interface MLGraphBuilder {
  MLOperand quantizeLinear(MLOperand input,
                           MLOperand scale,
                           MLOperand zeroPoint,
                           optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLQuantizeDequantizeLinearSupportLimits quantizeLinear;
};

dictionary MLEluOptions : MLOperatorOptions {
  double alpha = 1;
};

partial interface MLGraphBuilder {
  MLOperand elu(MLOperand input, optional MLEluOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits elu;
};

partial interface MLGraphBuilder {
  MLOperand expand(MLOperand input,
                   sequence<[EnforceRange] unsigned long> newShape,
                   optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits expand;
};

dictionary MLGatherOptions : MLOperatorOptions {
  [EnforceRange] unsigned long axis = 0;
};

partial interface MLGraphBuilder {
  MLOperand gather(MLOperand input,
                   MLOperand indices,
                   optional MLGatherOptions options = {});
};

dictionary MLGatherSupportLimits {
  MLTensorLimits input;
  MLTensorLimits indices;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLGatherSupportLimits gather;
};

partial interface MLGraphBuilder {
  MLOperand gatherElements(MLOperand input,
                           MLOperand indices,
                           optional MLGatherOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLGatherSupportLimits gatherElements;
};

partial interface MLGraphBuilder {
  MLOperand gatherND(MLOperand input,
                     MLOperand indices,
                     optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLGatherSupportLimits gatherND;
};

partial interface MLGraphBuilder {
  MLOperand gelu(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits gelu;
};

dictionary MLGemmOptions : MLOperatorOptions {
  MLOperand c;
  double alpha = 1.0;
  double beta = 1.0;
  boolean aTranspose = false;
  boolean bTranspose = false;
};

partial interface MLGraphBuilder {
  MLOperand gemm(MLOperand a, MLOperand b, optional MLGemmOptions options = {});
};

dictionary MLGemmSupportLimits {
  MLTensorLimits a;
  MLTensorLimits b;
  MLTensorLimits c;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLGemmSupportLimits gemm;
};

enum MLGruWeightLayout {
  "zrn",  // update-reset-new gate ordering
  "rzn"   // reset-update-new gate ordering
};

enum MLRecurrentNetworkActivation {
  "relu",
  "sigmoid",
  "tanh"
};

enum MLRecurrentNetworkDirection {
  "forward",
  "backward",
  "both"
};

dictionary MLGruOptions : MLOperatorOptions {
  MLOperand bias;
  MLOperand recurrentBias;
  MLOperand initialHiddenState;
  boolean resetAfter = true;
  boolean returnSequence = false;
  MLRecurrentNetworkDirection direction = "forward";
  MLGruWeightLayout layout = "zrn";
  sequence<MLRecurrentNetworkActivation> activations;
};

partial interface MLGraphBuilder {
  sequence<MLOperand> gru(MLOperand input,
                          MLOperand weight,
                          MLOperand recurrentWeight,
                          [EnforceRange] unsigned long steps,
                          [EnforceRange] unsigned long hiddenSize,
                          optional MLGruOptions options = {});
};

dictionary MLGruSupportLimits {
  MLTensorLimits input;
  MLTensorLimits weight;
  MLTensorLimits recurrentWeight;
  MLTensorLimits bias;
  MLTensorLimits recurrentBias;
  MLTensorLimits initialHiddenState;
  MLTensorLimits output0;
  MLTensorLimits output1;
};

partial dictionary MLOpSupportLimits {
  MLGruSupportLimits gru;
};

dictionary MLGruCellOptions : MLOperatorOptions {
  MLOperand bias;
  MLOperand recurrentBias;
  boolean resetAfter = true;
  MLGruWeightLayout layout = "zrn";
  sequence<MLRecurrentNetworkActivation> activations;
};

partial interface MLGraphBuilder {
  MLOperand gruCell(MLOperand input,
                    MLOperand weight,
                    MLOperand recurrentWeight,
                    MLOperand hiddenState,
                    [EnforceRange] unsigned long hiddenSize,
                    optional MLGruCellOptions options = {});
};

dictionary MLGruCellSupportLimits {
  MLTensorLimits input;
  MLTensorLimits weight;
  MLTensorLimits recurrentWeight;
  MLTensorLimits hiddenState;
  MLTensorLimits bias;
  MLTensorLimits recurrentBias;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLGruCellSupportLimits gruCell;
};

dictionary MLHardSigmoidOptions : MLOperatorOptions {
  double alpha = 0.2;
  double beta = 0.5;
};

partial interface MLGraphBuilder {
  MLOperand hardSigmoid(MLOperand input, optional MLHardSigmoidOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits hardSigmoid;
};

partial interface MLGraphBuilder {
  MLOperand hardSwish(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits hardSwish;
};

dictionary MLInstanceNormalizationOptions : MLOperatorOptions {
  MLOperand scale;
  MLOperand bias;
  double epsilon = 1e-5;
  MLInputOperandLayout layout = "nchw";
};

partial interface MLGraphBuilder {
  MLOperand instanceNormalization(
    MLOperand input,
    optional MLInstanceNormalizationOptions options = {});
};

dictionary MLNormalizationSupportLimits {
  MLTensorLimits input;
  MLTensorLimits scale;
  MLTensorLimits bias;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLNormalizationSupportLimits instanceNormalization;
};

dictionary MLLayerNormalizationOptions : MLOperatorOptions {
  MLOperand scale;
  MLOperand bias;
  sequence<[EnforceRange] unsigned long> axes;
  double epsilon = 1e-5;
};

partial interface MLGraphBuilder {
  MLOperand layerNormalization(MLOperand input,
                               optional MLLayerNormalizationOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLNormalizationSupportLimits layerNormalization;
};

dictionary MLLeakyReluOptions : MLOperatorOptions {
  double alpha = 0.01;
};

partial interface MLGraphBuilder {
  MLOperand leakyRelu(MLOperand input, optional MLLeakyReluOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits leakyRelu;
};

dictionary MLLinearOptions : MLOperatorOptions {
  double alpha = 1;
  double beta = 0;
};

partial interface MLGraphBuilder {
  MLOperand linear(MLOperand input, optional MLLinearOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits linear;
};

enum MLLstmWeightLayout {
  "iofg", // input-output-forget-cell gate ordering
  "ifgo"  // input-forget-cell-output gate ordering
};

dictionary MLLstmOptions : MLOperatorOptions {
  MLOperand bias;
  MLOperand recurrentBias;
  MLOperand peepholeWeight;
  MLOperand initialHiddenState;
  MLOperand initialCellState;
  boolean returnSequence = false;
  MLRecurrentNetworkDirection direction = "forward";
  MLLstmWeightLayout layout = "iofg";
  sequence<MLRecurrentNetworkActivation> activations;
};

partial interface MLGraphBuilder {
  sequence<MLOperand> lstm(MLOperand input,
                           MLOperand weight,
                           MLOperand recurrentWeight,
                           [EnforceRange] unsigned long steps,
                           [EnforceRange] unsigned long hiddenSize,
                           optional MLLstmOptions options = {});
};

dictionary MLLstmSupportLimits {
  MLTensorLimits input;
  MLTensorLimits weight;
  MLTensorLimits recurrentWeight;
  MLTensorLimits bias;
  MLTensorLimits recurrentBias;
  MLTensorLimits peepholeWeight;
  MLTensorLimits initialHiddenState;
  MLTensorLimits initialCellState;
  MLTensorLimits output0;
  MLTensorLimits output1;
  MLTensorLimits output2;
};

partial dictionary MLOpSupportLimits {
  MLLstmSupportLimits lstm;
};


dictionary MLLstmCellOptions : MLOperatorOptions {
  MLOperand bias;
  MLOperand recurrentBias;
  MLOperand peepholeWeight;
  MLLstmWeightLayout layout = "iofg";
  sequence<MLRecurrentNetworkActivation> activations;
};

partial interface MLGraphBuilder {
  sequence<MLOperand> lstmCell(MLOperand input,
                               MLOperand weight,
                               MLOperand recurrentWeight,
                               MLOperand hiddenState,
                               MLOperand cellState,
                               [EnforceRange] unsigned long hiddenSize,
                               optional MLLstmCellOptions options = {});
};

dictionary MLLstmCellSupportLimits {
  MLTensorLimits input;
  MLTensorLimits weight;
  MLTensorLimits recurrentWeight;
  MLTensorLimits hiddenState;
  MLTensorLimits cellState;
  MLTensorLimits bias;
  MLTensorLimits recurrentBias;
  MLTensorLimits peepholeWeight;
  MLTensorLimits output0;
  MLTensorLimits output1;
};

partial dictionary MLOpSupportLimits {
  MLLstmCellSupportLimits lstmCell;
};

partial interface MLGraphBuilder {
  MLOperand matmul(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLBinarySupportLimits matmul;
};

enum MLPaddingMode {
  "constant",
  "edge",
  "reflection"
};

dictionary MLPadOptions : MLOperatorOptions {
  MLPaddingMode mode = "constant";
  MLNumber value = 0;
};

partial interface MLGraphBuilder {
  MLOperand pad(MLOperand input,
                sequence<[EnforceRange] unsigned long> beginningPadding,
                sequence<[EnforceRange] unsigned long> endingPadding,
                optional MLPadOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits pad;
};

enum MLRoundingType {
  "floor",
  "ceil"
};

dictionary MLPool2dOptions : MLOperatorOptions {
  sequence<[EnforceRange] unsigned long> windowDimensions;
  sequence<[EnforceRange] unsigned long> padding;
  sequence<[EnforceRange] unsigned long> strides;
  sequence<[EnforceRange] unsigned long> dilations;
  MLInputOperandLayout layout = "nchw";
  MLRoundingType outputShapeRounding = "floor";
  sequence<[EnforceRange] unsigned long> outputSizes;
};

partial interface MLGraphBuilder {
  MLOperand averagePool2d(MLOperand input, optional MLPool2dOptions options = {});
  MLOperand l2Pool2d(MLOperand input, optional MLPool2dOptions options = {});
  MLOperand maxPool2d(MLOperand input, optional MLPool2dOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits averagePool2d;
  MLSingleInputSupportLimits l2Pool2d;
  MLSingleInputSupportLimits maxPool2d;
};

partial interface MLGraphBuilder {
  MLOperand prelu(MLOperand input,
                  MLOperand slope,
                  optional MLOperatorOptions options = {});
};

dictionary MLPreluSupportLimits {
  MLTensorLimits input;
  MLTensorLimits slope;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLPreluSupportLimits prelu;
};

dictionary MLReduceOptions : MLOperatorOptions {
  sequence<[EnforceRange] unsigned long> axes;
  boolean keepDimensions = false;
};

partial interface MLGraphBuilder {
  MLOperand reduceL1(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceL2(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceLogSum(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceLogSumExp(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceMax(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceMean(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceMin(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceProduct(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceSum(MLOperand input, optional MLReduceOptions options = {});
  MLOperand reduceSumSquare(MLOperand input, optional MLReduceOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits reduceL1;
  MLSingleInputSupportLimits reduceL2;
  MLSingleInputSupportLimits reduceLogSum;
  MLSingleInputSupportLimits reduceLogSumExp;
  MLSingleInputSupportLimits reduceMax;
  MLSingleInputSupportLimits reduceMean;
  MLSingleInputSupportLimits reduceMin;
  MLSingleInputSupportLimits reduceProduct;
  MLSingleInputSupportLimits reduceSum;
  MLSingleInputSupportLimits reduceSumSquare;
};

partial interface MLGraphBuilder {
  MLOperand relu(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits relu;
};

enum MLInterpolationMode {
  "nearest-neighbor",
  "linear"
};

dictionary MLResample2dOptions : MLOperatorOptions {
  MLInterpolationMode mode = "nearest-neighbor";
  sequence<float> scales;
  sequence<[EnforceRange] unsigned long> sizes;
  sequence<[EnforceRange] unsigned long> axes;
};

partial interface MLGraphBuilder {
  MLOperand resample2d(MLOperand input, optional MLResample2dOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits resample2d;
};

partial interface MLGraphBuilder {
  MLOperand reshape(MLOperand input,
                    sequence<[EnforceRange] unsigned long> newShape,
                    optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits reshape;
};

dictionary MLReverseOptions : MLOperatorOptions {
  sequence<[EnforceRange] unsigned long> axes;
};

partial interface MLGraphBuilder {
  MLOperand reverse(MLOperand input, optional MLReverseOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits reverse;
};

dictionary MLScatterOptions : MLOperatorOptions {
  [EnforceRange] unsigned long axis = 0;
};

partial interface MLGraphBuilder {
  MLOperand scatterElements(MLOperand input,
                            MLOperand indices,
                            MLOperand updates,
                            optional MLScatterOptions options = {});
};

dictionary MLScatterSupportLimits {
  MLTensorLimits input;
  MLTensorLimits indices;
  MLTensorLimits updates;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLScatterSupportLimits scatterElements;
};

partial interface MLGraphBuilder {
  MLOperand scatterND(MLOperand input,
                      MLOperand indices,
                      MLOperand updates,
                      optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLScatterSupportLimits scatterND;
};

partial interface MLGraphBuilder {
  MLOperand sigmoid(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits sigmoid;
};

dictionary MLSliceOptions : MLOperatorOptions {
  sequence<[EnforceRange] unsigned long> strides;
};

partial interface MLGraphBuilder {
  MLOperand slice(MLOperand input,
                  sequence<[EnforceRange] unsigned long> starts,
                  sequence<[EnforceRange] unsigned long> sizes,
                  optional MLSliceOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits slice;
};

partial interface MLGraphBuilder {
  MLOperand softmax(MLOperand input,
                    [EnforceRange] unsigned long axis,
                    optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits softmax;
};

partial interface MLGraphBuilder {
  MLOperand softplus(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits softplus;
};

partial interface MLGraphBuilder {
  MLOperand softsign(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits softsign;
};

dictionary MLSplitOptions : MLOperatorOptions {
  [EnforceRange] unsigned long axis = 0;
};

partial interface MLGraphBuilder {
  sequence<MLOperand> split(
      MLOperand input,
      ([EnforceRange] unsigned long or sequence<[EnforceRange] unsigned long>) splits,
      optional MLSplitOptions options = {});
};

dictionary MLSplitSupportLimits {
  MLTensorLimits input;
  MLTensorLimits outputs;
};

partial dictionary MLOpSupportLimits {
  MLSplitSupportLimits split;
};

partial interface MLGraphBuilder {
  MLOperand tanh(MLOperand input, optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits tanh;
};

partial interface MLGraphBuilder {
  MLOperand tile(MLOperand input,
                 sequence<unsigned long> repetitions,
                 optional MLOperatorOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits tile;
};

dictionary MLTransposeOptions : MLOperatorOptions {
  sequence<[EnforceRange] unsigned long> permutation;
};

partial interface MLGraphBuilder {
  MLOperand transpose(MLOperand input, optional MLTransposeOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits transpose;
};

dictionary MLTriangularOptions : MLOperatorOptions {
  boolean upper = true;
  [EnforceRange] long diagonal = 0;
};

partial interface MLGraphBuilder {
  MLOperand triangular(MLOperand input, optional MLTriangularOptions options = {});
};

partial dictionary MLOpSupportLimits {
  MLSingleInputSupportLimits triangular;
};

partial interface MLGraphBuilder {
  MLOperand where(MLOperand condition,
                  MLOperand trueValue,
                  MLOperand falseValue,
                  optional MLOperatorOptions options = {});
};

dictionary MLWhereSupportLimits {
  MLTensorLimits condition;
  MLTensorLimits trueValue;
  MLTensorLimits falseValue;
  MLTensorLimits output;
};

partial dictionary MLOpSupportLimits {
  MLWhereSupportLimits where;
};

課題索引

実装者への指針として、範囲外アクセスの影響を受ける可能性がある演算を文書化する。 ↵
レンダラーを実行するプロセス間で CPU が共有されている現在の状況を考慮し、 サイドチャネル攻撃の実現可能性を調査する。 ↵
ヒント付与によって懸念は部分的に軽減される。追加の緩和策を調査する。 ↵
グラフが完全に構築およびコンパイルされた後に、実行用として実際に選択されたデバイスを公開するため、 MLGraph.devices API 拡張が提案されている。この API 拡張のプライバシーへの影響は調査中である。 [Issue #836] ↵
dispatch() 中のエラーを報告する仕組みの追加を検討する。 [Issue #778] ↵
このタイムラインをより厳密に定義する。 [Issue #529] ↵
グラフ実行中のエラーを報告する仕組みを追加する。 [Issue #778] ↵
テンソルへの書き込み中のエラーを報告する仕組みを追加する。 [Issue #778] ↵
サイズ 0 の次元をサポートすべきか？ [Issue #391] ↵
オペランドの次元数の最大値は定義されていないが、ネイティブ ML API には通常、 サポートされる最大数がある。 [Issue #456] ↵
bigint と 数値型の union のサポートは [WEBIDL] で新たに導入されたものであり、 実装でのサポートも限定的である。プロトタイプ実装には、この アプローチについてフィードバックを提供することが推奨される。 [whatwg/webidl Issue #1388] ↵
サイズ 0 の次元が許可される場合、これらの手順を改訂する。 [Issue #391] ↵
サイズ 0 の次元が許可される場合、上記の手順を改訂する。 [Issue #391] ↵
サイズ 0 の次元が許可される場合、これらの手順を改訂する。 [Issue #391] ↵
[INFRA] に定義が 利用可能になったら、これを削除する。 [whatwg/infra Issue #664] ↵