グループ操作#

group ov_ops_cpp_api

異なる操作セットから操作を作成する OpenVINO C++ API。このような API は、コードからモデルを作成し、トランスフォーメーションを記述し、モデルグラフをトラバースするのに使用されます。

class AUGRUCell : public ov::op::util::RNNCellBase #

#include <augru_cell.hpp>

AUGRUCell 操作。

パブリック関数

virtual void validate_and_infer_types() override#

属性と入力に一貫性があることを確認し、出力の形状と要素タイプを計算します。何度でも実行できるように、具体的な子クラスによって実装される必要があります。

ノードが無効な場合にスローされます。

class AUGRUSequence : public ov::op::util::RNNCellBase #

#include <augru_sequence.hpp>

AUGRUSequence 操作。

パブリック関数

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Abs : public ov::op::util::UnaryElementwiseArithmetic #

#include <abs.hpp>

要素ごとの絶対値操作。

パブリック関数

Abs() = default#: 絶対値操作を構築します。

Abs(const Output<Node> &arg)#

絶対値操作を構築します。

Output [d1, ...]

パラメーター:: arg – 入力テンソルを生成する Output。[d1, ...]

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Acos : public ov::op::util::UnaryElementwiseArithmetic #

#include <acos.hpp>

要素ごとの逆余弦 (arccos) 操作。

パブリック関数

Acos() = default#: arccos 操作を構築します。

Acos(const Output<Node> &arg)#

arccos 操作を構築します。

Output [d1, ...]

パラメーター:: arg – 入力テンソルを生成する Output。[d1, ...]

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Acosh : public ov::op::util::UnaryElementwiseArithmetic #

#include <acosh.hpp>

要素ごとの逆双曲余弦操作。

パブリック関数

Acosh() = default#: Acosh オペレーションを構築します。

Acosh(const Output<Node> &arg)#

Acosh オペレーションを構築します。

Output [d1, ...]

パラメーター:: arg – 入力テンソルを生成する Output。[d1, ...]

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class AdaptiveAvgPool : public ov::op::Op #

#include <adaptive_avg_pool.hpp>

適応平均プーリング操作。

パブリック関数

AdaptiveAvgPool(const Output<Node> &data, const Output<Node> &output_shape)#

適応平均プーリング操作を構築します。

パラメーター:

data – Input データ
output_shape – 空間次元の出力形状を記述する 1D テンソル。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class AdaptiveMaxPool : public ov::op::Op #

#include <adaptive_max_pool.hpp>

適応最大プーリング操作。

パブリック関数

AdaptiveMaxPool(const Output<Node> &data, const Output<Node> &output_shape, const ov::element::Type &index_element_type = ov::element::i64)#

適応最大プーリング操作を構築します。

パラメーター:

data – 入力データ
output_shape – 空間次元の出力形状を記述する 1D テンソル。
index_element_type – インデックス出力の出力テンソルタイプを指定します

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Add : public ov::op::util::BinaryElementwiseArithmetic #

#include <add.hpp>

要素ごとの加算操作。

パブリック関数

inline Add()#: 初期化されていない加算操作を構築します。

Add(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

加算操作を構築します。

Output [d0, ...]

パラメーター:

arg – 入力テンソルを生成する Output。[d0, ...]
arg1 – 2 番目の入力テンソルを生成する Output。[d0, ...]
auto_broadcast – 自動ブロードキャスト仕様。デフォルトは Numpy スタイルの暗黙的なブロードキャストです。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Asin : public ov::op::util::UnaryElementwiseArithmetic #

#include <asin.hpp>

要素ごとの逆正弦 (arcsin) 操作。

パブリック関数

Asin() = default#: arcsin 操作を構築します。

Asin(const Output<Node> &arg)#

arcsin 操作を構築します。

Output [d1, ...]

パラメーター:: arg – 入力テンソルを生成する Output。[d1, ...]

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Assign : public ov::op::util::AssignBase #

#include <assign.hpp>

Assign 操作は、入力値を variable_id 変数に設定します

パブリック関数

Assign(const Output<Node> &new_value, const std::string &variable_id)#

Assign 操作を構築します。

パラメーター:

new_value – 入力テンソルを生成する Node。
variable_id – 更新する変数の識別子

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline virtual std::string get_variable_id() const override#: 対応する変数の識別子を返します。

class Assign : public ov::op::util::AssignBase #

#include <assign.hpp>

Assign 操作は、入力値を variable_id 変数に設定します

パブリック関数

Assign(const Output<Node> &new_value, const std::shared_ptr<util::Variable> &variable)#

Assign 操作を構築します。

パラメーター:

new_value – 入力テンソルを生成するノード。
variable – Assign/ReadValue ノードのペア間で要素タイプ、形状、識別子を保存および同期するクラス。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline virtual std::string get_variable_id() const override#: 対応する変数の識別子を返します。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Atan : public ov::op::util::UnaryElementwiseArithmetic #

#include <atan.hpp>

要素ごとの逆正接 (arctan) 操作。

パブリック関数

Atan() = default#: arctan 操作を構築します。

Atan(const Output<Node> &arg)#

arctan 操作を構築します。

Output [d1, ...]

パラメーター:: arg – 入力テンソルを生成する Output。[d1, ...]

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Atanh : public ov::op::util::UnaryElementwiseArithmetic #

#include <atanh.hpp>

要素ごとの逆双曲正接操作。

パブリック関数

Atanh() = default#: Atanh 操作を構築します。

Atanh(const Output<Node> &arg)#

Atanh 操作を構築します。

Output [d1, ...]

パラメーター:: arg – 入力テンソルを生成する Output。[d1, ...]

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class AvgPool : public ov::op::util::AvgPoolBase #

#include <avg_pool.hpp>

バッチ平均プーリング操作。

パブリック関数

AvgPool() = default#: バッチ平均プーリング操作を構築します。

AvgPool(const Output<Node> &arg, const Strides &strides, const Shape &pads_begin, const Shape &pads_end, const Shape &kernel, bool exclude_pad, RoundingType rounding_type = RoundingType::FLOOR, const PadType &auto_pad = PadType::EXPLICIT)#

バッチ平均プーリング操作を構築します。

パラメーター:

arg – 入力データ・バッチ・テンソルを生成する出力。.[d1, dn]
strides – ストライド。[n]
pads_begin – パディング形状の始まり。[n]
pads_end – パディング形状の終わり。[n]
kernel – カーネル形状。[n]
exclude_pad – false の場合、平均にはパディング要素が含まれ、それぞれが数値ゼロとして扱われます。true の場合、平均を計算するときにパディング要素は完全に無視されます。
rounding_type – 出力形状を計算するときに、天井丸めタイプまたは床丸めタイプを使用するかどうか。
auto_pad – 追加のパディング次元に使用するパディングタイプ

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class AvgPool : public ov::op::util::AvgPoolBase #

#include <avg_pool.hpp>

バッチ平均プーリング操作。

パブリック関数

AvgPool() = default#: バッチ平均プーリング操作を構築します。

バッチ平均プーリング操作を構築します。

パラメーター:

arg – 入力データ・バッチ・テンソルを生成する出力。.[d1, dn]
strides – ストライド。[n]
pads_begin – パディング形状の始まり。[n]
pads_end – パディング形状の終わり。[n]
kernel – カーネル形状。[n]
exclude_pad – false の場合、平均にはパディング要素が含まれ、それぞれが数値ゼロとして扱われます。true の場合、平均を計算するときにパディング要素は完全に無視されます。
rounding_type – 出力形状を計算するときに、天井丸めタイプまたは床丸めタイプを使用するかどうか。
auto_pad – 追加のパディング次元に使用するパディングタイプ

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class BatchNormInference : public ov::op::Op #

#include <batch_norm.hpp>

BatchNormInference 操作。

パブリック関数

BatchNormInference(const Output<Node> &input, const Output<Node> &gamma, const Output<Node> &beta, const Output<Node> &mean, const Output<Node> &variance, double epsilon)#

パラメーター:

input – [., C, …]
gamma – 正規化された値のガンマ・スケーリング。 [C]
beta – スケール正規化値に追加されたバイアス [C]
mean – 平均正規化の値 [C]
variance – 分散正規化の値 [C]
epsilon – 入力の分散が 0 の場合は 0 除算を避けます

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class BatchNormInference : public ov::op::Op #

#include <batch_norm.hpp>

BatchNormInference 操作。

パブリック関数

BatchNormInference(const Output<Node> &input, const Output<Node> &gamma, const Output<Node> &beta, const Output<Node> &mean, const Output<Node> &variance, double epsilon)#

パラメーター:

input – [., C, …]
gamma – 正規化された値のガンマ・スケーリング。[C]
beta – スケール正規化値に追加されたバイアス [C]
mean – 平均正規化の値 [C]
variance – 分散正規化の値 [C]
epsilon – 入力の分散が 0 の場合は 0 除算を避けます

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class BatchToSpace : public ov::op::Op #

#include <batch_to_space.hpp>

BatchToSpace は、データテンソルのバッチ次元のデータを空間次元に並べ替えます。

注

バッチ次元の値は、空間ブロック次元に移動されます。

 出力ノードは次の形状のテンソルを生成します: `[batch / (block_shape[0] * block_shape[1] * ... * block_shape[N - 1]), 
D_1 * block_shape[1] - crops_begin[1] - crops_end[1], 
D_2 * block_shape[2] - crops_begin[2] - crops_end[2], ..., 
D_{N - 1} * block_shape[N - 1] - crops_begin[N - 1] - `data` 入力と同じタイプの `crops_end[N - 1]`。

パブリック関数

BatchToSpace(const Output<Node> &data, const Output<Node> &block_shape, const Output<Node> &crops_begin, const Output<Node> &crops_end)#

BatchToSpace 操作を構築します。

パラメーター:

data – データテンソルを生成する Node
block_shape – 移動する値のブロックサイズ
crops_begin – data 入力の各軸に沿って最初から切り取る量を指定します
crops_end – data 入力の各軸に沿って終了点から切り取る量を指定します。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class BinaryConvolution : public ov::op::util::ConvolutionFwdPropBase #

#include <binary_convolution.hpp>

BinaryConvolution 操作。

パブリック関数

BinaryConvolution() = default#: バイナリー畳み込み操作を構築します。

BinaryConvolution(const Output<Node> &data, const Output<Node> &kernel, const Strides &strides, const CoordinateDiff &pads_begin, const CoordinateDiff &pads_end, const Strides &dilations, BinaryConvolutionMode mode, float pad_value, const PadType &auto_pad = PadType::EXPLICIT)#

バイナリー畳み込み操作を構築します。

Output [N, C_OUT, R1, ... Rf]

パラメーター:

データ – 入力データ・バッチ・テンソルを生成するノード。
kernel – フィルターテンソルを生成するノード。
strides – ストライド。
pads_begin – パディング形状の始まり。
pads_end – パディング形状の終わり。
dilations – 拡張。
mode – 入力テンソル 0/1 値と重み 0/1 がどのように解釈されるか定義します。
pad_value – パッド領域を埋めるのに使用される浮動小数点値。
auto_pad – パディングサイズを自動的に計算するパッドタイプ。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline const BinaryConvolutionMode &get_mode() const#

戻り値:: 畳み込みモード。

inline float get_pad_value() const#

戻り値:: パッド値。

class BitwiseAnd : public ov::op::util::BinaryElementwiseBitwise #

#include <bitwise_and.hpp>

要素ごとのビット AND 操作。

パブリック関数

BitwiseAnd() = default#: ビット単位の AND 操作を構築します。

BitwiseAnd(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

ビット単位の AND 操作を構築します。

Output [d0, ...]

パラメーター:

arg – 入力テンソルを生成する Output[d0, ...]
arg1 – 2 番目の入力テンソルを生成する Output。[d0, ...]
auto_broadcast – 自動ブロードキャスト仕様。デフォルトは Numpy スタイルの暗黙的なブロードキャストです。

class BitwiseNot : public ov::op::Op #

#include <bitwise_not.hpp>

要素ごとのビット否定操作。

パブリック関数

BitwiseNot() = default#: ビットごとの否定操作を構築します。

BitwiseNot(const Output<Node> &arg)#

ビットごとの否定操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class BitwiseOr : public ov::op::util::BinaryElementwiseBitwise #

#include <bitwise_or.hpp>

要素ごとのビット OR 操作。

パブリック関数

BitwiseOr() = default#: ビット単位の OR 操作を構築します。

BitwiseOr(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

ビット単位の OR 操作を構築します。

Output [d0, ...]

パラメーター:

arg – 入力テンソルを生成する Output[d0, ...]
arg1 – 2 番目の入力テンソルを生成する Output。[d0, ...]
auto_broadcast – 自動ブロードキャスト仕様。デフォルトは Numpy スタイルの暗黙的なブロードキャストです。

class BitwiseXor : public ov::op::util::BinaryElementwiseBitwise #

#include <bitwise_xor.hpp>

要素ごとのビット XOR 操作。

パブリック関数

BitwiseXor() = default#: ビット単位の XOR 操作を構築します。

BitwiseXor(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

ビット単位の XOR 操作を構築します。

Output [d0, ...]

パラメーター:

arg – 入力テンソルを生成する Output[d0, ...]
arg1 – 2 番目の入力テンソルを生成する Output。[d0, ...]
auto_broadcast – 自動ブロードキャスト仕様。デフォルトは Numpy スタイルの暗黙的なブロードキャストです。

class Broadcast : public ov::op::util::BroadcastBase #

#include <broadcast.hpp>

入力テンソルに軸を “追加” し、必要に応じて入力から要素を新しい軸に沿って複製する操作。

パブリック関数

Broadcast() = default#: ブロードキャスト操作を構築します。

Broadcast(const Output<Node> &arg, const Output<Node> &target_shape, const Output<Node> &axes_mapping, const BroadcastModeSpec &broadcast_spec = BroadcastType::EXPLICIT)#

ブロードキャスト操作を構築します。

パラメーター:

arg – ブロードキャストされる入力テンソル。
target_shape – 出力テンソルの形状。
axes_mapping – 入力軸に対応する結果内の軸の位置 (0 ベース)。‘Arg’ テンソルは残りの軸に沿ってブロードキャストされます。例えば、Input Shape - [3, 4]、ターゲット Shape - [3, 5, 4, 4] axes_mapping - [0, 2] => 軸 1 と 3 に沿って Broadcast します。 axes_mapping - [0, 3] => 軸 1 と 2 に沿って Broadcast します。
broadcast_spec – ブロードキャスト軸を決定するために使用する Broadcast 仕様。明示的 (なし) 以外のモードを使用する場合は、‘axes_mapping’ を指定しないでください。

Broadcast(const Output<Node> &arg, const Output<Node> &target_shape, const BroadcastModeSpec &broadcast_spec = BroadcastType::NUMPY)#

ブロードキャスト操作を構築します。

パラメーター:

arg – ブロードキャストされる入力テンソル。
target_shape – 出力テンソルの形状。
broadcast_spec – ブロードキャスト軸を決定するために使用する Broadcast 仕様

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual std::pair<bool, AxisSet> get_broadcast_axes() const override#

戻り値:: ブロードキャスト軸を完全に決定できる場合は true および AxisSet です。

virtual bool evaluate(ov::TensorVector &outputs, const ov::TensorVector &inputs) const override#

input_values の op を評価し、結果を output_values に格納します。

パラメーター:

output_values – 計算する出力のテンソル。結果ごとに 1 つ
input_values – 入力用のテンソル。入力ごとに 1 つ

戻り値:

成功したら true

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Broadcast : public ov::op::util::BroadcastBase #

#include <broadcast.hpp>

入力テンソルに軸を “追加” し、必要に応じて入力から要素を新しい軸に沿って複製する操作。

パブリック関数

Broadcast() = default#: ブロードキャスト操作を構築します。

Broadcast(const Output<Node> &arg, const Output<Node> &target_shape, const Output<Node> &axes_mapping, const AutoBroadcastSpec &broadcast_spec = AutoBroadcastSpec())#

ブロードキャスト操作を構築します。

パラメーター:

arg – ブロードキャストされる入力テンソル。
target_shape – 出力テンソルの形状。
axes_mapping – 入力軸に対応する結果内の軸の位置 (0 ベース)。‘Arg’ テンソルは残りの軸に沿ってブロードキャストされます。例えば、Input Shape - [3, 4]、ターゲット Shape - [3, 5, 4, 4] axes_mapping - [0, 2] => 軸 1 と 3 に沿って Broadcast します。 axes_mapping - [0, 3] => 軸 1 と 2 に沿って Broadcast します。
broadcast_spec – ブロードキャスト軸を決定するために使用する Broadcast 仕様。‘axes_mapping’ は broadcast_spec が NONE でない場合無視されます。

Broadcast(const Output<Node> &arg, const Output<Node> &target_shape, const AutoBroadcastSpec &broadcast_spec = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

ブロードキャスト操作を構築します。

パラメーター:

arg – ブロードキャストされる入力テンソル。
target_shape – 出力テンソルの形状。
broadcast_spec – ブロードキャスト軸を決定するために使用する Broadcast 仕様

inline const AutoBroadcastSpec &get_broadcast_spec() const#

戻り値:: Broadcast 仕様。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool evaluate(ov::TensorVector &outputs, const ov::TensorVector &inputs) const override#

input_values の op を評価し、結果を output_values に格納します。

パラメーター:

output_values – 計算する出力のテンソル。結果ごとに 1 つ
input_values – 入力用のテンソル。入力ごとに 1 つ

戻り値:

成功したら true

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Bucketize : public ov::op::Op #

#include <bucketize.hpp>

境界に基づいて入力をバケット化する操作。

パブリック関数

Bucketize(const Output<Node> &data, const Output<Node> &buckets, const element::Type output_type = element::i64, const bool with_right_bound = true)#

Bucketize ノードを構築します。

パラメーター:

data – バケット化する Input データ
buckets – バケットのソートされた一意の境界の 1 次元
output_type – Output テンソルタイプは “i64” または “i32” で、デフォルトは “i64” です。
with_right_bound – バケットが区間の右端または左端を含むかどうかを示します。デフォルトは true で右端を含むです。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Ceiling : public ov::op::util::UnaryElementwiseArithmetic #

#include <ceiling.hpp>

要素ごとの天井操作。

パブリック関数

Ceiling() = default#: 天井操作を構築します。

Ceiling(const Output<Node> &arg)#

天井操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Clamp : public ov::op::util::UnaryElementwiseArithmetic #

#include <clamp.hpp>

入力ノードのすべての要素に対してクリッピング操作を実行します。

<min;max> の範囲外にあるすべての入力値は、<min;max> 範囲のどちらにあるかに応じて ‘min’ または ‘max’ に設定されます。範囲内の値は変更されません。

パブリック関数

Clamp(const Output<Node> &data, const double min, const double max)#

Clamp ノードを構築します。

パラメーター:

data – 入力テンソルを生成する Node
min – <min;max> 範囲の下限
min – <min;max> 範囲の上限

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Col2Im : public ov::op::Op #

#include <col2im.hpp>

スライディング・ブロックを画像テンソルに結合するオペレーター。

パブリック関数

Col2Im(const Output<Node> &data, const Output<Node> &output_size, const Output<Node> &kernel_size, const Strides &strides = Strides{1, 1}, const Strides &dilations = Strides{1, 1}, const Shape &pads_begin = Shape{0, 0}, const Shape &pads_end = Shape{0, 0})#

Col2Im 操作を構築します。

パラメーター:

data – データ付き Input テンソル
output_size – 出力画像の空間次元の Shape
kernel_size – スライディング・ブロックのサイズ
strides – 入力空間次元内のスライディング・ブロック内のストライド
dilations 要素のローカルストライド
pads_begin – 各空間軸の先頭のパディング。未定義の場合はパディングは適用されません。
pads_end – 各空間軸の末尾のパディング。未定義の場合はパディングは適用されません。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Concat : public ov::op::Op #

#include <concat.hpp>

連結操作。

パブリック関数

Concat() = default#: 連結操作を構築します。

Concat(const OutputVector &args, int64_t axis)#

連結操作を構築します。

パラメーター:

arg – 入力テンソルを生成する出力
axis – 入力テンソルを連結する軸

Concat(const NodeVector &args, int64_t axis)#

連結操作を構築します。

パラメーター:

arg – 入力テンソルを生成するノード
axis – 入力テンソルを連結する軸

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline int64_t get_concatenation_axis() const#

戻り値:: 連結軸。

inline int64_t get_axis() const#

戻り値:: 連結軸。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Constant : public ov::op::Op #

#include <constant.hpp>

定数のクラス。

パブリック関数

Constant(const ov::Tensor &tensor)#

ov::Tensor から定数を初期化します。

パラメーター:: tensor – データを持つ ov::Tensor

template<typename T> inline Constant(const element::Type &type, const Shape &shape, const std::vector<T> &values)#

テンソル定数を構築します。

パラメーター:

type – テンソル定数の要素タイプ
shape – テンソル定数の形状
values – テンソル定数を初期化するリテラルのベクトル値のサイズは形状のサイズと一致する必要があります。

Constant(const element::Type &type, const Shape &shape)#: 初期化されていない定数を作成します。

template<class T, class = typename std::enable_if<std::is_fundamental<T>::value>::type> inline Constant(const element::Type &type, const Shape &shape, T value)#

均一なテンソル定数を構築します。

パラメーター:

type – テンソル定数の要素タイプ
shape – テンソル定数の形状
values – 均一テンソル定数を初期化するスカラー値は指定された形状にブロードキャストされます。

Constant(const element::Type &type, const Shape &shape, const std::vector<std::string> &values)#

テンソル定数を構築します。このコンストラクターは主に定数の逆シリアル化をサポートします。

パラメーター:

type – テンソル定数の要素タイプ
shape – テンソル定数の形状
values – 定数データとして使用する文字列値のリスト

Constant(const element::Type &type, const Shape &shape, const void *data)#

指定されたデータでテンソル定数を構築します。

パラメーター:

type – テンソル定数の要素タイプ
shape – テンソル定数の形状
data – 定数データへの void*

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool evaluate(ov::TensorVector &outputs, const ov::TensorVector &inputs) const override#

input_values の op を評価し、結果を output_values に格納します。

パラメーター:

output_values – 計算する出力のテンソル。結果ごとに 1 つ
input_values – 入力用のテンソル。入力ごとに 1 つ

戻り値:

成功したら true

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

Shape get_shape_val() const#: 定数ノードの値を Shape オブジェクトとして返します。element::i64 ノードでのみ使用でき、負の値はゼロとして解釈されます。

Strides get_strides_val() const#: 定数ノードの値を Strides オブジェクトとして返します。element::i64 ノードでのみ使用でき、負の値はゼロとして解釈されます。

Coordinate get_coordinate_val() const#: 定数ノードの値を Coordinate オブジェクトとして返します。element::i64 ノードでのみ使用でき、負の値はゼロとして解釈されます。

CoordinateDiff get_coordinate_diff_val() const#: 定数ノードの値を CoordinateDiff オブジェクトとして返します。element::i64 ノードでのみ使用でき、負の値はゼロとして解釈されます。

AxisVector get_axis_vector_val() const#: 定数ノードの値を AxisVector オブジェクトとして返します。element::i64 ノードでのみ使用でき、負の値はゼロとして解釈されます。

AxisSet get_axis_set_val() const#: 定数ノードの値を AxisSet オブジェクトとして返します。element::i64 ノードでのみ使用でき、負の値はゼロとして解釈されます。値の繰り返しが許可されます。

size_t get_byte_size() const#: データサイズをバイト単位で返します。

std::vector<std::string> get_value_strings() const#

戻り値:: テンソル定数の初期化リテラル。

template<typename T> inline std::vector<T> cast_vector(int64_t num_elements = -1) const#

Constant の値を T タイプにキャストされたベクトルとして返します。

テンプレート・パラメーター:: T – データベクトルのエントリーがキャストされるタイプ。
パラメーター:: num_elements – (オプション) キャストする要素の数デフォルトではすべての要素を返します
戻り値:: Constant のデータベクトル。

const Tensor get_tensor_view() const#

定数データをテンソルとして表示します。

戻り値:: 定数データを持つ OV::Tensor

const Strides &get_strides() const#

戻り値:: Constant のストライド (バイト単位)。

パブリック静的関数

template<typename T> static inline std::shared_ptr<Constant> create(const element::Type &type, const Shape &shape, const std::vector<T> &values)#

Constant の shared_ptr を構築するラッパー。

パラメーター:

type – テンソル定数の要素タイプ
shape – テンソル定数の形状
values – 定数データとして使用する値のベクトル

template<typename T> static inline std::shared_ptr<Constant> create(const element::Type &type, const Shape &shape, std::initializer_list<T> values)#

Constant の shared_ptr を構築するラッパー。

パラメーター:

type – テンソル定数の要素タイプ
shape – テンソル定数の形状

static inline std::shared_ptr<Constant> create(const element::Type &type, const Shape &shape, const void *memory)#

Constant の shared_ptr を構築するラッパー。

パラメーター:

type – テンソル定数の要素タイプ
shape – テンソル定数の形状
memory – 定数データを含む継続メモリーチャンク。

class Convert : public ov::op::Op #

#include <convert.hpp>

要素ごとのタイプ変換操作。

パブリック関数

Convert() = default#: 変換操作を構築します。

Convert(const Output<Node> &arg, const ov::element::Type &destination_type)#

変換操作を構築します。

パラメーター:

arg – 入力テンソルを生成する Node
destination_type – 出力テンソルの要素タイプ

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ConvertLike : public ov::op::Op #

#include <convert_like.hpp>

要素ごとのタイプ変換操作。

パブリック関数

ConvertLike() = default#: 変換操作を構築します。

ConvertLike(const Output<Node> &data, const Output<Node> &like)#

変換操作を構築します。

パラメーター:

data – 入力テンソルを生成する Node
like – 変換のターゲットタイプ情報を提供する Node

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class ConvertPromoteTypes : public ov::op::Op #

#include <convert_promote_types.hpp>

入力タイプを 1 つの共通データタイプに昇格および変換する要素ごとの操作。

パブリック関数

ConvertPromoteTypes() = default#: 入力タイプを 1 つの共通データタイプに昇格および変換する操作を構築します。

ConvertPromoteTypes(const Output<Node> &input_0, const Output<Node> &input_1, const bool promote_unsafe = false, const bool pytorch_scalar_promotion = false, const element::Type &u64_integer_promotion_target = element::f32)#

入力タイプを 1 つの共通データタイプに昇格および変換する操作を構築します。

パラメーター:

input_0 – 昇格するデータタイプを持つ Node
input_1 – 昇格するデータタイプを持つ Node
promote_unsafe – ビット幅の拡大、大幅な精度の低下、未定義の動作につながる可能性がある昇格を許可するかどうかを示すブール属性
pytorch_scalar_promotion – 数値形式が一致する場合に、スカラー入力を非スカラー入力によって提供されるタイプに昇格するかどうかを示すブール属性
u64_integer_promotion_target – u64 および符号付き整数の昇格結果を選択する要素タイプ属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

bool get_pytorch_scalar_promotion() const#: 数値形式が一致する場合に、スカラー入力を非スカラー入力によって提供されるタイプに昇格するかどうかを示すブール属性を取得します。

void set_pytorch_scalar_promotion(bool pytorch_scalar_promotion)#: 数値形式が一致する場合に、スカラー入力を非スカラー入力によって提供されるタイプに昇格するかどうかを示すブール属性を設定します。

bool get_promote_unsafe() const#: ビット幅の拡大、大幅な精度の低下、未定義の動作につながる可能性がある昇格を許可するかどうかを示すブール属性を取得します。

void set_promote_unsafe(bool promote_unsafe)#: ビット幅の拡大、大幅な精度の低下、未定義の動作につながる可能性がある昇格を許可するかどうかを示すブール属性を設定します。

const element::Type &get_u64_integer_promotion_target() const#: u64 および符号付き整数の昇格結果を選択する要素タイプ属性を取得します。

void set_u64_integer_promotion_target(const element::Type &u64_integer_promotion_target)#: u64 および符号付き整数の昇格結果を選択する要素タイプ属性を設定します。

class Convolution : public ov::op::util::ConvolutionFwdPropBase #

#include <convolution.hpp>

オプションのウィンドウ拡張とストライドを使用したバッチ畳み込み操作。

パブリック関数

Convolution() = default#: バッチ畳み込み演算を構築します。

Convolution(const Output<Node> &data_batch, const Output<Node> &filters, const Strides &strides, const CoordinateDiff &pads_begin, const CoordinateDiff &pads_end, const Strides &dilations, const PadType &auto_pad = PadType::EXPLICIT)#

バッチ畳み込み演算を構築します。

Output [N, C_OUT, R1, ... Rf]

パラメーター:

data_batch – 入力データ・バッチ・テンソルを生成するノード。[N, C_IN, D1, ... Df]
filters – フィルターテンソルを生成するノード。[C_OUT, C_IN, F1, ... Ff]
strides – ストライド。[f]
dilations – 拡張。[f]
pads_begin – パディング形状の始まり。[f]
pads_end – パディング形状の終わり。[f]
auto_pad – パディングサイズを自動的に計算するパッドタイプ。[f]

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class ConvolutionBackpropData : public ov::op::util::ConvolutionBackPropBase #

#include <convolution.hpp>

バッチ畳み込み操作のためのデータバッチのバック・プロパゲーション。

パブリック関数

ConvolutionBackpropData() = default#: バッチ畳み込みデータバッチのバック・プロパゲーション操作を構築します。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

const PartialShape get_output_shape() const#

戻り値:: 出力される空間次元の形状。

class Cos : public ov::op::util::UnaryElementwiseArithmetic #

#include <cos.hpp>

要素ごとの余弦操作。

パブリック関数

Cos() = default#: 余弦操作を構築します。

Cos(const Output<Node> &arg)#

余弦操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Cosh : public ov::op::util::UnaryElementwiseArithmetic #

#include <cosh.hpp>

要素ごとの双曲余弦 (cosh) 操作。

パブリック関数

Cosh() = default#: 双曲余弦演算を構築します。

Cosh(const Output<Node> &arg)#

双曲余弦演算を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class CTCGreedyDecoder : public ov::op::Op #

#include <ctc_greedy_decoder.hpp>

CTCGreedyDecoder 操作。

パブリック関数

CTCGreedyDecoder(const Output<Node> &input, const Output<Node> &seq_len, const bool ctc_merge_repeated)#

CTCGreedyDecoder 操作を構築します。

パラメーター:

input – 貪欲復号化が実行されるロジット
seq_len – シーケンスの長さ
ctc_merge_repeated – 重複ラベルを結合するかどうか

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class CTCGreedyDecoderSeqLen : public ov::op::Op #

#include <ctc_greedy_decoder_seq_len.hpp>

CTCGreedyDecoder を実行するオペレーター。

パブリック関数

CTCGreedyDecoderSeqLen(const Output<Node> &input, const Output<Node> &seq_len, const bool merge_repeated = true, const element::Type &classes_index_type = element::i32, const element::Type &sequence_length_type = element::i32)#

CTCGreedyDecoderSeqLen 操作を構築します。

パラメーター:

input – 貪欲復号化が実行されるロジットの 3D テンソル
seq_len – シーケンス長の 1-D テンソル
merge_repeated – 重複ラベルを結合するかどうか
classes_index_type – 出力 classes_index テンソルタイプを指定します
sequence_length_type – 出力 sequence_length テンソルタイプを指定します

CTCGreedyDecoderSeqLen(const Output<Node> &input, const Output<Node> &seq_len, const Output<Node> &blank_index, const bool merge_repeated = true, const element::Type &classes_index_type = element::i32, const element::Type &sequence_length_type = element::i32)#

CTCGreedyDecoderSeqLen 操作を構築します。

パラメーター:

input – 貪欲復号化が実行されるロジットの 3D テンソル
seq_len – シーケンス長の 1-D テンソル
blank_index – 空白のインデックスをマークするために使用される 1 つの要素を持つスカラーまたは 1-D テンソル
merge_repeated – 重複ラベルを結合するかどうか
classes_index_type – 出力 classes_index テンソルタイプを指定します
sequence_length_type – 出力 sequence_length テンソルタイプを指定します

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline bool get_merge_repeated() const#

merge_repeated 属性を取得します。

戻り値:: Merge_repeated 属性の現在の値

inline void set_merge_repeated(bool merge_repeated)#

merge_repeated 属性を設定します。

パラメーター:: merge_repeated – 属性の新しい値

inline const element::Type &get_classes_index_type() const#

classes_index_type 属性を取得します。

戻り値:: classes_index_type 属性の現在の値

inline void set_classes_index_type(const element::Type &classes_index_type)#

classes_index_type 属性を設定します。

パラメーター:: classes_index_type – classes_index のタイプ

inline const element::Type &get_sequence_length_type() const#

sequence_length_type 属性を取得します。

戻り値:: sequence_length_type 属性の現在の値

inline void set_sequence_length_type(const element::Type &sequence_length_type)#

sequence_length_type 属性を設定します。

パラメーター:: sequence_length_type – シーケンス長のタイプ

class CTCLoss : public ov::op::Op #

#include <ctc_loss.hpp>

CTCLoss 操作。

パブリック関数

CTCLoss(const Output<Node> &logits, const Output<Node> &logit_length, const Output<Node> &labels, const Output<Node> &label_length, const bool preprocess_collapse_repeated = false, const bool ctc_merge_repeated = true, const bool unique = false)#

CTCLoss 操作を構築します。

パラメーター:

logits – 3-D ロジットテンソル
logit_length – バッチからの各オブジェクトの長さの 1-D テンソル
labels – ロジストを使用して尤度が推定されるラベルの 2-D テンソル
label_length – 各ラベルシーケンスの長さの 1-D テンソル
blank_index – 空のインデックスをマークするのに使用されるスカラー
preprocess_collapse_repeated – 損失計算の前にラベルを前処理するフラグ
ctc_merge_repeated – 潜在的な配置で繰り返し文字を結合するフラグ
unique – アライメントと一致させる前にターゲット内の一意の要素を見つけるフラグ

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class CumSum : public ov::op::Op #

#include <cum_sum.hpp>

Tensor 累積和操作。

指定された軸に沿って入力テンソルの累積合計を計算します。

パブリック関数

CumSum() = default#: 累積合計操作を構築します。

CumSum(const Output<Node> &arg, const Output<Node> &axis, const bool exclusive = false, const bool reverse = false)#

累積合計操作を構築します。

パラメーター:

arg – 合計するテンソル
axis – 累積和を実行する軸の位置を指定するゼロ次元テンソル
exclusive – true に設定すると、最上位の要素は含まれません
reverse – true に設定すると、逆方向に合計を実行します

CumSum(const Output<Node> &arg, const bool exclusive = false, const bool reverse = false)#

軸 = 0 の累積合計演算を構築します。

パラメーター:: arg – 合計するテンソル

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class DeformableConvolution : public ov::op::util::DeformableConvolutionBase #

#include <deformable_convolution.hpp>

DeformableConvolution 操作。

パブリック関数

DeformableConvolution() = default#: 変換操作を構築します。

DeformableConvolution(const Output<Node> &arg, const Output<Node> &offsets, const Output<Node> &filters, const Strides &strides, const CoordinateDiff &pads_begin, const CoordinateDiff &pads_end, const Strides &dilations, const PadType &auto_pad = PadType::EXPLICIT, const int64_t group = 1, const int64_t deformable_group = 1)#

変換操作を構築します。

パラメーター:

arg – 入力テンソルを生成する Node
offsets – 変形可能な値テンソルを生成する Node
filters – OIZYX レイアウトでフィルター (カーネル) テンソルを生成する Node
strides – Convolution ストライド
pads_begin – 各軸に沿って先頭に追加されるパディング量例えば、2D 入力の場合、値 (1, 2) は、上に 1 つの要素が追加され、左に 2 つの要素が追加されることを意味します
pads_end – 各軸に沿って終端に追加されるパディング量
dilations – フィルターテンソル内の重み間の幅と高さの距離
auto_pad – パディングの自動計算をどのように行うかを指定します
group – 出力と入力の両方を分割するグループの数
deformable_group – 変形可能な値と出力をチャネル軸に沿って分割するグループの数

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class DeformableConvolution : public ov::op::util::DeformableConvolutionBase #

#include <deformable_convolution.hpp>

DeformableConvolution 操作。

パブリック関数

DeformableConvolution() = default#: 変換操作を構築します。

変換操作を構築します。

パラメーター:

arg – 入力テンソルを生成する Node
offsets – 変形可能な値テンソルを生成する Node
filters – OIZYX レイアウトでフィルター (カーネル) テンソルを生成する Node
strides – 畳み込みストライド
pads_begin – 各軸に沿って先頭に追加されるパディング量例えば、2D 入力の場合、値 (1, 2) は、上に 1 つの要素が追加され、左に 2 つの要素が追加されることを意味します
pads_end – 各軸に沿って終端に追加されるパディング量
dilations – フィルターテンソル内の重み間の幅と高さの距離
auto_pad – パディングの自動計算をどのように行うかを指定します
group – 出力と入力の両方を分割するグループの数
deformable_group – 変形可能な値と出力をチャネル軸に沿って分割するグループの数
bilinear_interpolation_pad – 双線形補間実行モードを決定するフラグフラグが true で、サンプリング位置が特徴マップ境界の外側 1 ピクセル以内にある場合、ゼロパディングされた特徴マップ上で双線形補間が行われます。フラグが false で、サンプリング位置が特徴マップの境界の外側 1 ピクセル以内にある場合、サンプリング位置は特徴マップの内側の境界にシフトします。

DeformableConvolution(const Output<Node> &arg, const Output<Node> &offsets, const Output<Node> &filters, const Output<Node> &mask, const Strides &strides, const CoordinateDiff &pads_begin, const CoordinateDiff &pads_end, const Strides &dilations, const PadType &auto_pad = PadType::EXPLICIT, const int64_t group = 1, const int64_t deformable_group = 1, const bool bilinear_interpolation_pad = false)#

変換操作を構築します。

パラメーター:

arg – 入力テンソルを生成する Node
offsets – 変形可能な値テンソルを生成する Node
filters – OIZYX レイアウトでフィルター (カーネル) テンソルを生成する Node
mask – マスクテンソルを生成する Node
strides – 畳み込みストライド
pads_begin – 各軸に沿って先頭に追加されるパディング量例えば、2D 入力の場合、値 (1, 2) は、上に 1 つの要素が追加され、左に 2 つの要素が追加されることを意味します
pads_end – 各軸に沿って終端に追加されるパディング量
dilations – フィルターテンソル内の重み間の幅と高さの距離
auto_pad – パディングの自動計算をどのように行うかを指定します
group – 出力と入力の両方を分割するグループの数
deformable_group – 変形可能な値と出力をチャネル軸に沿って分割するグループの数
bilinear_interpolation_pad – 双線形補間実行モードを決定するフラグフラグが true で、サンプリング位置が特徴マップ境界の外側 1 ピクセル以内にある場合、ゼロパディングされた特徴マップ上で双線形補間が行われます。フラグが false で、サンプリング位置が特徴マップの境界の外側 1 ピクセル以内にある場合、サンプリング位置は特徴マップの内側の境界にシフトします。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class DeformablePSROIPooling : public ov::op::Op #

#include <deformable_psroi_pooling.hpp>

DeformablePSROIPooling 操作。

パブリック関数

DeformablePSROIPooling(const Output<Node> &input, const Output<Node> &coords, const Output<Node> &offsets, const int64_t output_dim, const float spatial_scale, const int64_t group_size = 1, const std::string mode = "bilinear_deformable", int64_t spatial_bins_x = 1, int64_t spatial_bins_y = 1, float trans_std = 1, int64_t part_size = 1)#

DeformablePSROIPooling 操作を構築します。

パラメーター:

input – 位置依存スコアマップを持つ Input テンソル
coords – ROI 座標を記述する 5 つの要素タプルのリストを持つInput テンソル
offsets – 変換値を持つ Input テンソル
output_dim – プールされた出力チャネル番号
group_size – ROI 領域を分割する行あたりの水平ビンの数。出力の幅と高さを定義します
spatial_scale – ROI 座標を入力スケールからプールする際に使用されるスケールに変換する乗算空間スケール係数
mode – プーリングのモードを指定
spatial_bins_x – ROI を幅にわたって分割するビンの数を指定
spatial_bins_y – ROI を高さにわたって分割するビンの数を指定
no_trans – 3 番目の入力が存在し、変換 (オフセット) 値が含まれているかどうかを指定するフラグ
trans_std – すべての変換 (オフセット) 値が乗算される値
part_size – 出力テンソルの空間次元が分割される部分の数基本的には 3 番目の入力の高さと幅です

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class DepthToSpace : public ov::op::Op #

#include <depth_to_space.hpp>

DepthToSpace は、データテンソルの深さ次元のデータを空間次元に並べ替えます。

Output ノードは次の形状のテンソルを生成します: [N, C/(blocksize * blocksize), H * blocksize, W * blocksize]

注

深度次元の値 (NCHW レイアウトを想定) は、空間ブロックで高さと幅の次元に移動されます。

パブリック関数

DepthToSpace(const Output<Node> &data, const DepthToSpaceMode &mode, std::size_t block_size = 1)#

DepthToSpace 操作を構築します。

パラメーター:

data – 入力テンソルを生成する Node
mode – 入力深度次元をブロック座標に分割する方法を指定します
block_size – 移動する値のブロックサイズ

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class DFT : public ov::op::util::FFTBase #

#include <dft.hpp>

離散フーリエ変換を計算する DFT 操作。

パブリック関数

DFT(const Output<Node> &data, const Output<Node> &axes)#

DFT 操作を構築します。DFT はフルサイズの軸に対して実行されます。

パラメーター:

data – Input データ
axes – DFT を実行する軸

DFT(const Output<Node> &data, const Output<Node> &axes, const Output<Node> &signal_size)#

DFT 操作を構築します。

パラメーター:

data – Input データ
axes – DFT を実行する軸
signal_size – ‘軸’ の信号サイズ

class Divide : public ov::op::util::BinaryElementwiseArithmetic #

#include <divide.hpp>

要素ごとの除算操作。

パブリック関数

inline Divide()#: 除算操作を構築します。

Divide(const Output<Node> &arg0, const Output<Node> &arg1, bool pythondiv, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

除算操作を構築します。

パラメーター:

arg0 – 最初の入力テンソルを生成する Node
arg1 – 2 番目の入力テンソルを生成する Node
pythondiv – 整数タイプには Python スタイルの丸めを使用
auto_broadcast – 自動ブロードキャスト仕様

Divide(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

除算操作を構築します。

パラメーター:

arg0 – 最初の入力テンソルを生成する Node
arg1 – 2 番目の入力テンソルを生成する Node
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Einsum : public ov::op::Op #

#include <einsum.hpp>

Einsum 操作。

パブリック関数

Einsum(const OutputVector &inputs, const std::string &equation)#

Einsum 構築します。

パラメーター:

inputs – Einsum 操作が収縮を実行する Input ノード
equation – アインシュタインの和の慣例

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

void set_equation(std::string equation)#

Einsum 方程式を設定します。

パラメーター:: equation – 設定する方程式の文字列

inline const std::string &get_equation() const#

Einsum 操作の方程式を取得します。

戻り値:: Einsum 方程式

パブリック静的関数

static void parse_equation(const std::string &equation, std::vector<std::string> &input_subscripts, std::string &output_subscript)#

数式の正確さを確認し、入力添え字と出力添え字を抽出します。

パラメーター:

equation – 解析してチェックする式
input_subscripts – 抽出された入力添え字のベクトル
output_subscript – 出力添え字

static std::vector<std::string> extract_labels(const std::string &subscript)#

アルファベット文字または省略記号になるラベルを (下付き文字から) 抽出します。

パラメーター:: subscript – 添字
戻り値:: 入力添え字から出現順に抽出されたラベルのベクトル

class Elu : public ov::op::util::UnaryElementwiseArithmetic #

#include <elu.hpp>

指数線形単位 x < 0 => f(x) = alpha * (exp(x) - 1.) x >= 0 => f(x) = x

パブリック関数

Elu(const Output<Node> &data, const double alpha)#

Elu 操作を構築します。

パラメーター:

data – Input テンソル
alpha – 負の値の乗数

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class EmbeddingSegmentsSum : public ov::op::Op #

#include <embedding_segments_sum.hpp>

指定されたインデックスの埋め込みを返します。

パブリック関数

EmbeddingSegmentsSum() = default#: EmbeddingSegmentsSum 操作を構築します。

EmbeddingSegmentsSum(const Output<Node> &emb_table, const Output<Node> &indices, const Output<Node> &segment_ids, const Output<Node> &num_segments, const Output<Node> &default_index, const Output<Node> &per_sample_weights)#

EmbeddingSegmentsSum 操作を構築します。

EmbeddingSegmentsSum は、与えられた入力テンソルのすべてのインデックスを、そのインデックスの行 (重み行列から) に置き換えることによって出力テンソルを構築します。

パラメーター:

'emb_table' – 形状が [num_emb, emb_dim1, emb_dim2, …] でタイプが T のモジュールの埋め込みルックアップ・テーブルを含むテンソル
'indices' – 形状が [num_indices] でタイプが T_IND のテンソル必須
<tt>segment_ids</tt> – 出力テンソルへのインデックスを持つ、形状が [num_indices] でタイプが T_IND の Tensor値は並べ替える必要があり、繰り返すことができます必須
<tt>num_segments</tt> – セグメントの数を示す T_IND タイプのスカラー必須。
'default_index' – 空の “バッグ” を埋める埋め込みテーブル内のデフォルト・インデックスを含む T_IND タイプのスカラー提供されない場合、空の “バッグ” にはゼロが詰められますオプション
'per_sample_weights' – インデックスと同じ形状で T タイプのテンソル。このテンソルの各値は、各インデックスの埋め込みテーブルからプールされたそれぞれの値と乗算されますオプション。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class EmbeddingBagOffsets : public ov::op::util::EmbeddingBagOffsetsBase #

#include <embeddingbag_offsets.hpp>

指定されたインデックスの埋め込みを返します。

パブリック関数

EmbeddingBagOffsets() = default#: EmbeddingBagOffsets 操作を構築します。

EmbeddingBagOffsets(const Output<Node> &emb_table, const Output<Node> &indices, const Output<Node> &offsets, const Output<Node> &default_index, const Output<Node> &per_sample_weights, const Reduction &reduction = Reduction::SUM)#

EmbeddingBagOffsets 操作を構築します。

EmbeddingBagOffsets は、与えられた入力テンソルのすべてのインデックスを、そのインデックスの行 (重み行列から) に置き換えることによって出力テンソルを構築します。

パラメーター:

emb_table – 形状が [num_emb, emb_dim1, emb_dim2, …] でタイプが T のモジュールの埋め込みルックアップ・テーブルを含むテンソル
indices – 形状が [num_indices] でタイプが T_IND のテンソル必須
offsets – 形状が [バッチ] でタイプが T_IND のテンソル。インデックス内の各 “バッグ” の開始インデックス位置が含まれます必須
default_index – 空の “バッグ” を埋める埋め込みテーブル内のデフォルト・インデックスを含む T_IND タイプのスカラー値が -1 に設定されているか指定されていない場合は、空の “バッグ” にゼロが埋め込まれます負の値を使用した逆インデックスはサポートされていません。オプション。
per_sample_weights – インデックスと同じ形状で T タイプのテンソル。このテンソルの各値は、各インデックスの埋め込みテーブルからプールされたそれぞれの値と乗算されますオプション
reduction – バッグ内の要素をリダクションするのに使用されるアルゴリズムを選択する列挙タイプオプション

class EmbeddingBagOffsetsSum : public ov::op::util::EmbeddingBagOffsetsBase #

#include <embeddingbag_offsets_sum.hpp>

指定されたインデックスの埋め込みを返します。

パブリック関数

EmbeddingBagOffsetsSum() = default#: EmbeddingBagOffsetsSum 操作を構築します。

EmbeddingBagOffsetsSum(const Output<Node> &emb_table, const Output<Node> &indices, const Output<Node> &offsets, const Output<Node> &default_index, const Output<Node> &per_sample_weights)#

EmbeddingBagOffsetsSum 操作を構築します。

EmbeddingBagOffsetsSum は、与えられた入力テンソルのすべてのインデックスを、そのインデックスの行 (重み行列から) に置き換えることによって出力テンソルを構築します。

パラメーター:

emb_table – 形状が [num_emb, emb_dim1, emb_dim2, …] でタイプが T のモジュールの埋め込みルックアップ・テーブルを含むテンソル
indices – 形状が [num_indices] でタイプが T_IND のテンソル必須
offsets – 形状が [バッチ] でタイプが T_IND のテンソル。インデックス内の各 “バッグ” の開始インデックス位置が含まれます必須。
default_index – 空の “バッグ” を埋める埋め込みテーブル内のデフォルト・インデックスを含む T_IND タイプのスカラー値が -1 に設定されているか指定されていない場合は、空の “バッグ” にゼロが埋め込まれます負の値を使用した逆インデックスはサポートされていません。オプション。
per_sample_weights – インデックスと同じ形状で T タイプのテンソル。このテンソルの各値は、各インデックスの埋め込みテーブルからプールされたそれぞれの値と乗算されますオプション。

class EmbeddingBagPacked : public ov::op::util::EmbeddingBagPackedBase #

#include <embeddingbag_packed.hpp>

指定されたインデックスの埋め込みを返します。

パブリック関数

EmbeddingBagPacked() = default#: EmbeddingBagPacked 操作を構築します。

EmbeddingBagPacked(const Output<Node> &emb_table, const Output<Node> &indices, const Output<Node> &per_sample_weights, const Reduction &reduction = Reduction::SUM)#

EmbeddingBagPacked 操作を構築します。

EmbeddingBagPacked は、与えられた入力テンソルのすべてのインデックスを、そのインデックスの行 (重み行列から) に置き換えることによって出力テンソルを構築します。

パラメーター:

emb_table – 形状が [num_emb, emb_dim1, emb_dim2, …] でタイプが T のモジュールの埋め込みルックアップ・テーブルを含む Tensor
indices – 形状が [batch, indices_per_bag] でタイプが T_IND の Tensor必須
per_sample_weights – インデックスと同じ形状で T タイプのテンソル。このテンソルの各値は、各インデックスの埋め込みテーブルからプールされたそれぞれの値と乗算されますオプション。
reduction – バッグ内の要素をリダクションするのに使用されるアルゴリズムを選択する列挙タイプオプション。

class EmbeddingBagPackedSum : public ov::op::util::EmbeddingBagPackedBase #

#include <embeddingbag_packedsum.hpp>

指定されたインデックスの埋め込みを返します。

パブリック関数

EmbeddingBagPackedSum() = default#: EmbeddingBagPackedSum 操作を構築します。

EmbeddingBagPackedSum(const Output<Node> &emb_table, const Output<Node> &indices, const Output<Node> &per_sample_weights)#

EmbeddingBagPackedSum 操作を構築します。

EmbeddingBagPackedSum は、与えられた入力テンソルのすべてのインデックスを、そのインデックスの行 (重み行列から) に置き換えることによって出力テンソルを構築します。

パラメーター:

emb_table – 形状が [num_emb, emb_dim1, emb_dim2, …] でタイプが T のモジュールの埋め込みルックアップ・テーブルを含む Tensor
indices – 形状が [batch, indices_per_bag] でタイプが T_IND の Tensor必須。
per_sample_weigths – インデックスと同じ形状で T タイプのテンソル。このテンソルの各値は、各インデックスの埋め込みテーブルからプールされたそれぞれの値と乗算されますオプション。

class Equal : public ov::op::util::BinaryElementwiseComparison #

#include <equal.hpp>

要素ごとの等価比較操作。

入力

	タイプ	説明
`arg0`	$E [d_{1}, \dots, d_{n}] (n \geq 0)$	任意の形状と要素タイプのテンソル。
`arg1`	$E [d_{1}, \dots, d_{n}] (n \geq 0)$	`arg0` と同じ形状と要素タイプのテンソル。
`autob`	AutoBroadcastSpec	自動ブロードキャスト仕様。

タイプ	説明
$bool [d_{1}, \dots, d_{n}]$	テンソル $T$ 、ここで $T [i_{1}, \dots, i_{n}] = 1 if arg0 [i_{1}, \dots, i_{n}] = arg1 [i_{1}, \dots, i_{n}], else 0$

パブリック関数

inline Equal()#: 等価操作を構築します。

Equal(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

等価操作を構築します。

パラメーター:

arg0 – 最初の入力テンソルを生成する Node
arg1 – 2 番目の入力テンソルを生成する Node
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Erf : public ov::op::util::UnaryElementwiseArithmetic #

#include <erf.hpp>

要素ごとの erf 操作。

パブリック関数

Erf() = default#: floor 操作を構築します。

Erf(const Output<Node> &arg)#

floor 操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Exp : public ov::op::util::UnaryElementwiseArithmetic #

#include <exp.hpp>

要素ごとの自然指数 (exp) 操作。

パブリック関数

Exp() = default#: 指数操作を構築します。

Exp(const Output<Node> &arg)#

指数操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ExperimentalDetectronDetectionOutput : public ov::op::Op #

#include <experimental_detectron_detection_output.hpp>

ExperimentalDetectronDetectionOutput 操作は、位置とスコアの予測に関する情報を使用して非最大抑制を実行し、検出出力を生成します。

パブリック関数

ExperimentalDetectronDetectionOutput(const Output<Node> &input_rois, const Output<Node> &input_deltas, const Output<Node> &input_scores, const Output<Node> &input_im_info, const Attributes &attrs)#

ExperimentalDetectronDetectionOutput 操作を構築します。

パラメーター:

input_rois – Input ROI
input_deltas – Input デルタ
input_scores – Input スコア
input_im_info – Input 画像情報
attrs – Attributes 属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline const Attributes &get_attrs() const#: ExperimentalDetectronDetectionOutput 操作の属性を返します。

void set_attrs(Attributes attrs)#

ExperimentalDetectronDetectionOutput 操作の属性を設定します。

パラメーター:: attrs – 設定する Attributes

struct Attributes#: #include <experimental_detectron_detection_output.hpp>

操作の属性を指定する構造体。

class ExperimentalDetectronGenerateProposalsSingleImage : public ov::op::Op #

#include <experimental_detectron_generate_proposals.hpp>

ExperimentalDetectronGenerateProposalsSingleImage 操作は、入力データに基づいて ROI とスコアを計算します。

パブリック関数

ExperimentalDetectronGenerateProposalsSingleImage(const Output<Node> &im_info, const Output<Node> &anchors, const Output<Node> &deltas, const Output<Node> &scores, const Attributes &attrs)#

ExperimentalDetectronGenerateProposalsSingleImage 操作を構築します。

パラメーター:

im_info – Input 画像情報
anchors – Input アンカー
deltas – Input デルタ
scores – Input スコア
attrs – 操作属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

struct Attributes#: #include <experimental_detectron_generate_proposals.hpp>

操作の属性を指定する構造体。

class ExperimentalDetectronPriorGridGenerator : public ov::op::Op #

#include <experimental_detectron_prior_grid_generator.hpp>

ExperimentalDetectronPriorGridGenerator 操作は、指定されたサイズの以前のグリッドを生成します。

パブリック関数

ExperimentalDetectronPriorGridGenerator(const Output<Node> &priors, const Output<Node> &feature_map, const Output<Node> &im_data, const Attributes &attrs)#

ExperimentalDetectronDetectionOutput 操作を構築します。

パラメーター:

priors – Input 事前確率
feature_map – Input 特徴マップ
im_data – 画像データ
attrs – 属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline const Attributes &get_attrs() const#: この操作の属性を返します。

void set_attrs(Attributes attrs)#

ExperimentalDetectronPriorGridGenerator 操作の属性を設定します。

パラメーター:: attrs – 設定する Attributes

struct Attributes#: #include <experimental_detectron_prior_grid_generator.hpp>

操作の属性を指定する構造体。

class ExperimentalDetectronROIFeatureExtractor : public ov::op::Op #

#include <experimental_detectron_roi_feature.hpp>

ExperimentalDetectronROIFeatureExtractor は、特徴ピラミッドに適用される ROIAlign 操作です。

パブリック関数

ExperimentalDetectronROIFeatureExtractor(const OutputVector &args, const Attributes &attrs)#

ExperimentalDetectronROIFeatureExtractor 操作を構築します。

パラメーター:

args – ExperimentalDetectronROIFeatureExtractor の入力
attrs – 操作属性

ExperimentalDetectronROIFeatureExtractor(const NodeVector &args, const Attributes &attrs)#

ExperimentalDetectronROIFeatureExtractor 操作を構築します。

パラメーター:

args – ExperimentalDetectronROIFeatureExtractor の入力
attrs – 操作属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline const Attributes &get_attrs() const#: この操作の属性を返します。

void set_attrs(Attributes attrs)#

ExperimentalDetectronROIFeatureExtractor の属性を設定します。

パラメーター:: attrs – 設定する Attributes

struct Attributes#: #include <experimental_detectron_roi_feature.hpp>

操作の属性を指定する構造体。

class ExperimentalDetectronTopKROIs : public ov::op::Op #

#include <experimental_detectron_topkrois.hpp>

リポジトリーによると、ExperimentalDetectronTopKROIs 操作は、入力 ROI の確率に適用される TopK 操作です。

パブリック関数

ExperimentalDetectronTopKROIs(const Output<Node> &input_rois, const Output<Node> &rois_probs, size_t max_rois = 0)#

ExperimentalDetectronTopKROIs 操作を構築します。

パラメーター:

input_rois – Input ROI
rois_probs – 入力 ROI の確率
max_rois – 出力 ROI の最大数

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class ExtractImagePatches : public ov::op::Op #

#include <extractimagepatches.hpp>

ExtractImagePatches 操作。

パブリック関数

ExtractImagePatches(const Output<Node> &image, const Shape &sizes, const Strides &strides, const Shape &rates, const PadType &auto_pad)#

ExtractImagePatches 操作を構築します。

パラメーター:

data – 画像パッチを抽出する 4D Input データ
sizes – [size_rows, size_cols] 形式のパッチサイズ
strides – [stride_rows, stride_cols] の形式でのパッチ移動ストライド
rates – パッチを作成する要素選択率。形式は [rate_rows, rate_cols]
auto_pad – パディングタイプ。valid、same_lower、same_upper のいずれかの値を指定できます

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Eye : public ov::op::Op #

#include <eye.hpp>

Tensor Eye 操作。

パブリック関数

Eye(const Output<Node> &num_rows, const Output<Node> &num_columns, const Output<Node> &diagonal_index, const Output<Node> &batch_shape, const ov::element::Type &out_type)#

Eye 操作を構築します。

パラメーター:

num_rows – 行番号付きテンソルを生成する Node
num_rows – 列番号付きテンソルを生成する Node
diagonal_index – 対角のインデックスが 1 であるテンソルを生成する Node
batch_shape – バッチ形状のテンソルを生成する Node
out_type – テンソルの Output タイプ

Eye(const Output<Node> &num_rows, const Output<Node> &num_columns, const Output<Node> &diagonal_index, const ov::element::Type &out_type)#

batch_shape なしで Eye 操作を構築します。

パラメーター:

num_rows – 行番号付きテンソルを生成する Node
num_rows – 列番号付きテンソルを生成する Node
diagonal_index – 対角のインデックスが 1 であるテンソルを生成する Node
out_type – テンソルの Output タイプ

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline const ov::element::Type &get_out_type() const#

戻り値:: 出力テンソルのタイプ。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class FakeConvert : public ov::op::Op #

#include <fake_convert.hpp>

FakeConvert は、入力値を要素単位で量子化し、ターゲットの低精度タイプに対応する値のセットに変換します。

注

FakeConvert は実験的な操作であり、将来変更される可能性があります。

パブリック関数

FakeConvert(const ov::Output<ov::Node> &data, const ov::Output<ov::Node> &scale, std::string destination_type = "f8e4m3")#

FakeConvert 操作を構築します (デフォルトはシフト)。

パラメーター:

data – 入力データテンソル
scale – データ入力のスケール係数を持つ Tensor
destination_type – エミュレートする低精度タイプ。

FakeConvert(const ov::Output<ov::Node> &data, const ov::Output<ov::Node> &scale, const ov::Output<ov::Node> &shift, std::string destination_type = "f8e4m3")#

FakeConvert 操作を構築します。

パラメーター:

data – 入力データテンソル
scale – データ入力のスケール係数を持つ Tensor
shift – データ入力のシフト係数を持つ Tensor
destination_type – エミュレートする低精度タイプ。

FakeConvert(const ov::Output<ov::Node> &data, const ov::Output<ov::Node> &scale, const ov::element::Type &destination_type)#

FakeConvert 操作を構築します (デフォルトはシフト)。

パラメーター:

data – 入力データテンソル
scale – データ入力のスケール係数を持つ Tensor
destination_type – エミュレートする低精度タイプ。

FakeConvert(const ov::Output<ov::Node> &data, const ov::Output<ov::Node> &scale, const ov::Output<ov::Node> &shift, const ov::element::Type &destination_type)#

FakeConvert 操作を構築します。

パラメーター:

data – 入力データテンソル
scale – データ入力のスケール係数を持つ Tensor
shift – データ入力のシフト係数を持つ Tensor
destination_type – エミュレートする低精度タイプ。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class FakeQuantize : public ov::op::Op #

#include <fake_quantize.hpp>

要素ごとに線形量子化を実行するクラス。

注

Input 浮動小数点値は、浮動小数点値の離散セットに量子化されます。

パブリック関数

FakeQuantize(const Output<Node> &data, const Output<Node> &input_low, const Output<Node> &input_high, const Output<Node> &output_low, const Output<Node> &output_high, std::size_t levels, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

FakeQuantize 操作ノードを構築します。

パラメーター:

data – [in] 入力データテンソル
input_low – [in] 入力値の最小制限
input_high – [in] 入力値の最大制限
output_low – [in] 量子化された最小値
output_high – [in] 量子化された最大値
levels – [in] 量子化レベルの数
auto_broadcast – [in] 制限値をブロードキャストするのに使用される自動ブロードキャスト・モード

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Floor : public ov::op::util::UnaryElementwiseArithmetic #

#include <floor.hpp>

要素ごとの floor 操作。

パブリック関数

Floor() = default#: floor 操作を構築します。

Floor(const Output<Node> &arg)#

floor 操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class FloorMod : public ov::op::util::BinaryElementwiseArithmetic #

#include <floor_mod.hpp>

要素ごとの FloorMod 操作。

パブリック関数

inline FloorMod()#: 初期化されていない加算操作を構築します。

FloorMod(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastType::NUMPY)#

floor Mod を構築します。

Output [d0, ...]

パラメーター:

arg – 入力テンソルを生成する Output[d0, ...]
arg1 – 2 番目の入力テンソルを生成する Output。[d0, ...]
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Gather : public ov::op::util::GatherBase #

#include <gather.hpp>

インデックスに従ってデータの軸からスライスをGather します。

パブリック関数

Gather(const Output<Node> &params, const Output<Node> &indices, const Output<Node> &axis)#

パラメーター:

data – スライスが収集されるテンソル
indices – 収集するインデックスを持つ Tensor
axis – テンソルは、データを収集する次元インデックスです

class Gather : public ov::op::util::GatherBase #

#include <gather.hpp>

インデックスに従ってデータの軸からスライスを収集 (Gather) します。

パブリック関数

Gather(const Output<Node> &data, const Output<Node> &indices, const Output<Node> &axis, const int64_t batch_dims = 0)#

パラメーター:

data – スライスが収集されるテンソル
indices – 収集するインデックスを持つ Tensor
axis – テンソルは、データを収集する次元インデックスです
batch_dims – データとインデックス・テンソルのバッチ次元の数 batch_dims = 0 の場合、Gather v7 は Gather v1 と同一です

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Gather : public ov::op::util::GatherBase #

#include <gather.hpp>

インデックスに従ってデータの軸からスライスを収集 (Gather) します。負のインデックスがサポートされており、末尾からの逆インデックスとなります。

ov::op::internal::GatherCompressed によってサブクラス化されます

パブリック関数

Gather(const Output<Node> &data, const Output<Node> &indices, const Output<Node> &axis, const int64_t batch_dims = 0)#

パラメーター:

data – スライスが収集されるテンソル
indices – 収集するインデックスを持つ Tensor
axis – テンソルは、データを収集する次元インデックスです
batch_dims – データとインデックス・テンソルのバッチ次元の数

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class GatherElements : public ov::op::Op #

#include <gather_elements.hpp>

GatherElements 操作。

パブリック関数

GatherElements(const Output<Node> &data, const Output<Node> &indices, const int64_t axis)#

GatherElements 操作を構築します。

パラメーター:

data – 収集されたデータを生成する Node
indices – 操作が要素を収集するインデックスを生成する Node
axis – インデックスを指定する軸を指定します

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class GatherND : public ov::op::util::GatherNDBase #

#include <gather_nd.hpp>

GatherND 操作。

パブリック関数

GatherND(const Output<Node> &data, const Output<Node> &indices, const size_t batch_dims = 0)#

GatherND 操作を構築します。

パラメーター:

data – 収集されたデータを生成する Node
indices – データから要素またはスライスを収集する操作のインデックスを生成する Node
batch_dims – バッチ次元の数を指定します

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class GatherND : public ov::op::util::GatherNDBase #

#include <gather_nd.hpp>

GatherND 操作。

パブリック関数

GatherND(const Output<Node> &data, const Output<Node> &indices, const size_t batch_dims = 0)#

GatherND 操作を構築します。

パラメーター:

data – 収集されたデータを生成する Node
indices – データから要素またはスライスを収集する操作のインデックスを生成する Node
batch_dims – バッチ次元の数を指定します

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class GatherTree : public ov::op::Op #

#include <gather_tree.hpp>

各ステップの ID と親ビーム ID から完全なビームを生成します。

パブリック関数

GatherTree(const Output<Node> &step_ids, const Output<Node> &parent_idx, const Output<Node> &max_seq_len, const Output<Node> &end_token)#

パラメーター:

step_ids – 各ステップごとにインデックスを持つ形状 [MAX_TIME、BATCH_SIZE、BEAM_WIDTH] の Tensor
parent_idx – 親ビームのインデックスを持つ形状 [MAX_TIME、BATCH_SIZE、BEAM_WIDTH] の Tensor
max_seq_len – バッチ内の各シーケンスの最大長を持つ形状 [BATCH_SIZE] の Tensor
end_token – 形状 [MAX_TIME、BATCH_SIZE、BEAM_WIDTH] の Tensor

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Gelu : public ov::op::util::UnaryElementwiseArithmetic #

#include <gelu.hpp>

ガウス誤差線形単位 f(x) = 0.5 * x * (1 + erf( x / sqrt(2) )

パブリック関数

Gelu(const Output<Node> &data)#

Gelu 操作を構築します。

パラメーター:: data – 入力テンソル

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Gelu : public ov::op::util::UnaryElementwiseArithmetic #

#include <gelu.hpp>

ガウス誤差線形単位 f(x) = 0.5 * x * (1 + erf( x / sqrt(2) )、“approximation” = “erf” の場合、f(x) = 0.5 * x * (1 + tanh([sqrt(2 / pi)] * [x + 0.044715^3])、“approximation” = “tanh” の場合。

パブリック関数

Gelu(const Output<Node> &data, GeluApproximationMode mode = GeluApproximationMode::ERF)#

Gelu 操作を構築します。

パラメーター:

data – Input テンソル
mode – 近似モード

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Greater : public ov::op::util::BinaryElementwiseComparison #

#include <greater.hpp>

要素ごとの大なり (greater-than) 操作。

パブリック関数

inline Greater()#: 大なり (greater-than) 操作を構築します。

Greater(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

大なり (greater-than) 操作を構築します。

パラメーター:

arg0 – 最初の入力テンソルを生成する Node
arg1 – 2 番目の入力テンソルを生成する Node
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class GreaterEqual : public ov::op::util::BinaryElementwiseComparison #

#include <greater_eq.hpp>

要素ごとの大なりイコール (greater-than-or-equal) 操作。

パブリック関数

inline GreaterEqual()#: 大なりイコール (greater-than-or-equal) 操作を構築します。

GreaterEqual(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

大なりイコール (greater-than-or-equal) 操作を構築します。

パラメーター:

arg0 – 最初の入力テンソルを生成する Node
arg1 – 2 番目の入力テンソルを生成する Node
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class GridSample : public ov::op::Op #

#include <grid_sample.hpp>

入力テンソルの補間サンプリングを実行するオペレーター。

パブリック関数

GridSample(const Output<Node> &data, const Output<Node> &grid, const Attributes &attributes)#

GridSample 操作を構築します。

パラメーター:

data – Input データテンソル (入力画像)
grid – 正規化された補間座標
attrs – GridSample 属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

struct Attributes#: #include <grid_sample.hpp>

すべての GridSample 属性を含む構造体。

class GroupNormalization : public ov::op::Op #

#include <group_normalization.hpp>

入力テンソルに対する GroupNormalization 操作。

パブリック関数

GroupNormalization(const Output<Node> &data, const Output<Node> &scale, const Output<Node> &bias, int64_t num_groups, double epsilon)#

パラメーター:

data – 正規化される入力テンソル
scale – 各チャネルのスケール値を含むテンソル
bias – 各チャネルのバイアス値を含むテンソル
num_groups – チャネル次元を分割するグループの数
epsilon – GroupNormalization 式でゼロ除算を防ぐ値

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class GRUCell : public ov::op::util::RNNCellBase #

#include <gru_cell.hpp>

GRU セルノードのクラス。

注

このクラスは GRU レイヤー全体ではなく、単一のセルのみを表すことに注意してください。

パブリック関数

GRUCell(const Output<Node> &X, const Output<Node> &initial_hidden_state, const Output<Node> &W, const Output<Node> &R, std::size_t hidden_size)#

GRUCell ノードを構築します。

パラメーター:

X – [in] 入力テンソルの形状は次のようになります: [batch_size, input_size]
initial_hidden_state – [in] 現在のタイムステップにおける隠れ状態テンソルの形状は次のようになります: [batch_size, hidden_size]
W – [in] 重みテンソルの形状は次のようになります: [gates_count * hidden_size, input_size]
R – [in] 再帰重みテンソルの形状は次のようになります: [gates_count * hidden_size, hidden_size]
hidden_size – [in] 再帰セルの隠れユニットの数

GRUCell(const Output<Node> &X, const Output<Node> &initial_hidden_state, const Output<Node> &W, const Output<Node> &R, std::size_t hidden_size, const std::vector<std::string> &activations, const std::vector<float> &activations_alpha, const std::vector<float> &activations_beta, float clip, bool linear_before_reset)#

GRUCell ノードを構築します。

パラメーター:

X – [in] 入力テンソルの形状は次のようになります: [batch_size, input_size]
initial_hidden_state – [in] 現在のタイムステップにおける隠れ状態テンソルの形状は次のようになります: [batch_size, hidden_size]
W – [in] 重みテンソルの形状は次のようになります: [gates_count * hidden_size, input_size]
R – [in] 再帰重みテンソルの形状は次のようになります: [gates_count * hidden_size, hidden_size]
hidden_size – [in] 再帰セルの隠れユニットの数
activations – [in] 再帰セル内で使用される活性化関数のベクトル
activations_alpha – [in] 活性化リストの順に並べられた活性化関数のアルファ・パラメーターのベクトル
activations_beta – [in] 活性化リストの順に並べられた活性化関数のベータ・パラメーターのベクトル
clip – [in] 活性化関数の入力におけるクリッピング範囲 [-clip, clip] を定義する値

GRUCell(const Output<Node> &X, const Output<Node> &initial_hidden_state, const Output<Node> &W, const Output<Node> &R, const Output<Node> &B, std::size_t hidden_size, const std::vector<std::string> &activations = std::vector<std::string>{"sigmoid", "tanh"}, const std::vector<float> &activations_alpha = {}, const std::vector<float> &activations_beta = {}, float clip = 0.f, bool linear_before_reset = false)#

GRUCell ノードを構築します。

パラメーター:

X – [in] 入力テンソルの形状は次のようになります: [batch_size, input_size]
initial_hidden_state – [in] 現在のタイムステップにおける隠れ状態テンソルの形状は次のようになります: [batch_size, hidden_size]
W – [in] 重みテンソルの形状は次のようになります: [gates_count * hidden_size, input_size]
R – [in] 再帰重みテンソルの形状は次のようになります: [gates_count * hidden_size, hidden_size]
hidden_size – [in] 再帰セルの隠れユニットの数
B – [in] 更新ゲート、リセットゲート、および隠しゲートのバイアス (重みと再帰) の合計 linear_before_reset := true の場合、隠しゲートのバイアス (重みと再帰) が別々に配置されます。 Shape: [gates_count * hidden_size] linear_before_reset := false の場合、Shape: [(gates_count + 1) * hidden_size] linear_before_reset := true の場合
activations – [in] 再帰セル内で使用される活性化関数のベクトル
activations_alpha – [in] 活性化リストの順に並べられた活性化関数のアルファ・パラメーターのベクトル
activations_beta – [in] 活性化リストの順に並べられた活性化関数のベータ・パラメーターのベクトル
clip – [in] 活性化関数の入力におけるクリッピング範囲 [-clip, clip] を定義する値
linear_before_reset – [in] リセットゲートの出力を乗算する前に線形変換を適用するかどうか

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class GRUSequence : public ov::op::util::RNNCellBase #

#include <gru_sequence.hpp>

GRUSequence 操作。

パブリック関数

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class HardSigmoid : public ov::op::Op #

#include <hard_sigmoid.hpp>

パラメーター化された、境界のあるシグモイドのような区分線形関数。 min(max(alpha*x + beta, 0), 1)

パブリック関数

HardSigmoid(const Output<Node> &data, const Output<Node> &alpha, const Output<Node> &beta)#

HardSigmoid 操作を構築します。

パラメーター:

data – Input テンソル
alpha – [in] アルファ・パラメーターを表すスカラー値
beta – [in] ベータ・パラメーターを表すスカラー値

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class HSigmoid : public ov::op::util::UnaryElementwiseArithmetic #

#include <hsigmoid.hpp>

A HSigmoid 活性化関数 f(x) = x * min(max(x + 3, 0), 6) / 6 または f(x) = x * min(ReLU(x + 3), 6) / 6.

パブリック関数

HSigmoid(const Output<Node> &arg)#

HSigmoid 操作を構築します。

パラメーター:: data – Input テンソル

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class HSwish : public ov::op::util::UnaryElementwiseArithmetic #

#include <hswish.hpp>

A HSwish 活性化関数 f(x) = x * min(max(x + 3, 0), 6) / 6 or f(x) = x * min(ReLU(x + 3), 6) / 6.

パブリック関数

HSwish(const Output<Node> &arg)#

HSwish (Swish のハードバージョン) 操作を構築します。

パラメーター:: data – Input テンソル

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class I420toBGR : public ov::op::util::ConvertColorI420Base #

#include <i420_to_bgr.hpp>

I420 から BGR 形式へのカラー変換操作。 Input:

Input NV12 画像は 2 つの方法で表現できます: a) 単一平面 (ファイル内にあるとおり): I420 高さ次元は画像の高さの 1.5 倍です。‘C’ 次元は 1 とします。b) 3 つの別々の平面 (多くの物理ビデオソースでこのように使用されます): Y、U、V。この場合、b1) Y 平面の高さは画像の高さと同じです。‘C’ 次元は 1 に等しい b2) U 平面の次元は次の通りです: ‘H’ = image_h / 2; ‘W’ = image_w / 2; ‘C’ = 1。b3) V 平面の次元は次のようになります: ‘H’ = image_h / 2; ‘W’ = image_w / 2; ‘C’ = 1。
サポートされる要素タイプ: u8 またはサポートされている任意の浮動小数点タイプ。出力:
Output ノードは NHWC レイアウトを持ち、形状 HxW は画像の空間次元と同じになります。
出力チャネル数 ‘C’ は、インターリーブ BGR 形式に従って 3 になり、最初のチャネルは B、最後のチャネルは R になります

I420 (YUV) から RGB 空間への各ピクセルの変換は、次の式で表されます: R = 1.164 * (Y - 16) + 1.596 * (V - 128) G = 1.164 * (Y - 16) - 0.813 * (V - 128) - 0.391 * (U - 128) B = 1.164 * (Y - 16) + 2.018 * (U - 128) 次に、R、G、B の値は (0, 255) の範囲にクリップされます

パブリック関数

explicit I420toBGR(const Output<Node> &arg)#

I420 形式の入力画像から変換操作を構築します。I420 形式の定義によれば、ノードの高さの次元は画像の高さの 1.5 倍であるはずため、画像 (w=640、h=480) は NHWC の形状 {N,720,640,1} (高さ*1.5 x 幅) で表されます

パラメーター:: arg – 入力テンソルを生成する Node Input テンソルは、NV12 形式 (YUV) で画像を表します。

explicit I420toBGR(const Output<Node> &arg_y, const Output<Node> &arg_u, const Output<Node> &arg_v)#

NV12 形式の 2 平面入力画像から変換操作を構築します。一般に、画像の Y チャネルは UV チャネルから分離できるため、操作には Y 平面と UV 平面のそれぞれに 2 つのノードが必要になります。Y 平面には 1 つのチャネルがあり、UV には 2 つのチャネルがあり、どちらも ‘NHWC’ レイアウトを想定しています。

パラメーター:

arg_y – Y 平面 (NHWC レイアウト) の入力テンソルを生成する NodeWxH 次元は画像の次元と同じである必要があります。‘C’ 次元は 1 と等しくなります。
arg_u – U 平面 (NHWC レイアウト) の入力テンソルを生成する Node‘H’ は画像の高さの半分、‘W’ は画像の幅の半分、‘C’ の次元は 1 になります。
arg_v – V 平面 (NHWC レイアウト) の入力テンソルを生成する Node‘H’ は画像の高さの半分、‘W’ は画像の幅の半分、‘C’ の次元は 1 になります。

class I420toRGB : public ov::op::util::ConvertColorI420Base #

#include <i420_to_rgb.hpp>

I420 から RGB 形式へのカラー変換操作。Input:

Input NV12 画像は 2 つの方法で表現できます: a) 単一平面 (ファイル内にあるとおり): I420 高さ次元は画像の高さの 1.5 倍です。‘C’ 次元は 1 とします。b) 3 つの別々の平面 (多くの物理ビデオソースでこのように使用されます): Y、U、V。この場合、b1) Y 平面の高さは画像の高さと同じです。‘C’ 次元は 1 に等しい b2) U 平面の次元は次の通りです: ‘H’ = image_h / 2; ‘W’ = image_w / 2; ‘C’ = 1。b3) V 平面の次元は次のようになります: ‘H’ = image_h / 2; ‘W’ = image_w / 2; ‘C’ = 1。
サポートされる要素タイプ: u8 またはサポートされている任意の浮動小数点タイプ。 Output:
Output ノードは NHWC レイアウトを持ち、形状 HxW は画像の空間次元と同じになります。
出力チャネル数 ‘C’ は、インターリーブ RGB 形式に従って 3 になり、最初のチャネルは R、最後のチャネルは B になります

I420 (YUV) から RGB 空間への各ピクセルの変換は、次の式で表されます: R = 1.164 * (Y - 16) + 1.596 * (V - 128) G = 1.164 * (Y - 16) - 0.813 * (V - 128) - 0.391 * (U - 128) B = 1.164 * (Y - 16) + 2.018 * (U - 128) 次に、R、G、B の値は (0, 255) の範囲にクリップされます

パブリック関数

explicit I420toRGB(const Output<Node> &arg)#

パラメーター:: arg – 入力テンソルを生成する Node Input テンソルは、NV12 形式 (YUV) で画像を表します。

explicit I420toRGB(const Output<Node> &arg_y, const Output<Node> &arg_u, const Output<Node> &arg_v)#

パラメーター:

arg_y – Y 平面 (NHWC レイアウト) の入力テンソルを生成する NodeWxH 次元は画像の次元と同じである必要があります。‘C’ 次元は 1 と等しくなります。
arg_u – U 平面 (NHWC レイアウト) の入力テンソルを生成する Node‘H’ は画像の高さの半分、‘W’ は画像の幅の半分、‘C’ の次元は 1 になります。
arg_v – V 平面 (NHWC レイアウト) の入力テンソルを生成する Node‘H’ は画像の高さの半分、‘W’ は画像の幅の半分、‘C’ の次元は 1 になります。

class IDFT : public ov::op::util::FFTBase #

#include <idft.hpp>

逆離散フーリエ変換を計算する IDFT 操作。

パブリック関数

IDFT(const Output<Node> &data, const Output<Node> &axes)#

IDFT 操作を構築します。IDFT はフルサイズの軸に対して実行されます。

パラメーター:

data – Input データ
axes – IDFT を実行する軸

IDFT(const Output<Node> &data, const Output<Node> &axes, const Output<Node> &signal_size)#

IDFT 操作を構築します。

パラメーター:

data – Input データ
axes – IDFT を実行する軸
signal_size – ‘軸’ の信号サイズ

class If : public ov::op::util::MultiSubGraphOp #

#include <if.hpp>

If 操作、

パブリック関数

If(const Output<Node> &execution_condition)#

条件付きで If を構築します。

パラメーター:: execution_condition – 条件ノード

inline const std::shared_ptr<Model> &get_then_body() const#

then_body を ov::Model として取得します。

戻り値:: then_body を ov::Model として返します。

inline const std::shared_ptr<Model> &get_else_body() const#

else_body を ov::Model として取得します。

戻り値:: else_body を ov::Model として返します。

inline void set_then_body(const std::shared_ptr<Model> &body)#

新しい ov::Model を新しい then_body として設定します。

パラメーター:: body – ‘then’ ブランチの新しいボディー

inline void set_else_body(const std::shared_ptr<Model> &body)#

新しい ov::Model を新しい else_body として設定します。

パラメーター:: body – ‘else’ ブランチの新しいボディー

void set_input(const Output<Node> &value, const std::shared_ptr<v0::Parameter> &then_parameter, const std::shared_ptr<v0::Parameter> &else_parameter)#

各サブグラフのパラメーターに関連付けられた操作に新しい入力を設定します

パラメーター:

value – 操作への入力
then_parameter – hen_body のパラメーターまたは nullptr
else_parameter – else_body のパラメーターまたは nullpt

Output<Node> set_output(const std::shared_ptr<v0::Result> &then_result, const std::shared_ptr<v0::Result> &else_result)#

各サブグラフのパラメーターに関連付けられた操作から新しい出力を設定します

パラメーター:

then_result – then_body からの結果
else_parameter – else_body からの結果

戻り値:

操作からの出力

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Interpolate : public ov::op::Op #

#include <interpolate.hpp>

双線形補間を実行するレイヤー。

パブリック関数

Interpolate(const Output<Node> &image, const Output<Node> &output_shape, const Attributes &attrs)#

Interpolate 操作を構築します。

パラメーター:

image – Input 画像
output_shape – 空間軸の Output 形状
attrs – 補間属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

struct Attributes#: #include <interpolate.hpp>

補間の属性を指定する構造体。

class Interpolate : public ov::op::util::InterpolateBase #

#include <interpolate.hpp>

Interpolate 操作。

パブリック関数

Interpolate(const Output<Node> &image, const Output<Node> &output_shape, const Output<Node> &scales, const InterpolateAttrs &attrs)#

‘軸’ 入力なしで Interpolate 操作を構築します。

パラメーター:

image – Input 画像
output_shape – 空間軸の Output 形状
scales – 空間軸のスケール、つまり output_shape / input_shape
attrs – 補間属性

Interpolate(const Output<Node> &image, const Output<Node> &output_shape, const Output<Node> &scales, const Output<Node> &axes, const InterpolateAttrs &attrs)#

‘軸’ 入力を使用して Interpolate 操作を構築します。

パラメーター:

image – Input 画像
output_shape – 空間軸の Output 形状
scales – 空間軸のスケール、つまり output_shape / input_shape
axes – 補間軸
attrs – 補間属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Interpolate : public ov::op::util::InterpolateBase #

#include <interpolate.hpp>

Interpolate 操作。

パブリック関数

Interpolate(const Output<Node> &image, const Output<Node> &scales_or_sizes, const InterpolateAttrs &attrs)#

‘軸’ 入力なしで Interpolate 操作を構築します。

パラメーター:

image – Input 画像
scales_or_sizes – 空間軸のスケール、つまり output_shape / input_shape
attrs – 補間属性

Interpolate(const Output<Node> &image, const Output<Node> &scales_or_sizes, const Output<Node> &axes, const InterpolateAttrs &attrs)#

‘軸’ 入力を使用して Interpolate 操作を構築します。

パラメーター:

image – Input 画像
scales_or_sizes – 空間軸のスケール、つまり output_shape / input_shape
axes – 補間軸
attrs – 補間属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Inverse : public ov::op::Op #

#include <inverse.hpp>

Inverse 操作は、入力テンソル逆を計算します。

パブリック関数

Inverse(const Output<Node> &data, const bool adjoint = false)#

Inverse 操作は、入力行列の逆行列を計算します。逆行列は、バッチのすべての次元を保持しながら、各 MxM 行列ごとに個別に計算されます。

パラメーター:

data –逆行列を計算する Input 行列最後の 2 つのテンソル次元は同じサイズでなければなりません
adjoint – 入力行列の通常の逆行列を返すか、または随伴行列 (共役転置) を返すかを決定するブール値

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class IsFinite : public ov::op::Op #

#include <is_finite.hpp>

NaN 値と Infinity 値を false に、その他の値を true にマッピングするブールマスク。

パブリック関数

IsFinite(const Output<Node> &data)#

IsFinite 操作を構築します。

パラメーター:: data – Input データテンソル

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class IsInf : public ov::op::Op #

#include <is_inf.hpp>

無限値を true にマッピングするブールマスク。

パブリック関数

IsInf(const Output<Node> &data)#

IsInf 操作を構築します。

パラメーター:: data – Input データテンソル

IsInf(const Output<Node> &data, const Attributes &attributes)#

IsInf 操作を構築します。

パラメーター:

data – Input データテンソル
attrs – IsInf 属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

struct Attributes#: #include <is_inf.hpp>

すべての IsInf 属性を含む構造体。

class IsNaN : public ov::op::Op #

#include <is_nan.hpp>

NaN 値を true に、その他の値を false にマッピングするブールマスク。

パブリック関数

IsNaN(const Output<Node> &data)#

IsNaN 操作を構築します。

パラメーター:: data – Input データテンソル

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Less : public ov::op::util::BinaryElementwiseComparison #

#include <less.hpp>

要素ごとの小なり操作。

パブリック関数

inline Less()#: 小なり操作を構築します。

Less(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

小なり操作を構築します。

パラメーター:

arg0 – 最初の入力テンソルを生成する Node
arg1 – 2 番目の入力テンソルを生成する Node
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class LessEqual : public ov::op::util::BinaryElementwiseComparison #

#include <less_eq.hpp>

要素ごとの小なりイコール (less-than-or-equal) 操作。

パブリック関数

inline LessEqual()#: 小なりイコール (less-than-or-equal) 操作を構築します。

LessEqual(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

以下 (less-than-or-equal) 操作を構築します。

パラメーター:

arg0 – 最初の入力テンソルを生成する Node
arg1 – 2 番目の入力テンソルを生成する Node
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Log : public ov::op::util::UnaryElementwiseArithmetic #

#include <log.hpp>

要素ごとの自然対数操作。

パブリック関数

Log() = default#: 自然対数操作を構築します。

Log(const Output<Node> &arg)#

自然対数操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class LogSoftmax : public ov::op::Op #

#include <log_softmax.hpp>

LogSoftmax 操作。

パブリック関数

LogSoftmax(const Output<Node> &arg, const int64_t axis)#

LogSoftmax 操作を構築します。

Output [d0, ...]

パラメーター:

args – 最初の入力テンソルを生成する Node。[d0, ...]
axis – LogSoftmax を計算する軸の位置 (0 ベース)。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class LogicalAnd : public ov::op::util::BinaryElementwiseLogical #

#include <logical_and.hpp>

要素ごとの論理積操作。

パブリック関数

LogicalAnd() = default#: 論理積操作を構築します。

LogicalAnd(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

論理積操作を構築します。

Output [d0, ...]

パラメーター:

arg – 入力テンソルを生成する Output[d0, ...]
arg1 – 2 番目の入力テンソルを生成する Output。[d0, ...]
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class LogicalNot : public ov::op::Op #

#include <logical_not.hpp>

要素ごとの論理否定操作。

パブリック関数

LogicalNot() = default#: 論理否定操作を構築します。

LogicalNot(const Output<Node> &arg)#

論理否定操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class LogicalOr : public ov::op::util::BinaryElementwiseLogical #

#include <logical_or.hpp>

要素ごとの論理和操作。

パブリック関数

LogicalOr(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

論理和操作を構築します。

Output [d0, ...]

パラメーター:

arg0 – 最初の入力テンソルを生成する Node。[d0, ...]
arg1 – 2 番目の入力テンソルを生成する Node。[d0, ...]
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class LogicalXor : public ov::op::util::BinaryElementwiseLogical #

#include <logical_xor.hpp>

要素ごとの排他的論理和操作。

パブリック関数

LogicalXor(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

排他的論理和操作を構築します。

Output [d0, ...]

パラメーター:

arg0 – 最初の入力テンソルを生成する Node。[d0, ...]
arg1 – 2 番目の入力テンソルを生成する Node。[d0, ...]
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Loop : public ov::op::util::SubGraphOp #

#include <loop.hpp>

ボディーをテンソル上で反復処理し、テンソルに蓄積します。

パブリック関数

Loop() = default#: Loop 操作を構築します。

Loop(const Output<Node> &trip_count, const Output<Node> &execution_condition)#

Loop 操作を構築します。

パラメーター:

trip_count – 反復の最大回数を指定する Node
execution_condition – 最初の反復を実行するかどうかを決定する Node

virtual Output<Node> get_concatenated_slices(const Output<Node> &value, int64_t start, int64_t stride, int64_t part_size, int64_t end, int64_t axis) override#

すべての反復からスライスを連結します。

パラメーター:

value – 各反復からスライス値を提供する値
start – スライスの軸上の最初のインデックス
stride – スライスのステップ
part_size – 軸上のスライスのサイズ
end – スライスの軸上の最後のインデックス
axis – スライスする軸

戻り値:

連結されたスライス。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool evaluate(ov::TensorVector &outputs, const ov::TensorVector &inputs) const override#

input_values の op を評価し、結果を output_values に格納します。

パラメーター:

output_values – 計算する出力のテンソル。結果ごとに 1 つ
input_values – 入力用のテンソル。入力ごとに 1 つ

戻り値:

成功したら true

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

struct SpecialBodyPorts#: #include <loop.hpp>

ボディーで入力/出力の目的を定義できます。

class LRN : public ov::op::Op #

#include <lrn.hpp>

要素ごとのローカル応答正規化 (LRN) 操作。

入力

	タイプ	説明
`arg`	$N [n, c, d_{1}, \dots, d_{n}] (n \geq 0)$	任意の形状と数値要素タイプのテンソル。

タイプ	説明
$N [n, c, d_{1}, \dots, d_{n}]$	テンソル $T$ 、ここで $T [n, c, d_{1}, \dots, d_{n}] = \frac{N [n, i, d_{1}, \dots, d_{n}]}{(b i a s + a l p h a * (\sum_{i = m a x (0, (n s i z e - 1) / 2)}^{m i n (C, (n s i z e - 1) / 2) + 1} N [n, i, d_{1}, \dots, d_{n}]^{2})^{2})}$

パブリック関数

LRN() = default#: LRN 操作を構築します。

LRN(const Output<Node> &arg, double alpha, double beta, double bias, size_t size)#

LRN 操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class LSTMCell : public ov::op::util::RNNCellBase #

#include <lstm_cell.hpp>

単一の lstm セルノードのクラス。

関連情報

LSTMSequence、RNNCell、GRUCell

注

次の実装がサポートされます:

peepholes Gers & Schmidhuber (2000) https://ieeexplore.ieee.org/document/861302
入力ゲートと忘却ゲートを結合します。

注

次の式を計算します:

 it = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Pi (.) Ct-1 + Wbi + Rbi) 
ft = f(Xt*(Wf^T) + Ht-1*(Rf^T) + Pf (.)Ct-1 + Wbf + Rbf) 
ct = g(Xt*(Wc^T) + Ht-1*(Rc^T) + Wbc + Rbc) 
Ct = ft (.)Ct-1 + it (.) ct 
ot = f(Xt*(Wo^T) + Ht-1*(Ro^T) + Po (.)Ct + Wbo + Rbo) 
Ht = ot (.) h(Ct) 

* - Is a dot product, 
(.)- is a Hadamard product (element-wise), 
f, g, h - are activation functions.

注

このクラスは、LSTM シーケンスレイヤー全体ではなく、単一のセル (現在の時間ステップ) のみを表します

パブリック関数

LSTMCell(const Output<Node> &X, const Output<Node> &initial_hidden_state, const Output<Node> &initial_cell_state, const Output<Node> &W, const Output<Node> &R, std::size_t hidden_size, LSTMWeightsFormat weights_format = LSTMWeightsFormat::IFCO, const std::vector<std::string> &activations = std::vector<std::string>{"sigmoid", "tanh", "tanh"}, const std::vector<float> &activations_alpha = {}, const std::vector<float> &activations_beta = {}, float clip = 0.f, bool input_forget = false)#

LSTMCell ノードを構築します。

パラメーター:

X – [in] 入力テンソルの形状は次のようになります: [batch_size, input_size].
initial_hidden_state – [in] 現在のタイムステップにおける隠れ状態テンソルの形状は次のようになります: [batch_size, hidden_size]
initial_cell_state – [in] 現在のタイムステップにおけるセル状態テンソルの形状は次のようになります: [batch_size, hidden_size]
W – [in] ゲートの重みテンソルの形状は次のようになります: [4 * hidden_size, input_size]
R – [in] 再帰重みテンソルの形状は次のようになります: [4*hidden_size, hidden_size].
hidden_size – [in] 再帰セルの隠れユニットの数
weights_format – [in] 重みテンソルのゲートの順序デフォルトの形式は、DNNL で使用される IFCO です
activations – [in] 再帰セル内で使用される活性化関数のベクトル
activations_alpha – [in] 活性化リストの順に並べられた活性化関数のアルファ・パラメーターのベクトル
activations_beta – [in] 活性化リストの順に並べられた活性化関数のベータ・パラメーターのベクトル
clip – [in] 活性化関数の入力におけるクリッピング範囲 [-clip, clip] を定義する値
input_forget – [in] 結合入力と忘却ゲートを制御します

LSTMCell(const Output<Node> &X, const Output<Node> &initial_hidden_state, const Output<Node> &initial_cell_state, const Output<Node> &W, const Output<Node> &R, const Output<Node> &B, std::size_t hidden_size, LSTMWeightsFormat weights_format = LSTMWeightsFormat::IFCO, const std::vector<std::string> &activations = std::vector<std::string>{"sigmoid", "tanh", "tanh"}, const std::vector<float> &activations_alpha = {}, const std::vector<float> &activations_beta = {}, float clip = 0.f, bool input_forget = false)#

LSTMCell ノードを構築します。

パラメーター:

X – [in] 入力テンソルの形状は次のようになります: [batch_size, input_size].
initial_hidden_state – [in] 現在のタイムステップにおける隠れ状態テンソルの形状は次のようになります: [batch_size, hidden_size]
initial_cell_state – [in] 現在のタイムステップにおけるセル状態テンソルの形状は次のようになります: [batch_size, hidden_size]
W – [in] 重みテンソルの形状は次のようになります: [4 * hidden_size, input_size]
R – [in] 再帰重みテンソルの形状は次のようになります: [4*hidden_size, hidden_size].
B – [in] 形状が次のゲートのバイアステンソル: [4*hidden_size].
hidden_size – [in] 再帰セルの隠れユニットの数
weights_format – [in] 重みテンソルのゲートの順序デフォルトの形式は、DNNL で使用される IFCO です
activations – [in] 再帰セル内で使用される活性化関数のベクトル
activations_alpha – [in] 活性化リストの順に並べられた活性化関数のアルファ・パラメーターのベクトル
activations_beta – [in] 活性化リストの順に並べられた活性化関数のベータ・パラメーターのベクトル
clip – [in] 活性化関数の入力におけるクリッピング範囲 [-clip, clip] を定義する値
input_forget – [in] 結合入力と忘却ゲートを制御します

LSTMCell(const Output<Node> &X, const Output<Node> &initial_hidden_state, const Output<Node> &initial_cell_state, const Output<Node> &W, const Output<Node> &R, const Output<Node> &B, const Output<Node> &P, std::size_t hidden_size, LSTMWeightsFormat weights_format = LSTMWeightsFormat::IFCO, const std::vector<std::string> &activations = std::vector<std::string>{"sigmoid", "tanh", "tanh"}, const std::vector<float> &activations_alpha = {}, const std::vector<float> &activations_beta = {}, float clip = 0.f, bool input_forget = false)#

LSTMCell ノードを構築します。

パラメーター:

X – [in] 入力テンソルの形状は次のようになります: [batch_size, input_size].
initial_hidden_state – [in] 現在のタイムステップにおける隠れ状態テンソルの形状は次のようになります: [batch_size, hidden_size]
initial_cell_state – [in] 現在のタイムステップにおけるセル状態テンソルの形状は次のようになります: [batch_size, hidden_size]
W – [in] 重みテンソルの形状は次のようになります: [4 * hidden_size, input_size]
R – [in] 再帰重みテンソルの形状は次のようになります: [4*hidden_size, hidden_size].
B – [in] 形状が次のゲートのバイアステンソル: [4*hidden_size].
P – [in] 形状のピープホールの重みテンソル: [3*hidden_size] - 3 は iof ゲートのみに相当します順序は、入力、出力、忘却ゲートです。
hidden_size – [in] 再帰セルの隠れユニットの数
weights_format – [in] 重みテンソルのゲートの順序デフォルトの形式は、DNNL で使用される IFCO です
activations – [in] 再帰セル内で使用される活性化関数のベクトル
activations_alpha – [in] 活性化リストの順に並べられた活性化関数のアルファ・パラメーターのベクトル
activations_beta – [in] 活性化リストの順に並べられた活性化関数のベータ・パラメーターのベクトル
clip – [in] 活性化関数の入力におけるクリッピング範囲 [-clip, clip] を定義する値
input_forget – [in] 結合入力と忘却ゲートを制御します

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class LSTMCell : public ov::op::util::RNNCellBase #

#include <lstm_cell.hpp>

単一の lstm セルノードのクラス。

関連情報

LSTMSequence、RNNCell、GRUCell

注

次の実装がサポートされます:

peepholes Gers & Schmidhuber (2000) https://ieeexplore.ieee.org/document/861302
入力ゲートと忘却ゲートを結合します。

注

次の式を計算します:

 it = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi) 
ft = f(Xt*(Wf^T) + Ht-1*(Rf^T) + Wbf + Rbf) ct = g(Xt*(Wc^T) + Ht-1*(Rc^T) + Wbc + Rbc) 
Ct = ft (.)Ct-1 + it (.) ct 
ot = f(Xt*(Wo^T) + Ht-1*(Ro^T) + Wbo + Rbo) 
Ht = ot (.) h(Ct) 

* - Is a dot product, 
(.)- is a Hadamard product (element-wise), 
f, g, h - are activation functions.

注

このクラスは、LSTM シーケンスレイヤー全体ではなく、単一のセル (現在の時間ステップ) のみを表します

パブリック関数

LSTMCell(const Output<Node> &X, const Output<Node> &initial_hidden_state, const Output<Node> &initial_cell_state, const Output<Node> &W, const Output<Node> &R, std::size_t hidden_size, const std::vector<std::string> &activations = std::vector<std::string>{"sigmoid", "tanh", "tanh"}, const std::vector<float> &activations_alpha = {}, const std::vector<float> &activations_beta = {}, float clip = 0.f)#

LSTMCell ノードを構築します。

パラメーター:

X – [in] 入力テンソルの形状は次のようになります: [batch_size, input_size].
initial_hidden_state – [in] 現在のタイムステップにおける隠れ状態テンソルの形状は次のようになります: [batch_size, hidden_size]
initial_cell_state – [in] 現在のタイムステップにおけるセル状態テンソルの形状は次のようになります: [batch_size, hidden_size]
W – [in] ゲートの重みテンソルの形状は次のようになります: [4 * hidden_size, input_size]
R – [in] 再帰重みテンソルの形状は次のようになります: [4*hidden_size, hidden_size].
hidden_size – [in] 再帰セルの隠れユニットの数
activations – [in] 再帰セル内で使用される活性化関数のベクトル
activations_alpha – [in] 活性化リストの順に並べられた活性化関数のアルファ・パラメーターのベクトル
activations_beta – [in] 活性化リストの順に並べられた活性化関数のベータ・パラメーターのベクトル
clip – [in] 活性化関数の入力におけるクリッピング範囲 [-clip, clip] を定義する値

LSTMCell(const Output<Node> &X, const Output<Node> &initial_hidden_state, const Output<Node> &initial_cell_state, const Output<Node> &W, const Output<Node> &R, const Output<Node> &B, std::size_t hidden_size, const std::vector<std::string> &activations = std::vector<std::string>{"sigmoid", "tanh", "tanh"}, const std::vector<float> &activations_alpha = {}, const std::vector<float> &activations_beta = {}, float clip = 0.f)#

LSTMCell ノードを構築します。

パラメーター:

X – [in] 入力テンソルの形状は次のようになります: [batch_size, input_size].
initial_hidden_state – [in] 現在のタイムステップにおける隠れ状態テンソルの形状は次のようになります: [batch_size, hidden_size]
initial_cell_state – [in] 現在のタイムステップにおけるセル状態テンソルの形状は次のようになります: [batch_size, hidden_size]
W – [in] 重みテンソルの形状は次のようになります: [4 * hidden_size, input_size]
R – [in] 再帰重みテンソルの形状は次のようになります: [4*hidden_size, hidden_size].
B – [in] 形状が次のゲートのバイアステンソル: [4*hidden_size].
hidden_size – [in] 再帰セルの隠れユニットの数
activations – [in] 再帰セル内で使用される活性化関数のベクトル
activations_alpha – [in] 活性化リストの順に並べられた活性化関数のアルファ・パラメーターのベクトル
activations_beta – [in] 活性化リストの順に並べられた活性化関数のベータ・パラメーターのベクトル
clip – [in] 活性化関数の入力におけるクリッピング範囲 [-clip, clip] を定義する値

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class LSTMSequence : public ov::op::util::RNNCellBase #

#include <lstm_sequence.hpp>

lstm シーケンスノードのクラス。

関連情報

LSTMCell、RNNCell、GRUCell

注

これは ONNX 標準で定義された表記法と方程式に従います: onnx/onnx

パブリック関数

inline virtual size_t get_default_output_index() const override#: デフォルト出力の出力を返します。デフォルト出力がない場合はスローします。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class LSTMSequence : public ov::op::util::RNNCellBase #

#include <lstm_sequence.hpp>

lstm シーケンスノードのクラス。

関連情報

LSTMCell、RNNCell、GRUCell

注

これは ONNX 標準で定義された表記法と方程式に従います: onnx/onnx

パブリック関数

inline virtual size_t get_default_output_index() const override#: デフォルト出力の出力を返します。デフォルト出力がない場合はスローします。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class MatMul : public ov::op::Op #

#include <matmul.hpp>

行列乗算を実行するオペレーター。

パブリック関数

MatMul(const Output<Node> &A, const Output<Node> &B, const bool &transpose_a = false, const bool &transpose_b = false)#

行列乗算操作を構築します。

パラメーター:

A – 行列 A
B – 行列 B
transpose_a – 行列 A をトランスポーズする必要がある場合
transpose_b – 行列 B をトランスポーズする必要がある場合

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class MatrixNms : public ov::op::Op #

#include <matrix_nms.hpp>

MatrixNms 操作。

パブリック関数

MatrixNms() = default#: 変換操作を構築します。

MatrixNms(const Output<Node> &boxes, const Output<Node> &scores, const Attributes &attrs)#

MatrixNms 操作を構築します。

パラメーター:

boxes – ボックス座標を生成する Node
scores – ボックスを生成する Node
attrs – 操作の属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline const Attributes &get_attrs() const#: MatrixNms 操作の属性を返します。

struct Attributes#: #include <matrix_nms.hpp>

操作の属性を指定する構造体。

class MaxPool : public ov::op::util::MaxPoolBase #

#include <max_pool.hpp>

バッチ最大プーリング操作。

パブリック関数

MaxPool() = default#: バッチ最大プーリング操作を構築します。

MaxPool(const Output<Node> &arg, const Strides &strides, const Shape &pads_begin, const Shape &pads_end, const Shape &kernel, const op::RoundingType rounding_type = op::RoundingType::FLOOR, const PadType auto_pad = op::PadType::EXPLICIT)#

バッチ最大プーリング操作を構築します。

パラメーター:

arg – 入力データ・バッチ・テンソルを生成するノード
strides – ストライド
pads_begin – パディング形状の始まり
pads_end – パディング形状の終わり
kernel – カーネル形状
rounding_type – 出力形状を計算するときに、天井丸めタイプまたは床丸めタイプを使用するかどうか
auto_pad – パディングサイズを自動的に計算するパッドタイプ

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class MaxPool : public ov::op::util::MaxPoolBase #

#include <max_pool.hpp>

値とインデックスが個別の出力として計算される MaxPooling 操作。

パブリック関数

MaxPool() = default#: 空の MaxPool 操作を構築します。

MaxPool(const Output<Node> &arg, const Strides &strides, const Strides &dilations, const Shape &pads_begin, const Shape &pads_end, const Shape &kernel, const op::RoundingType rounding_type = op::RoundingType::FLOOR, const PadType auto_pad = op::PadType::EXPLICIT, const element::Type index_element_type = element::i64, const int64_t axis = 0)#

パラメーター化された MaxPool 操作を構築します。

パラメーター:

arg – プールされる特徴テンソルを生成するノードの Output
strides – プーリングフィルターのストライド
dilations – プーリングフィルターの拡張
pads_begin – 各空間軸の先頭のパディング。
pads_end – 各空間軸の末尾のパディング。
kernel – カーネル形状
rounding_type – 出力形状を計算するときに、天井丸めタイプまたは床丸めタイプを使用するかどうか
auto_pad – パディングサイズを自動的に計算するパッドタイプ
index_element_type – 選択したインデックスを含む 2 番目の出力テンソルで使用されるデータタイプ
axis – インデックス出力の許容値の上限を計算する開始点として使用する必入力データ形状内の次元を示します

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

const Strides &get_dilations() const noexcept#

戻り値:: プーリングフィルターの拡張

element::Type get_index_element_type() const noexcept#

戻り値:: 2 番目の出力テンソル (インデックス) のデータタイプ。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class MaxPool : public ov::op::util::MaxPoolBase #

#include <max_pool.hpp>

値とインデックスが個別の出力として計算される MaxPooling 操作。

パブリック関数

MaxPool() = default#: 空の MaxPool 操作を構築します。

パラメーター化された MaxPool 操作を構築します。

パラメーター:

arg – プールされる特徴テンソルを生成するノードの Output
strides – プーリングフィルターのストライド
dilations – プーリングフィルターの拡張
pads_begin – 各空間軸の先頭のパディング。
pads_end – 各空間軸の末尾のパディング。
kernel – カーネル形状
rounding_type – 出力形状を計算するときに、天井丸めタイプまたは床丸めタイプを使用するかどうか
auto_pad – パディングサイズを自動的に計算するパッドタイプ
index_element_type – 選択したインデックスを含む 2 番目の出力テンソルで使用されるデータタイプ
axis – インデックス出力の許容値の上限を計算する開始点として使用する必入力データ形状内の次元を示します

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

const Strides &get_dilations() const noexcept#

戻り値:: プーリングフィルターの拡張

element::Type get_index_element_type() const noexcept#

戻り値:: 2 番目の出力テンソル (インデックス) のデータタイプ。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Maximum : public ov::op::util::BinaryElementwiseArithmetic #

#include <maximum.hpp>

要素ごとの最大操作。

パブリック関数

inline Maximum()#: 最大操作を構築します。

Maximum(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

最大操作を構築します。

パラメーター:

arg0 – 最初の入力テンソルを生成する Node
arg1 – 2 番目の入力テンソルを生成する Node
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Minimum : public ov::op::util::BinaryElementwiseArithmetic #

#include <minimum.hpp>

要素ごとの最小操作。

パブリック関数

inline Minimum()#: 最小操作を構築します。

Minimum(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

最小操作を構築します。

パラメーター:

arg0 – 最初の入力テンソルを生成する Node
arg1 – 2 番目の入力テンソルを生成する Node
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Mish : public ov::op::util::UnaryElementwiseArithmetic #

#include <mish.hpp>

自己正規化非単調ニューラル活性化関数 f(x) = x * tanh(log(exp(x) + 1.))

パブリック関数

Mish(const Output<Node> &arg)#

Mish 操作を構築します。

パラメーター:: data – Input テンソル

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Mod : public ov::op::util::BinaryElementwiseArithmetic #

#include <mod.hpp>

Mod は、方向ブロードキャスト・ルールを適用した 2 つの指定されたテンソルを使用して、要素ごとの除算リマインダーを返します。

パブリック関数

inline Mod()#: Mod ノードを構築します。

Mod(const Output<Node> &A, const Output<Node> &B, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

パラメーター:

A – - 被除数テンソル
B – - 除数テンソル
auto_broadcast – 自動ブロードキャスト仕様

virtual bool evaluate(ov::TensorVector &outputs, const ov::TensorVector &inputs) const override#

input_values の op を評価し、結果を output_values に格納します。

パラメーター:

output_values – 計算する出力のテンソル。結果ごとに 1 つ
input_values – 入力用のテンソル。入力ごとに 1 つ

戻り値:

成功したら true

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Multinomial : public ov::op::Op #

#include <multinomial.hpp>

Multinomial は、多項式分布からサンプリングされたクラスのインデックスのシーケンスを作成します。

パブリック関数

Multinomial(const Output<Node> &input, const Output<Node> &num_samples, const ov::element::Type_t convert_type, const bool with_replacement, const bool log_probs, const uint64_t global_seed = 0, const uint64_t op_seed = 0)#

Multinomial は、多項式分布からサンプリングされたクラスのインデックスのシーケンスを作成します。

パラメーター:

probs – 各インデックス位置における、特定のクラスをサンプリングする確率/対数確率を含む Input テンソルAny 浮動小数点精度値が許可されます
num_samples – バッチごとに生成するサンプルの数を決定する単一の値を持つスカラーまたは 1D テンソル値は整数タイプである必要があります
convert_type – 出力クラス・インデックスを変換するデータタイプ許容値: i32/i64
with_replacement – サンプリングされたクラスが出力に複数回出現するかどうか決定するブール値
log_probs – 入力確率を対数確率として扱うかどうか決定するブール値
global_seed – Philox 乱数生成アルゴリズムの最初のシード値 (キー)(詳細は RandomUniform を参照)
op_seed – Philox 乱数生成アルゴリズムの 2 番目のシード値 (カウンター)(詳細は RandomUniform を参照)

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Multiply : public ov::op::util::BinaryElementwiseArithmetic #

#include <multiply.hpp>

要素ごとの乗算演算子。

パブリック関数

inline Multiply()#: 乗算操作を構築します。

Multiply(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

乗算操作を構築します。

パラメーター:

arg0 – 最初の入力テンソルを生成する Node
arg1 – 2 番目の入力テンソルを生成する Node
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class MVN : public ov::op::Op #

#include <mvn.hpp>

平均分散正規化を実行するオペレーター。

パブリック関数

MVN(const Output<Node> &data, bool across_channels = true, bool normalize_variance = true, double eps = 1e-9)#

MVN 操作を構築します。

パラメーター:

data – データ付き Input テンソル
normalize_variance – 分散正規化を行うかどうかをがありますするフラグです。
across_channels – 平均値をチャネル間で共有するかどうかを指定するフラグです。
eps – 値を正規化するときにゼロによる除算を避けるため分散に追加される数値です。

MVN(const Output<Node> &data, AxisSet reduction_axes, bool normalize_variance = true, double eps = 1e-9)#

MVN 操作を構築します。

パラメーター:

data – データ付き Input テンソル
reduction_axes – リデュースを行う軸のリスト
normalize_variance – 分散正規化を行うかどうかをがありますするフラグです。
eps – 値を正規化するときにゼロによる除算を避けるため分散に追加される数値です。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class MVN : public ov::op::Op #

#include <mvn.hpp>

平均分散正規化を実行するオペレーター。

パブリック関数

MVN(const Output<Node> &data, const Output<Node> &reduction_axes, bool normalize_variance, float eps, MVNEpsMode eps_mode)#

MVN 操作を構築します。

パラメーター:

data – データ付き Input テンソル
reduction_axes – リデュースを行う軸のリスト
normalize_variance – 分散正規化を行うかどうかをがありますするフラグです。
eps – 値を正規化するときにゼロによる除算を避けるため分散に追加される数値です。
eps_mode – イプシロンの適用モード

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool evaluate(ov::TensorVector &output_values, const ov::TensorVector &input_values) const override#

input_values の op を評価し、結果を output_values に格納します。

パラメーター:

output_values – 計算する出力のテンソル。結果ごとに 1 つ
input_values – 入力用のテンソル。入力ごとに 1 つ

戻り値:

成功したら true

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Negative : public ov::op::util::UnaryElementwiseArithmetic #

#include <negative.hpp>

要素ごとの負の操作。

パブリック関数

Negative() = default#: 負の操作を構築します。

Negative(const Output<Node> &arg)#

負の操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class NonMaxSuppression : public ov::op::Op #

#include <non_max_suppression.hpp>

要素ごとの加算操作。

パブリック関数

NonMaxSuppression(const Output<Node> &boxes, const Output<Node> &scores, const Output<Node> &max_output_boxes_per_class, const Output<Node> &iou_threshold, const Output<Node> &score_threshold, const BoxEncodingType box_encoding = BoxEncodingType::CORNER, const bool sort_result_descending = true)#

NonMaxSuppression 操作を構築します。

パラメーター:

boxes – ボックス座標を生成する Node
scores – ボックススコアを生成する Node
max_output_boxes_per_class – クラスごとに選択されるボックスの最大数を生成する Node
iou_threshold – 結合しきい値を超える交差を生成する Node
score_threshold – 最小スコアしきい値を生成する Node
box_encoding – ボックスデータのエンコード形式を指定します

NonMaxSuppression(const Output<Node> &boxes, const Output<Node> &scores, const BoxEncodingType box_encoding = BoxEncodingType::CORNER, const bool sort_result_descending = true)#

最後の 3 つの入力に対してデフォルト値で NonMaxSuppression 操作を構築します。

パラメーター:

boxes – Node producing the box coordinates
scores – ボックス等位を生成する Node
box_encoding – ボックスデータのエンコード形式を指定します
sort_result_descending – 選択したボックスをバッチ間で並べ替える必要があるかどうか指定します
output_type – 出力テンソルタイプを指定します

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class NonMaxSuppression : public ov::op::Op #

#include <non_max_suppression.hpp>

NonMaxSuppression 操作。

ov::op::v4::NonMaxSuppression によってサブクラス化されます

パブリック関数

Constructs a NonMaxSuppression operation.

パラメーター:

boxes – Node producing the box coordinates
scores – ボックススコアを生成する Node
max_output_boxes_per_class – クラスごとに選択されるボックスの最大数を生成する Node
iou_threshold – 結合しきい値を超える交差を生成する Node
score_threshold – 最小スコアしきい値を生成する Node
box_encoding – ボックスデータのエンコード形式を指定します
sort_result_descending – 選択したボックスをバッチ間で並べ替える必要があるかどうか指定します
output_type – 出力テンソルタイプを指定します

NonMaxSuppression(const Output<Node> &boxes, const Output<Node> &scores, const BoxEncodingType box_encoding = BoxEncodingType::CORNER, const bool sort_result_descending = true, const ov::element::Type &output_type = ov::element::i64)#

最後の 3 つの入力に対してデフォルト値で NonMaxSuppression 操作を構築します。

パラメーター:

boxes – ボックス座標を生成する Node
scores – ボックス等位を生成する Node
box_encoding – ボックスデータのエンコード形式を指定します
sort_result_descending – 選択したボックスをバッチ間で並べ替える必要があるかどうか指定します
output_type – 出力テンソルタイプを指定します

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class NonMaxSuppression : public ov::op::v3::NonMaxSuppression #

#include <non_max_suppression.hpp>

NonMaxSuppression 操作。

パブリック関数

Constructs a NonMaxSuppression operation.

パラメーター:

boxes – ボックス座標を生成する Node
scores – ボックススコアを生成する Node
max_output_boxes_per_class – クラスごとに選択されるボックスの最大数を生成する Node
iou_threshold – 結合しきい値を超える交差を生成する Node
score_threshold – 最小スコアしきい値を生成する Node
box_encoding – ボックスデータのエンコード形式を指定します
sort_result_descending – 選択したボックスをバッチ間で並べ替える必要があるかどうか指定します
output_type – 出力テンソルタイプを指定します

最後の 3 つの入力に対してデフォルト値で NonMaxSuppression 操作を構築します。

パラメーター:

boxes – ボックス座標を生成する Node
scores – ボックス等位を生成する Node
box_encoding – ボックスデータのエンコード形式を指定します
sort_result_descending – 選択したボックスをバッチ間で並べ替える必要があるかどうか指定します
output_type – 出力テンソルタイプを指定します

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class NonMaxSuppression : public ov::op::Op #

#include <non_max_suppression.hpp>

NonMaxSuppression 操作。

パブリック関数

最後の 4 つの入力に対してデフォルト値で NonMaxSuppression 操作を構築します。

パラメーター:

boxes – ボックス座標を生成する Node
scores – ボックススコアを生成する Node
box_encoding – ボックスデータのエンコード形式を指定します
sort_result_descending – 選択したボックスをバッチ間で並べ替える必要があるかどうか指定します
output_type – 出力テンソルタイプを指定します

NonMaxSuppression(const Output<Node> &boxes, const Output<Node> &scores, const Output<Node> &max_output_boxes_per_class, const BoxEncodingType box_encoding = BoxEncodingType::CORNER, const bool sort_result_descending = true, const ov::element::Type &output_type = ov::element::i64)#

最後にデフォルト値で NonMaxSuppression 操作を構築します。3 つの入力。

パラメーター:

boxes – ボックス座標を生成する Node
scores – ボックススコアを生成する Node
max_output_boxes_per_class – クラスごとに選択されるボックスの最大数を生成する Node
box_encoding – ボックスデータのエンコード形式を指定します
sort_result_descending – 選択したボックスをバッチ間で並べ替える必要があるかどうか指定します
output_type – 出力テンソルタイプを指定します

NonMaxSuppression(const Output<Node> &boxes, const Output<Node> &scores, const Output<Node> &max_output_boxes_per_class, const Output<Node> &iou_threshold, const BoxEncodingType box_encoding = BoxEncodingType::CORNER, const bool sort_result_descending = true, const ov::element::Type &output_type = ov::element::i64)#

最後にデフォルト値で NonMaxSuppression 操作を構築します。2 つの入力。

パラメーター:

boxes – ボックス座標を生成する Node
scores – ボックススコアを生成する Node
max_output_boxes_per_class – クラスごとに選択されるボックスの最大数を生成する Node
iou_threshold – 結合しきい値を超える交差を生成する Node
box_encoding – ボックスデータのエンコード形式を指定します
sort_result_descending – 選択したボックスをバッチ間で並べ替える必要があるかどうか指定します
output_type – 出力テンソルタイプを指定します

最後の入力に対してデフォルト値で NonMaxSuppression 操作を構築します。

パラメーター:

boxes – ボックス座標を生成する Node
scores – ボックススコアを生成する Node
max_output_boxes_per_class – クラスごとに選択されるボックスの最大数を生成する Node
iou_threshold – 結合しきい値を超える交差を生成する Node
score_threshold – 最小スコアしきい値を生成する Node
box_encoding – ボックスデータのエンコード形式を指定します
sort_result_descending – 選択したボックスをバッチ間で並べ替える必要があるかどうか指定します
output_type – 出力テンソルタイプを指定します

NonMaxSuppression(const Output<Node> &boxes, const Output<Node> &scores, const Output<Node> &max_output_boxes_per_class, const Output<Node> &iou_threshold, const Output<Node> &score_threshold, const Output<Node> &soft_nms_sigma, const BoxEncodingType box_encoding = BoxEncodingType::CORNER, const bool sort_result_descending = true, const ov::element::Type &output_type = ov::element::i64)#

Constructs a NonMaxSuppression operation.

パラメーター:

boxes – ボックス座標を生成する Node
scores – ボックススコアを生成する Node
max_output_boxes_per_class – クラスごとに選択されるボックスの最大数を生成する Node
iou_threshold – 結合しきい値を超える交差を生成する Node
score_threshold – 最小スコアしきい値を生成する Node
soft_nms_sigma – Soft-NMS のシグマ・パラメーターを指定する Node
box_encoding – ボックスデータのエンコード形式を指定します
sort_result_descending – 選択したボックスをバッチ間で並べ替える必要があるかどうか指定します
output_type – 出力テンソルタイプを指定します

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class NonZero : public ov::op::Op #

#include <non_zero.hpp>

入力テンソル内のゼロ以外の要素のインデックスを返す NonZero 操作。

注

インデックスは、行優先順序で次元ごとに返されます。例えば、次の出力には 3D 入力テンソル要素の 3 つのインデックスが含まれます: [[0, 0, 2], [0, 1, 1], [0, 1, 2]] 値は [0,0,0], [0,1,1], [2,1,2] の入力要素を指します

パブリック関数

NonZero() = default#: NonZero 操作を構築します。

NonZero(const Output<Node> &arg)#

NonZero 操作を構築します。

注

出力タイプは int64 です。

パラメーター:: arg – 入力テンソルを生成する Node

NonZero(const Output<Node> &arg, const std::string &output_type)#

NonZero 操作を構築します。

パラメーター:

arg – 入力テンソルを生成する Node
output_type – インデックスを作成します現在、‘int64’ または ‘int32’ のみがサポートされています

NonZero(const Output<Node> &arg, const element::Type &output_type)#

NonZero 操作を構築します。

パラメーター:

arg – 入力テンソルを生成する Node
output_type – インデックスを作成します現在、‘int64’ または ‘int32’ のみがサポートされています

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class NormalizeL2 : public ov::op::Op #

#include <normalize_l2.hpp>

L2 ノルムによる正規化。

パブリック関数

NormalizeL2(const Output<Node> &data, const Output<Node> &axes, float eps, EpsMode eps_mode)#

NormalizeL2 操作を構築します。

パラメーター:

data – 入力テンソルを生成する Node
axes – リダクションを計算する軸を示す Node
eps – L2 ノルムに追加されたイプシロン
eps_mode – 除算前に計算された L2 値と eps をどのように組み合わせるか指定します

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class NotEqual : public ov::op::util::BinaryElementwiseComparison #

#include <not_equal.hpp>

要素ごとの不等操作。

パブリック関数

inline NotEqual()#: 不等操作を構築します。

NotEqual(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

不等操作を構築します。

パラメーター:

arg0 – 最初の入力テンソルを生成する Node
arg1 – 2 番目の入力テンソルを生成する Node
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class NV12toBGR : public ov::op::util::ConvertColorNV12Base #

#include <nv12_to_bgr.hpp>

NV12 から RGB 形式へのカラー変換操作。Input:

Input NV12 画像は 2 つの方法で表現できます: a) 単一平面 (ファイル内にあるとおり): NV12 高さ次元は画像の高さの 1.5 倍です。‘C’ 次元は 1 とします。b) 2 つの別々の平面 (多くの物理ビデオソースでこのように使用されます): Y と UV。この場合、b1) Y 平面の高さは画像の高さと同じです。‘C’ 次元は 1 に等しい b2) UV 平面の次元は次の通りです: ‘H’ = image_h / 2; ‘W’ = image_w / 2; ‘C’ = 2.
サポートされる要素タイプ: u8 またはサポートされている任意の浮動小数点タイプ。 Output:
Output ノードは NHWC レイアウトを持ち、形状 HxW は画像の空間次元と同じになります。
出力チャネル数 ‘C’ は、インターリーブ RGB 形式に従って 3 になり、最初のチャネルは B、最後のチャネルは R になります

NV12 (YUV) から RGB 空間への各ピクセルの変換は、次の式で表されます: R = 1.164 * (Y - 16) + 1.596 * (V - 128) G = 1.164 * (Y - 16) - 0.813 * (V - 128) - 0.391 * (U - 128) B = 1.164 * (Y - 16) + 2.018 * (U - 128) 次に、R、G、B の値は (0, 255) の範囲にクリップされます

パブリック関数

explicit NV12toBGR(const Output<Node> &arg)#

NV12 形式の入力画像から変換操作を構築します。NV12 形式の定義によれば、ノードの高さの次元は画像の高さの 1.5 倍であるはずため、画像 (w=640、h=480) は NHWC の形状 {N,720,640,1} (高さ*1.5 x 幅) で表されます

パラメーター:: arg – 入力テンソルを生成する Node Input テンソルは、NV12 形式 (YUV) で画像を表します。

explicit NV12toBGR(const Output<Node> &arg_y, const Output<Node> &arg_uv)#

パラメーター:

arg_y – Y 平面 (NHWC レイアウト) の入力テンソルを生成する NodeWxH 次元は画像の次元と同じである必要があります。‘C’ 次元は 1 と等しくなります。
arg_v – UV 平面 (NHWC レイアウト) の入力テンソルを生成する Node‘H’ は画像の高さの半分、‘W’ は画像の幅の半分、‘C’ の次元は 2 になります。チャネル 0 は ‘U’、チャネル 1 は ‘V’ チャネルを表します

class NV12toRGB : public ov::op::util::ConvertColorNV12Base #

#include <nv12_to_rgb.hpp>

NV12 から RGB 形式へのカラー変換操作。Input:

Input NV12 画像は 2 つの方法で表現できます: a) 単一平面 (ファイル内にあるとおり): NV12 高さ次元は画像の高さの 1.5 倍です。‘C’ 次元は 1 とします。b) 2 つの別々の平面 (多くの物理ビデオソースでこのように使用されます): Y と UV。この場合、b1) Y 平面の高さは画像の高さと同じです。‘C’ 次元は 1 に等しい b2) UV 平面の次元は次の通りです: ‘H’ = image_h / 2; ‘W’ = image_w / 2; ‘C’ = 2.
サポートされる要素タイプ: u8 またはサポートされている任意の浮動小数点タイプ。出力:
Output ノードは NHWC レイアウトを持ち、形状 HxW は画像の空間次元と同じになります。
出力チャネル数 ‘C’ は、インターリーブ RGB 形式に従って 3 になり、最初のチャネルは R、最後のチャネルは B になります

NV12 (YUV) から RGB 空間への各ピクセルの変換は、次の式で表されます: R = 1.164 * (Y - 16) + 1.596 * (V - 128) G = 1.164 * (Y - 16) - 0.813 * (V - 128) - 0.391 * (U - 128) B = 1.164 * (Y - 16) + 2.018 * (U - 128) 次に、R、G、B の値は (0, 255) の範囲にクリップされます

パブリック関数

explicit NV12toRGB(const Output<Node> &arg)#

パラメーター:: arg – 入力テンソルを生成する Node Input テンソルは、NV12 形式 (YUV) で画像を表します。

NV12toRGB(const Output<Node> &arg_y, const Output<Node> &arg_uv)#

パラメーター:

arg_y – Y 平面 (NHWC レイアウト) の入力テンソルを生成する NodeWxH 次元は画像の次元と同じである必要があります。‘C’ 次元は 1 と等しくなります。
arg_v – UV 平面 (NHWC レイアウト) の入力テンソルを生成する Node‘H’ は画像の高さの半分、‘W’ は画像の幅の半分、‘C’ の次元は 2 になります。チャネル 0 は ‘U’、チャネル 1 は ‘V’ チャネルを表します

class OneHot : public ov::op::Op #

#include <one_hot.hpp>

OneHot 操作。

パブリック関数

OneHot() = default#: one-hot 操作を構築します。

OneHot(const Output<Node> &indices, const Output<Node> &depth, const Output<Node> &on_value, const Output<Node> &off_value, int64_t axis)#

one-hot 操作を構築します。

パラメーター:

indices – インデックスを含む Input テンソル
depth – クラスの数とワンホット次元のサイズを指定します
on_value – 入力インデックスによって表される出力テンソル内の位置が取る値を指定します
off_value – 入力インデックスによって表されない出力テンソル内の位置が取る値を指定します
axis – ワンホット表現が追加される軸

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

inline const int64_t &get_axis() const#

戻り値:: ワンホット軸のインデックス

class Op : public ov::Node #

#include <op.hpp>

すべての実際の ops のルート

パブリック関数

inline virtual const ::ov::Node::type_info_t &get_type_info() const override#: ノードのクラスの NodeTypeInfo を返します。type_info への移行中に、クラスがまだ更新されていない場合は、ノードのダミーの type_info を返します。

class Pad : public ov::op::util::PadBase #

#include <pad.hpp>

一般的なパディング操作。

パブリック関数

Pad() = default#: Pad-1 操作を構築します。

Pad(const Output<Node> &arg, const Output<Node> &pads_begin, const Output<Node> &pads_end, const Output<Node> &arg_pad_value, PadMode pad_mode)#

Pad-1 操作を構築します。

パラメーター:

arg – パディングされる出力を生成する入力テンソル。
pads_begin – arg の各軸上の位置 0 の前に追加されるパディング要素の数を指定する出力
pads_end – 各軸の最後の要素の後のパディング要素の数を指定する出力
arg_pad_value – pad_mode が CONSTANT の場合、パディングに使用される値を持つスカラー出力
pad_mode – パディングモード: CONSTANT、EDGE, REFLECT または SYMMETRIC。CONSTANT は arg_pad_value を使用して新しい要素を初期化し、EDGE は arg から最も近い値を使用します。REFLECT および SYMMETRIC は、エッジ (SYMMETRIC) または最後の行/列などで引数を反転して背景をタイル化します。(REFLECT)。

Pad(const Output<Node> &arg, const Output<Node> &pads_begin, const Output<Node> &pads_end, PadMode pad_mode)#

Pad-1 操作を構築します。

パラメーター:

arg – パディングされる出力を生成する入力テンソル。
pads_begin – 追加されるパディング要素の数を指定する出力
pads_end – 各軸の最後の要素の後のパディング要素の数を指定する出力
pad_mode – パディングモード: CONSTANT、EDGE, REFLECT または SYMMETRIC。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

virtual bool evaluate(ov::TensorVector &outputs, const ov::TensorVector &inputs) const override#

input_values の op を評価し、結果を output_values に格納します。

パラメーター:

output_values – 計算する出力のテンソル。結果ごとに 1 つ
input_values – 入力用のテンソル。入力ごとに 1 つ

戻り値:

成功したら true

class Pad : public ov::op::util::PadBase #

#include <pad.hpp>

一般的なパディング操作。

パブリック関数

Pad() = default#: Pad-12 操作を構築します。

Pad(const Output<Node> &arg, const Output<Node> &pads_begin, const Output<Node> &pads_end, PadMode pad_mode)#

Pad-12 操作を構築します。

パラメーター:

arg – パディングされる出力を生成する入力テンソル。
pads_begin – arg の各軸上の位置 0 の前に追加 (または削除) するパディング要素の数を指定する出力
pads_end – 各軸の最後の要素の後に追加 (または削除) するパディング要素の数を指定する出力
pad_mode – パディングモード: CONSTANT、EDGE, REFLECT または SYMMETRIC。

Pad(const Output<Node> &arg, const Output<Node> &pads_begin, const Output<Node> &pads_end, const Output<Node> &arg_pad_value, PadMode pad_mode)#

Pad-12 操作を構築します。

パラメーター:

arg – パディングされる出力を生成する入力テンソル。
pads_begin – arg の各軸上の位置 0 の前に追加 (または削除) するパディング要素の数を指定する出力
pads_end – 各軸の最後の要素の後に追加 (または削除) するパディング要素の数を指定する出力
arg_pad_value – pad_mode が CONSTANT の場合、パディングに使用される値を持つスカラー出力
pad_mode – パディングモード: CONSTANT、EDGE, REFLECT または SYMMETRIC。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

virtual bool evaluate(ov::TensorVector &outputs, const ov::TensorVector &inputs) const override#

input_values の op を評価し、結果を output_values に格納します。

パラメーター:

output_values – 計算する出力のテンソル。結果ごとに 1 つ
input_values – 入力用のテンソル。入力ごとに 1 つ

戻り値:

成功したら true

class Parameter : public ov::op::Op #

#include <parameter.hpp>

モデル・パラメーター

パラメーターは、ユーザー定義モデルに渡される引数を表すノードです。Model の作成には一連のパラメーターが必要です。基本的なグラフ操作では、モデルにパラメーターを添付する必要はありません。

パブリック関数

Parameter() = default#: テンソルタイプ付きのパラメーター・ノードを構築します。

Parameter(const ov::element::Type &element_type, const PartialShape &pshape)#

テンソルタイプ付きのパラメーター・ノードを構築します。

パラメーター:

element_type – パラメーターの要素タイプ
pshape – パラメーターの部分形状

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

Layout get_layout() const#: 現在のレイアウトを返します。設定されていない場合は空の Layout を返します。

void set_layout(const Layout &layout)#

レイアウトのランタイム情報をテンソルに設定します。

パラメーター:: layout – 設定する Layout空の場合 (デフォルトで構築)、レイアウトのランタイム情報は消去されます

class Power : public ov::op::util::BinaryElementwiseArithmetic #

#include <power.hpp>

要素ごとの累乗演算。

入力

	タイプ	説明
`arg0`	$N [d_{1}, \dots, d_{n}] (n \geq 0)$	任意の形状と数値要素タイプのテンソル。
`arg1`	$N [d_{1}, \dots, d_{n}] (n \geq 0)$	`arg0` と同じ形状と要素タイプのテンソル。

タイプ	説明
$N [d_{1}, \dots, d_{n}]$	テンソル $T$ 、ここで $T [i_{1}, \dots, i_{n}] = arg0 [i_{1}, \dots, i_{n}]^{arg1 [i_{1}, \dots, i_{n}]}$

パブリック関数

Power(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

指数操作を構築します。

パラメーター:

arg0 – 最初の入力テンソルを生成する Node
arg1 – 2 番目の入力テンソルを生成する Node
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class PRelu : public ov::op::Op #

#include <prelu.hpp>

パラメーター化された Relu x < 0 => f(x) = x * 傾き x >= 0 => f(x) = x。

パブリック関数

PRelu(const Output<Node> &data, const Output<Node> &slope)#

PRelu 操作を構築します。

パラメーター:

data – Input テンソル
の勾配 – 負の値の乗数

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class PriorBox : public ov::op::Op #

#include <prior_box.hpp>

入力画像のサイズに正規化された指定されたサイズの事前ボックスを生成するレイヤー。

パブリック関数

PriorBox(const Output<Node> &layer_shape, const Output<Node> &image_shape, const Attributes &attrs)#

PriorBox 操作を構築します。

パラメーター:

layer_shape – 事前ボックスが計算されるレイヤーの Shape
layer_shape – 事前ボックスが拡大縮小される画像の Shape
attrs – PriorBox 属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

struct Attributes#: #include <prior_box.hpp>

class PriorBox : public ov::op::Op #

#include <prior_box.hpp>

入力画像のサイズに正規化された指定されたサイズの事前ボックスを生成するレイヤー。

パブリック関数

PriorBox(const Output<Node> &layer_shape, const Output<Node> &image_shape, const Attributes &attrs)#

PriorBox 操作を構築します。

パラメーター:

layer_shape – 事前ボックスが計算されるレイヤーの Shape
layer_shape – 事前ボックスが拡大縮小される画像の Shape
attrs – PriorBox 属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

struct Attributes#: #include <prior_box.hpp>

class PriorBoxClustered : public ov::op::Op #

#include <prior_box_clustered.hpp>

入力画像のサイズに正規化された指定されたサイズの事前ボックスを生成するレイヤー。

パブリック関数

PriorBoxClustered(const Output<Node> &layer_shape, const Output<Node> &image_shape, const Attributes &attrs)#

PriorBoxClustered 操作を構築します。

パラメーター:

layer_shape – 事前ボックスが計算されるレイヤーの Shape
layer_shape – 事前ボックスが拡大縮小される画像の Shape
attrs – PriorBoxClustered 属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

struct Attributes#: #include <prior_box_clustered.hpp>

class Proposal : public ov::op::Op #

#include <proposal.hpp>

Proposal 操作。

ov::op::v4::Proposal によってサブクラス化されます

パブリック関数

Proposal(const Output<Node> &class_probs, const Output<Node> &bbox_deltas, const Output<Node> &image_shape, const Attributes &attrs)#

Proposal 操作を構築します。

パラメーター:

class_probs – クラス確率スコア
bbox_deltas – 境界ボックスのデルタ予測
image_shape – 画像の Shape
attrs – Proposal op 属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

void set_attrs(Attributes attrs)#

Proposal オペレーターの属性を設定します。

パラメーター:: attrs – 設定する Attributes

struct Attributes#: #include <proposal.hpp>

class Proposal : public ov::op::v0::Proposal #

#include <proposal.hpp>

Proposal 操作。

パブリック関数

Proposal(const Output<Node> &class_probs, const Output<Node> &bbox_deltas, const Output<Node> &image_shape, const Attributes &attrs)#

Proposal 操作を構築します。

パラメーター:

class_probs – クラス確率スコア
bbox_deltas – 境界ボックスのデルタ予測
image_shape – 画像の Shape
attrs – Proposal op 属性

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class PSROIPooling : public ov::op::Op #

#include <psroi_pooling.hpp>

PSROIPooling 操作。

パブリック関数

PSROIPooling(const Output<Node> &input, const Output<Node> &coords, const size_t output_dim, const size_t group_size, const float spatial_scale, int spatial_bins_x, int spatial_bins_y, const std::string &mode)#

PSROIPooling 操作を構築します。

パラメーター:

input – Input 特徴マップ {N, C, …}
coords – 境界ボックスの座標
output_dim – Output チャネル番号
group_size – 位置依存スコアをエンコードするグループ数
spatial_scale – 入力特徴マップと入力画像サイズの比率
spatial_bins_x – 入力特徴マップを幅で分割するビンの数
spatial_bins_y – 入力特徴マップを高さで分割するビンの数
mode – プーリングのモード - 平均または双線形

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

void set_output_dim(size_t output_dim)#

出力チャネルの次元サイズを設定します。

パラメーター:: output_dim – チャネルの次元サイズ。

void set_group_size(size_t group_size)#

出力グループ数を設定します。

パラメーター:: group_size – グループの数

void set_spatial_scale(float scale)#

空間スケールを設定します

パラメーター:: scale – 空間スケールの値

void set_spatial_bins_x(int x)#

画像の幅にわたるビン数を設定します。

パラメーター:: x – 幅 (x) 軸上のビン数

void set_spatial_bins_y(int y)#

画像の高さにわたるビン数を設定します。

パラメーター:: y – 高さ (y) 軸上のビン数

void set_mode(std::string mode)#

プーリングモードを設定します。

パラメーター:: mode – プーリングモード名

class RandomUniform : public ov::op::Op #

#include <random_uniform.hpp>

Tensor RandomUniform 操作。

パブリック関数

RandomUniform(const Output<Node> &out_shape, const Output<Node> &min_val, const Output<Node> &max_val, const ov::element::Type &out_type, uint64_t global_seed = 0, uint64_t op_seed = 0, ov::op::PhiloxAlignment alignment = ov::op::PhiloxAlignment::TENSORFLOW)#

RandomUniform 操作を構築します。

パラメーター:

out_shape – 出力形状のテンソルを生成する Node
min_val – 最小値のテンソルを生成する Node
max_val – 最大値をのテンソルを生成する Node
out_type – テンソルの Output タイプ
global_seed – グローバルシード値
op_seed – 運用シード値
alignment – 提供されたシードに基づいて Philox アルゴリズムによって生成された数字の配置

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool constant_fold(OutputVector &output_values, const OutputVector &inputs_values) override#

戻り値:: RandomUniform 操作の定数の折りたたみをオフにします。

const ov::element::Type &get_out_type() const#

戻り値:: 出力テンソルのタイプ。

uint64_t get_global_seed() const#

戻り値:: グローバルシード値。

uint64_t get_op_seed() const#

戻り値:: 運用シード値。

std::pair<uint64_t, uint64_t> get_state() const#

戻り値:: 状態の値。

ov::op::PhiloxAlignment get_alignment() const#

戻り値:: 配置モード。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Range : public ov::op::Op #

#include <range.hpp>

Numpy の arange() に類似した Range 操作。

パブリック関数

Range() = default#: 初期化されてい range 操作を構築します。

Range(const Output<Node> &start, const Output<Node> &stop, const Output<Node> &step, element::Type output_type)#

range 操作を構築します。

パラメーター:

start – 開始値を生成するテンソル。数値要素タイプのスカラーである必要があります。
start – 停止値を生成するテンソル。数値要素タイプのスカラーである必要があります。
step – ステップ値を生成するテンソル。数値要素タイプのスカラーである必要があります。
output_type – 出力のタイプ

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Range : public ov::op::Op #

#include <range.hpp>

Python の range() に類似した Range 操作。

パブリック関数

Range() = default#: 初期化されてい range 操作を構築します。

Range(const Output<Node> &start, const Output<Node> &stop, const Output<Node> &step)#

range 操作を構築します。

パラメーター:

start – 開始値を生成するテンソル。整数要素タイプのスカラーで、stop および step と同じ要素タイプである必要があります。
stop – 停止値を生成するテンソル。整数要素タイプのスカラーで、start および step と同じ要素タイプである必要があります。
step – ステップ値を生成するテンソル。整数要素タイプのスカラーで、start および stop と同じ要素タイプである必要があります。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ReadValue : public ov::op::util::ReadValueBase #

#include <read_value.hpp>

ReadValue 操作は、variable_id を持つ変数を作成し、この変数の値を返します。

パブリック関数

ReadValue(const Output<Node> &init_value, const std::string &variable_id)#

ReadValue 操作を構築します

パラメーター:

init_value – 入力テンソルを生成する Node
variable_id – 作成する変数の識別子

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline virtual std::string get_variable_id() const override#: 対応する変数の識別子を返します。

class ReadValue : public ov::op::util::ReadValueBase #

#include <read_value.hpp>

ReadValue 操作は、variable_id を持つ変数から入力値を取得し、それを出力として返します。

パブリック関数

explicit ReadValue(const std::shared_ptr<util::Variable> &variable)#

ReadValue 操作を構築します。

パラメーター:: variable – Assign/ReadValue ノードのペア間で要素タイプ、形状、識別子を保存および同期するクラス。

ReadValue(const Output<Node> &init_value, const std::shared_ptr<util::Variable> &variable)#

ReadValue 操作を構築します。

パラメーター:

init_value – 入力テンソルを生成する Node
variable – Assign/ReadValue ノードのペア間で要素タイプ、形状、識別子を保存および同期するクラス。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline virtual std::string get_variable_id() const override#: 対応する変数の識別子を返します。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ReduceL1 : public ov::op::util::ArithmeticReductionKeepDims #

#include <reduce_l1.hpp>

L1 ノルムを使用したリダクション操作: 正規化のためすべての次元が指定されている場合、L1(x) = sum(abs(x)) となります。

L1 ノルムを取得して指定されたリダクション軸を削除し、テンソルをリデュースします。

パブリック関数

ReduceL1() = default#: Reducet L1 ノルム操作を構築します。

ReduceL1(const Output<Node> &arg, const Output<Node> &reduction_axes, bool keep_dims = false)#

reduce L1 ノルム操作を構築します。

パラメーター:

arg – リデュースするテンソル
reduction_axes – 削除する軸の位置 (0 ベース)。
keep_dims – true に設定すると、リダクションに使用される軸が保持されます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ReduceL2 : public ov::op::util::ArithmeticReductionKeepDims #

#include <reduce_l2.hpp>

L2 ノルムを使用したリダクション操作:

L2 ノルムを取得して指定されたリダクション軸を削除し、テンソルをリデュースします。

パブリック関数

ReduceL2() = default#: Reducet L2 ノルム操作を構築します。

ReduceL2(const Output<Node> &arg, const Output<Node> &reduction_axes, bool keep_dims = false)#

reduce L2 ノルム操作を構築します。

パラメーター:

arg – リデュースするテンソル
reduction_axes – 削除する軸の位置 (0 ベース)。
keep_dims – true に設定すると、リダクションに使用される軸が保持されます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ReduceLogicalAnd : public ov::op::util::LogicalReductionKeepDims #

#include <reduce_logical_and.hpp>

論理積を使用してリダクションを実行します。

リダクションは最初の入力スライスに対して実行されます。スライスの形状は、2 番目の入力 (軸) に渡される値によって決まります。

パブリック関数

ReduceLogicalAnd(const Output<Node> &data, const Output<Node> &reduction_axes, const bool keep_dims = false)#

ReduceLogicalAnd ノードを構築します。

パラメーター:

data – リデュースされる入力テンソル
reduction_axes – リダクション操作の前に、最初のテンソルをスライスする軸に関する情報を持つ入力テンソル
keep_dims – リダクションに使用する軸を保持するかどうかを示します

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ReduceLogicalOr : public ov::op::util::LogicalReductionKeepDims #

#include <reduce_logical_or.hpp>

論理和を使用してリダクションを実行します。

リダクションは最初の入力スライスに対して実行されます。スライスの形状は、2 番目の入力 (軸) に渡される値によって決まります。

パブリック関数

ReduceLogicalOr(const Output<Node> &data, const Output<Node> &reduction_axes, const bool keep_dims = false)#

ReduceLogicalOr ノードを構築します。

パラメーター:

data – リデュースされる入力テンソル
reduction_axes – リダクション操作の前に、最初のテンソルをスライスする軸に関する情報を持つ入力テンソル
keep_dims – リダクションに使用する軸を保持するかどうかを示します

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ReduceMax : public ov::op::util::ArithmeticReductionKeepDims #

#include <reduce_max.hpp>

ReduceMax 操作。

パブリック関数

ReduceMax() = default#: 合計操作を構築します。

ReduceMax(const Output<Node> &arg, const Output<Node> &reduction_axes, bool keep_dims = false)#

合計操作を構築します。

パラメーター:

arg – 合計するテンソル
reduction_axes – 削除する軸の位置 (0 ベース)。
keep_dims – 1 に設定すると、リダクションに使用される軸が保持されます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ReduceMean : public ov::op::util::ArithmeticReductionKeepDims #

#include <reduce_mean.hpp>

ReduceMean 操作。

パブリック関数

ReduceMean(const Output<Node> &arg, const Output<Node> &reduction_axes, bool keep_dims = false)#

パラメーター:

arg – 合計するテンソル
reduction_axes – 削除する軸の位置 (0 ベース)。
keep_dims – 1 に設定すると、リダクションに使用される軸が保持されます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ReduceMin : public ov::op::util::ArithmeticReductionKeepDims #

#include <reduce_min.hpp>

ReduceMin 操作。

パブリック関数

ReduceMin() = default#: 合計操作を構築します。

ReduceMin(const Output<Node> &arg, const Output<Node> &reduction_axes, bool keep_dims = false)#

合計操作を構築します。

パラメーター:

arg – 合計するテンソル
reduction_axes – 削除する軸の位置 (0 ベース)。
keep_dims – 1 に設定すると、リダクションに使用される軸が保持されます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ReduceProd : public ov::op::util::ArithmeticReductionKeepDims #

#include <reduce_prod.hpp>

リダクション操作。

テンソルをリデュースし、積を取ることで指定されたリダクション軸を削除します。

パブリック関数

ReduceProd() = default#: 積分操作を構築します。

ReduceProd(const Output<Node> &arg, const Output<Node> &reduction_axes, bool keep_dims = false)#

積分操作を構築します。

パラメーター:

arg – リデュースするテンソル
reduction_axes – 削除する軸の位置 (0 ベース)。
keep_dims – true に設定すると、リダクションに使用される軸が保持されます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ReduceSum : public ov::op::util::ArithmeticReductionKeepDims #

#include <reduce_sum.hpp>

テンソル和操作。

入力テンソルを要素ごとに合計し、指定されたリダクション軸を削除します。次に例を示します:

\begin{array}{r} sum ({0}, [\begin{array}{ccc} 1 & 2 \\ 3 & 4 \\ 5 & 6 \end{array}]) = [(1 + 3 + 5), (2 + 4 + 6)] = [9, 12] (dimension 0 (rows) は削除されます) \end{array}

\begin{array}{r} sum ({1}, [\begin{array}{ccc} 1 & 2 \\ 3 & 4 \\ 5 & 6 \end{array}]) = [(1 + 2), (3 + 4), (5 + 6)] = [3, 7, 11] (dimension 1 (columns) は削除されます) \end{array}

\begin{array}{r} sum ({0}, [\begin{array}{ccc} 1 & 2 \\ 3 & 4 \\ 5 & 6 \end{array}]) = [(1 + 3 + 5), (2 + 4 + 6)] = [9, 21] (dimension 0 (rows) は削除されます) \end{array}

パラメーター

	説明
`reduction_axes`	合計によって削除する軸。
`keep_dims`	1 に設定すると、リダクションに使用される軸が保持されます。

入力

	タイプ	説明
`arg`	$N [d_{1}, \dots, d_{n}] (n \geq 0)$	任意の形状と数値要素タイプの入力テンソル。

タイプ	説明
$N [delete (A, d_{1}, \dots, d_{n})]$	テンソル $T$ 。ここで、 $T$ は、合計によって `reduction_axes` $A$ が削除された入力テンソルです。

パブリック関数

ReduceSum() = default#: 合計操作を構築します。

ReduceSum(const Output<Node> &arg, const Output<Node> &reduction_axes, bool keep_dims = false)#

合計操作を構築します。

パラメーター:

arg – 合計するテンソル
reduction_axes – 削除する軸の位置 (0 ベース)。
keep_dims – 1 に設定すると、リダクションに使用される軸が保持されます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class RegionYolo : public ov::op::Op #

#include <region_yolo.hpp>

RegionYolo 操作。

パブリック関数

RegionYolo(const Output<Node> &input, const size_t coords, const size_t classes, const size_t regions, const bool do_softmax, const std::vector<int64_t> &mask, const int axis, const int end_axis, const std::vector<float> &anchors = std::vector<float>{})#

RegionYolo 操作を構築します。

パラメーター:

input – [in] Input
coords – [in] 各領域の座標数
classes – [in] 各領域のクラス数
regions – [in] 領域数
do_softmax – [in] softmax を計算します
mask – [in] Mask
axis – [in] softmax を開始する軸
end_axis – [in] softmax を終了する軸
anchors – [in] 以前のボックスサイズをコード化するペア [width, height] が平坦化されたリスト

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Relu : public ov::op::util::UnaryElementwiseArithmetic #

#include <relu.hpp>

要素ごとの Relu 操作。

パブリック関数

Relu(const Output<ov::Node> &arg)#

Relu 操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ReorgYolo : public ov::op::Op #

#include <reorg_yolo.hpp>

ReorgYolo 操作。

パブリック関数

ReorgYolo(const Output<Node> &input, const size_t stride)#

ReorgYolo 操作を構築します。

パラメーター:

input – Input
stride – 入力を再編成するストライド

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Reshape : public ov::op::Op #

#include <reshape.hpp>

Tensor の動的再形成操作。

入力テンソルを同じ要素数を持つ新しい形状に “変換” します。この操作は実際のデータには影響しません。必要に応じて、Transpose を使用します。

パブリック関数

Reshape(const Output<Node> &arg, const Output<Node> &shape_pattern, bool special_zero)#

動的再形成操作を構築します。この操作では転置 (transpose) は実行されません。

パラメーター:

arg – 再形成するテンソル
shape_pattern – 出力形状 shape_pattern を定義するノード入力形状が $(a_{0}, \dots, a_{k - 1})$ の場合、出力形状は $(b_{0}, \dots, b_{j - 1})$ の形式である必要があります。ここで $Π (a_{i}) = Π (b_{i})$ です。最大 1 つの次元に対して -1 の値が許可されます。この場合、次元サイズは入力テンソルの要素数に基づいて推測されます。
special_zero – shape_pattern 内のゼロを、同じインデックスの入力形状からのコピーを示すワイルドカード・フラグとして扱います。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool evaluate(ov::TensorVector &outputs, const ov::TensorVector &inputs) const override#

input_values の op を評価し、結果を output_values に格納します。

パラメーター:

output_values – 計算する出力のテンソル。結果ごとに 1 つ
input_values – 入力用のテンソル。入力ごとに 1 つ

戻り値:

成功したら true

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Result : public ov::op::Op #

#include <result.hpp>

Result 操作。

パブリック関数

Result() = default#: 値を関数の結果として使用できるようにします。

Result(const Output<Node> &arg)#

値を関数の結果として使用できるようにします。

パラメーター:: arg – 入力テンソルを生成する Node

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool evaluate(ov::TensorVector &outputs, const ov::TensorVector &inputs) const override#

input_values の op を評価し、結果を output_values に格納します。

パラメーター:

output_values – 計算する出力のテンソル。結果ごとに 1 つ
input_values – 入力用のテンソル。入力ごとに 1 つ

戻り値:

成功したら true

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

Layout get_layout() const#: 現在のレイアウトを返します。設定されていない場合は空の Layout を返します。

void set_layout(const Layout &layout)#

レイアウトのランタイム情報をテンソルに設定します。

パラメーター:: layout – 設定する Layout空の場合 (デフォルトで構築)、レイアウトのランタイム情報は消去されます

class Reverse : public ov::op::Op #

#include <reverse.hpp>

Reverse 操作。

パブリック関数

Reverse(const Output<Node> &data, const Output<Node> &reversed_axes, const std::string &mode)#

リバース操作を構築します。

パラメーター:

data – いくつかの軸が反転される入力テンソル。
reversed_axes – インデックスのセットまたはブールマスクの形式で反転する軸。
mode – Reverse_axes を解釈する方法 (セットまたはマスク)。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline Mode get_mode() const#

戻り値:: 2 番目の入力データ解釈モード。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ReverseSequence : public ov::op::Op #

#include <reverse_sequence.hpp>

ReverseSequence 操作。

パブリック関数

ReverseSequence(const Output<Node> &arg, const Output<Node> &seq_lengths, int64_t batch_axis = 0, int64_t seq_axis = 1)#

ReverseSequence 操作を構築します。

パラメーター:

arg – 逆順に入力データを持つテンソル
seq_lengths – 入力テンソルにシーケンスの長さを持つ整数の 1D テンソル。
batch_axis – バッチ次元のインデックス。
seq_axis – シーケンス次元のインデックス。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class RNNCell : public ov::op::util::RNNCellBase #

#include <rnn_cell.hpp>

単一の RNN セルノードのクラス。

関連情報

LSTMSequence、LSTMCell、GRUCell

注

これは ONNX 標準で定義された表記法と方程式に従います: onnx/onnx

注

次の式を計算します:

 Ht = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi) 

* - Is a dot product, 
f - is activation functions.

注

このクラスは、RNN シーケンスレイヤー全体ではなく、単一のセル (現在の時間ステップ) のみを表します

パブリック関数

RNNCell(const Output<Node> &X, const Output<Node> &initial_hidden_state, const Output<Node> &W, const Output<Node> &R, std::size_t hidden_size, const std::vector<std::string> &activations = std::vector<std::string>{"tanh"}, const std::vector<float> &activations_alpha = {}, const std::vector<float> &activations_beta = {}, float clip = 0.f)#

RNNCell ノードを構築します。

パラメーター:

X – [in] 入力テンソルの形状は次のようになります: [batch_size, input_size].
initial_hidden_state – [in] 現在のタイムステップにおける隠れ状態テンソルの形状は次のようになります: [batch_size, hidden_size]
W – [in] 重みテンソルの形状は次のようになります: [hidden_size, input_size].
R – [in] 再帰重みテンソルの形状は次のようになります: [hidden_size, hidden_size].
hidden_size – [in] 再帰セルの隠れユニットの数
activations – [in] 再帰セル内で使用される活性化関数のベクトル
activations_alpha – [in] 活性化リストの順に並べられた活性化関数のアルファ・パラメーターのベクトル
activations_beta – [in] 活性化リストの順に並べられた活性化関数のベータ・パラメーターのベクトル
clip – [in] 活性化関数の入力におけるクリッピング範囲 [-clip, clip] を定義する値

RNNCell(const Output<Node> &X, const Output<Node> &initial_hidden_state, const Output<Node> &W, const Output<Node> &R, const Output<Node> &B, std::size_t hidden_size, const std::vector<std::string> &activations = std::vector<std::string>{"tanh"}, const std::vector<float> &activations_alpha = {}, const std::vector<float> &activations_beta = {}, float clip = 0.f)#

RNNCell ノードを構築します。

パラメーター:

X – [in] 入力テンソルの形状は次のようになります: [batch_size, input_size]
initial_hidden_state – [in] 現在のタイムステップにおける隠れ状態テンソルの形状は次のようになります: [batch_size, hidden_size]
W – [in] 重みテンソルの形状は次のようになります: [hidden_size, input_size]
R – [in] 再帰重みテンソルの形状は次のようになります: [hidden_size, hidden_size]
B – [in] 形状が次の入力ゲートのバイアステンソル: [hidden_size]
hidden_size – [in] 再帰セルの隠れユニットの数
activations – [in] 再帰セル内で使用される活性化関数のベクトル
activations_alpha – [in] 活性化リストの順に並べられた活性化関数のアルファ・パラメーターのベクトル
activations_beta – [in] 活性化リストの順に並べられた活性化関数のベータ・パラメーターのベクトル
clip – [in] 活性化関数の入力におけるクリッピング範囲 [-clip, clip] を定義する値

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class RNNSequence : public ov::op::util::RNNCellBase #

#include <rnn_sequence.hpp>

RNNSequence 操作。

パブリック関数

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class ROIAlign : public ov::op::util::ROIAlignBase #

#include <roi_align.hpp>

ROIAlign 操作。

パブリック関数

ROIAlign(const Output<Node> &input, const Output<Node> &rois, const Output<Node> &batch_indices, const int pooled_h, const int pooled_w, const int sampling_ratio, const float spatial_scale, const std::string &mode)#

ONNX ROIAlign 仕様に一致する ROIAlign ノードを構築します。共通パラメーターの説明については、util::ROIAlignBase を確認してください。

パラメーター:: mode – プーリングのメソッド - ‘平均’ または ‘最大’

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ROIAlignRotated : public ov::op::util::ROIAlignBase #

#include <roi_align_rotated.hpp>

ROIAlignRotated 操作。

パブリック関数

ROIAlignRotated(const Output<Node> &input, const Output<Node> &rois, const Output<Node> &batch_indices, const int pooled_h, const int pooled_w, const int sampling_ratio, const float spatial_scale, const bool clockwise_mode)#

ROIAlignRotated 操作を構築します。

パラメーター:

input – Input 特徴マップ {N, C, H, W}
rois – プールする関心領域
batch_indices – バッチ内の画像のインデックスと一致する数または ROI
pooled_h – ROI 出力特徴の高さ
pooled_w – ROI 出力特徴の幅
sampling_ratio – 出力要素の計算に使用されるサンプリング・ポイントの数
spatial_scale – ROI 座標を変換するのに使用される空間スケール係数
clockwise_mode – true の場合、回転角度は時計回りと解釈され、そうでない場合は反時計回りと解釈されます。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class ROIPooling : public ov::op::Op #

#include <roi_pooling.hpp>

ROIPooling 操作。

パブリック関数

ROIPooling(const Output<Node> &input, const Output<Node> &coords, const Shape &output_size, const float spatial_scale, const std::string &method = "max")#

ROIPooling 操作を構築します。

パラメーター:

input – Input 特徴マップ {N, C, H, W}
coords – 境界ボックスの座標
output_size – ROI 出力特徴の高さ/幅
spatial_scale – 入力特徴マップと入力画像サイズの比率
mode – プーリングの方法 - 最大または双線形

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

void set_output_roi(Shape output_size)#

出力 ROI 特徴マップ (pooled_h、pooled_w) を設定します。

パラメーター:: output_size – プーリング属性 pooled_h および pooled_w サイズを持つ Shape

const Shape &get_output_roi() const#

出力 ROI 特徴マップの形状 (H x W) を取得します。

戻り値:: pooled_h 属性と pooled_w 属性を持つ Shape

void set_spatial_scale(float scale)#

空間スケール値を設定します。

パラメーター:: scale – 設定するスケール値。

void set_method(std::string method_name)#

プーリングの方法を設定します。

パラメーター:: method_name – プーリングの方法名。

class Roll : public ov::op::Op #

#include <roll.hpp>

Tensor ロール操作。

パブリック関数

Roll(const Output<Node> &data, const Output<Node> &shift, const Output<Node> &axes)#

ロール操作を構築します。

パラメーター:

data – シフトされるテンソルを生成する Node
shift – 要素がシフトされる場所の数を指定する 0D または 1D テンソルを生成する Node
shift – 要素がシフトされる軸を指定する 0D または 1D テンソルを生成する Node

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Round : public ov::op::util::UnaryElementwiseArithmetic #

#include <round.hpp>

要素ごとの丸め操作。出力は各値に対して最も近い整数に丸められます。ハーフの場合、ルールは属性 ‘mode’ で定義されます: ‘HALF_TO_EVEN’ - 半分を最も近い偶数に丸めます。 ‘HALF_AWAY_FROM_ZERO’: 結果がゼロから離れるように丸めます。

パブリック関数

Round() = default#: Round 操作を構築します。

Round(const Output<Node> &arg, const RoundMode mode)#

Round 操作を構築します。

パラメーター:

arg – 入力テンソルを生成する Node
mode – ハーフを解決するルール

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ScaledDotProductAttention : public ov::op::Op #

#include <scaled_dot_product_attention.hpp>

PyTorch からのスケールされたドット積アテンション操作。

パブリック関数

ScaledDotProductAttention() = default#: ScaledDotProductAttention 操作を構築します。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class ScatterElementsUpdate : public ov::op::util::ScatterElementsUpdateBase #

#include <scatter_elements_update.hpp>

ScatterElementsUpdate 操作。

パブリック関数

ScatterElementsUpdate(const Output<Node> &data, const Output<Node> &indices, const Output<Node> &updates, const Output<Node> &axis)#

ScatterElementsUpdate ノードを構築します。

パラメーター:

data – 入力データ
indices – 更新されるデータ入力インデックス
updates – 更新値
axis – 発散する軸

class ScatterNDUpdate : public ov::op::util::ScatterNDBase #

#include <scatter_nd_update.hpp>

インデックスでアドレス指定された入力からスライスに更新を追加します。

パブリック関数

inline ScatterNDUpdate(const Output<Node> &inputs, const Output<Node> &indices, const Output<Node> &updates)#

パラメーター:

inputs – Tensor
indices – インデックス・テンソル: データタイプは element::i32 または element::i64 である必要があります
updates – Tensor: 入力と同じタイプである必要があります

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ScatterNDUpdate : public ov::op::util::ScatterNDBase #

#include <scatter_nd_update.hpp>

インデックスでアドレス指定された入力からスライスに更新を追加します。

パブリックタイプ

enum class Reduction#

このバージョンのオペレーターでサポートされているリダクション・タイプを一覧表示します。ScatterNDUpdate でのリダクションの仕組みについては、仕様を参照してください。

値:

enumerator NONE#

enumerator SUM#

enumerator SUB#

enumerator PROD#

enumerator MIN#

enumerator MAX#

パブリック関数

ScatterNDUpdate(const Output<Node> &inputs, const Output<Node> &indices, const Output<Node> &updates, const Reduction reduction = Reduction::NONE)#

パラメーター:

inputs – Tensor
indices – インデックス・テンソル: データタイプは element::i32 または element::i64 である必要があります
updates – Tensor: 入力と同じタイプである必要があります
reduction – リダクション: 入力に対して実行する操作タイプ

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ScatterUpdate : public ov::op::util::ScatterBase #

#include <scatter_update.hpp>

インデックスでアドレス指定されたデータからスライスに新しい値を設定します。

パブリック関数

ScatterUpdate(const Output<Node> &data, const Output<Node> &indices, const Output<Node> &updates, const Output<Node> &axis)#

ScatterUpdate オペレーター・オブジェクトを構築します。

パラメーター:

data – 更新される入力テンソル。
indices – 更新されるインデックスを持つテンソル。
updates – 更新値を持つテンソル。
axis – [in] 要素が更新される軸。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Select : public ov::op::Op #

#include <select.hpp>

要素ごとの選択操作。

入力

	タイプ	説明
`arg0`	$bool [d_{1}, \dots, d_{n}] (n \geq 0)$	要素が `bool` である、任意の形状のテンソル。
`arg1`	$E [d_{1}, \dots, d_{n}] (n \geq 0)$	任意の要素タイプを持つ、`arg0` とブロードキャスト互換の形状のテンソル。
`arg2`	$E [d_{1}, \dots, d_{n}] (n \geq 0)$	`arg0` とブロードキャスト互換で、`arg1` と同じ要素タイプの形状のテンソル。
`auto_broadcast`	AutoBroadcastSpec	自動ブロードキャスト仕様。

タイプ	説明
$E [d_{1}, \dots, d_{n}]$	テンソル $T$ 、ここで $T [i_{1}, \dots, i_{n}] = arg1 [i_{1}, \dots, i_{n}] if arg0 [i_{1}, \dots, i_{n}] \neq 0, else arg2 [i_{1}, \dots, i_{n}]$

パブリック関数

inline Select()#: 選択操作を構築します。

Select(const Output<Node> &arg0, const Output<Node> &arg1, const Output<Node> &arg2, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

選択操作を構築します。

パラメーター:

arg0 – 最初の入力テンソルを生成する Node
arg1 – 2 番目の入力テンソルを生成する Node
arg2 – 3 番目の入力テンソルを生成する Node
auto_broadcast – 自動ブロードキャスト仕様。デフォルトは Numpy スタイルの暗黙的なブロードキャストです。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline virtual const AutoBroadcastSpec &get_autob() const override#

戻り値:: AutoBroadcastSpec

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Selu : public ov::op::Op #

#include <selu.hpp>

入力ノードのすべての要素に対して SELU 活性化関数を実行します。

パブリック関数

Selu(const Output<Node> &data, const Output<Node> &alpha, const Output<Node> &lambda)#

Selu ノードを構築します。

パラメーター:

data – 入力テンソルを生成する Node
alpha – SELU 操作のアルファ係数
lambda – SELU 操作のラムダ係数

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class ShapeOf : public ov::op::util::ShapeOfBase #

#include <shape_of.hpp>

入力引数の形状をテンソルとして返す操作。

パブリック関数

ShapeOf(const Output<Node> &arg, const element::Type output_type = element::i64)#: 形状 (shape-of) 操作を構築します。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ShapeOf : public ov::op::util::ShapeOfBase #

#include <shape_of.hpp>

入力引数の形状をテンソルとして返す操作。

パブリック関数

ShapeOf(const Output<Node> &arg)#: 形状 (shape-of) 操作を構築します。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class ShuffleChannels : public ov::op::Op #

#include <shuffle_channels.hpp>

入力のチャネル次元でデータを並べ替えます。

パブリック関数

ShuffleChannels(const Output<Node> &data, const int64_t axis = 1, const int64_t group = 1)#

ShuffleChannels ノードを構築します。

パラメーター:

data – 入力テンソルを生成する Node
axis – データテンソル内のチャネル次元インデックス。負の値は、インデックスを入力データ形状の後方から計算する必要があることを意味します。
group – チャネル次元を分割するグループの数

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Sigmoid : public ov::op::util::UnaryElementwiseArithmetic #

#include <sigmoid.hpp>

Sigmoid 操作。

パブリック関数

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Sign : public ov::op::util::UnaryElementwiseArithmetic #

#include <sign.hpp>

要素ごとの正弦操作。

パブリック関数

Sign(const Output<Node> &arg)#

要素ごとの正弦操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Sin : public ov::op::util::UnaryElementwiseArithmetic #

#include <sin.hpp>

要素ごとの正弦操作。

入力

	タイプ	説明
`arg`	$N [d_{1}, \dots, d_{n}] (n \geq 0)$	任意の形状と数値要素タイプのテンソル。

タイプ	説明
$N [d_{1}, \dots, d_{n}]$	テンソル $T$ 、ここで $T [i_{1}, \dots, i_{n}] = \sin (arg [i_{1}, \dots, i_{n}])$

パブリック関数

Sin(const Output<Node> &arg)#

正弦操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Sinh : public ov::op::util::UnaryElementwiseArithmetic #

#include <sinh.hpp>

要素ごとの双曲正弦 (sinh) 操作。

パブリック関数

Sinh(const Output<Node> &arg)#

双曲正弦演算を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Sink : public ov::op::Op #

#include <sink.hpp>

シンクノードになることができるノードのルート。

ov::op::util::AssignBase、ov::op::util::MultiSubGraphOp でサブクラス化されます

class Slice : public ov::op::Op #

#include <slice.hpp>

Slice 操作。

パブリック関数

Slice(const Output<Node> &data, const Output<Node> &start, const Output<Node> &stop, const Output<Node> &step)#

Slice 操作を構築します (デフォルトは軸)。

パラメーター:

data – スライスされるテンソル。
start – スライスの開始インデックスを持つ 1D テンソル。
end – スライスの停止インデックスを持つ 1D テンソル。
step – 対応する軸に沿ってスライスする際に使用する増分を指定する 1D テンソル。

Slice(const Output<Node> &data, const Output<Node> &start, const Output<Node> &stop, const Output<Node> &step, const Output<Node> &axes)#

Slice 操作を構築します。

パラメーター:

data – スライスされるテンソル。
start – スライスの開始インデックスを持つ 1D テンソル。
end – スライスの停止インデックスを持つ 1D テンソル。
step – 対応する軸に沿ってスライスする際に使用する増分を指定する 1D テンソル。
axes – start と stop の値がどの次元に適用されるかを示す 1D テンソル。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Softmax : public ov::op::Op #

#include <softmax.hpp>

Softmax 操作。

パブリック関数

Softmax(const Output<Node> &arg, const size_t axis = 1)#

Softmax 操作を構築します。

出力 [d0, ...]

パラメーター:

arg – 最初の入力テンソルを生成する Node。[d0, ...]
axis – Softmax を計算する軸の位置 (0 ベース)

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Softmax : public ov::op::Op #

#include <softmax.hpp>

負の軸値を持つ Softmax 操作。

パブリック関数

Softmax(const Output<Node> &arg, const int64_t axis = 1)#

Softmax 操作を構築します。

Output [d0, ...]

パラメーター:

args – 最初の入力テンソルを生成する Node。[d0, ...]
axis – Softmax を計算する範囲 [-rank(arg), rank(arg) - 1] 内の軸の位置 (0 ベース)。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class SoftPlus : public ov::op::util::UnaryElementwiseArithmetic #

#include <softplus.hpp>

自己正規化非単調ニューラル活性化関数 f(x) = ln(exp(x) + 1.)

パブリック関数

SoftPlus(const Output<Node> &arg)#

SoftPlus 操作を構築します。

パラメーター:: data – Input テンソル

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class SpaceToBatch : public ov::op::Op #

#include <space_to_batch.hpp>

SpaceToBatch は、空間データのデータ・テンソル・ブロックをバッチ次元に並べ替えます。

注

空間ブロック次元の値はバッチ次元に移動されます。

 出力ノードは、次の形状のテンソルを生成します: 形状のテンソル `[batch * block_shape[0] * block_shape[1] * ...`data` 入力と同じタイプの block_shape[N - 1]、(pads_begin[1] + D_1 + pads_end[1]) / block_shape[1]、(pads_begin[2] + D_2 + pads_end[2]) / block_shape[2]、...、(pads_begin[N - 1] + D_{N - 1} + pads_end[N - 1]) / block_shape[N - 1]`。

パブリック関数

SpaceToBatch(const Output<Node> &data, const Output<Node> &block_shape, const Output<ov::Node> &pads_begin, const Output<ov::Node> &pads_end)#

SpaceToBatch 操作を構築します。

パラメーター:

data – データテンソルを生成する Node
block_shape – 移動する値のブロックサイズ
pads_begin – data 入力の各軸の先頭パディングを指定します
pads_end – data 入力の各軸の終了パディングを指定します。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class SpaceToDepth : public ov::op::Op #

#include <space_to_depth.hpp>

SpaceToDepth は、空間データの入力テンソルブロックをバッチ次元に並べ替えます。

注

高さと幅の次元の値は奥行きの次元に移動されます。

 出力ノードは次の形状のテンソルを生成します: [N, C * blocksize * blocksize, H / blocksize, W / blocksize]

パブリック関数

SpaceToDepth(const Output<Node> &data, const SpaceToDepthMode &mode, std::size_t block_size = 1)#

SpaceToDepth 操作を構築します。

パラメーター:

data – 入力テンソルを生成する Node
mode – 出力深度次元をブロック座標と古い深度次元から収集する方法を指定します
block_size – 移動する値のブロックサイズ

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Split : public ov::op::Op #

#include <split.hpp>

入力テンソルを同じサイズのテンソルのリストに分割します。

パブリック関数

Split() = default#: split 操作を構築します。

Split(const Output<Node> &data, const Output<Node> &axis, const size_t num_splits)#

split 操作を構築します。

パラメーター:

data – 分割されるテンソル。
axis – 分割を実行する “data” 内の軸のインデックス
num_splits – データテンソルを分割する部分の数。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Sqrt : public ov::op::util::UnaryElementwiseArithmetic #

#include <sqrt.hpp>

要素ごとの平方根操作。

入力

	タイプ	説明
`arg`	$N [d_{1}, \dots, d_{n}] (n \geq 0)$	任意の形状と数値要素タイプのテンソル。

タイプ	説明
$N [d_{1}, \dots, d_{n}]$	テンソル $T$ 、ここで $T [i_{1}, \dots, i_{n}] = \sqrt{arg [i_{1}, \dots, i_{n}]}$

パブリック関数

Sqrt(const Output<Node> &arg)#

square 操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class SquaredDifference : public ov::op::util::BinaryElementwiseArithmetic #

#include <squared_difference.hpp>

2 つのテンソル間の要素ごとの二乗差を計算します。

y[i] = (x1[i] - x2[i])^2

パブリック関数

inline SquaredDifference()#: 初期化されていない二乗差演算を構築します。

SquaredDifference(const Output<Node> &x1, const Output<Node> &x2, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

二乗差演算を構築します。

パラメーター:

x1 – 最初の入力テンソル
x2 – 2 番目の入力テンソル
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Squeeze : public ov::op::Op #

#include <squeeze.hpp>

Squeeze 操作。

パブリック関数

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class StridedSlice : public ov::op::Op #

#include <strided_slice.hpp>

入力テンソルのスライス、つまり境界ボックス内に存在するサブテンソルを、オプションでストライド付きで受け取ります。

パブリック関数

StridedSlice(const Output<Node> &data, const Output<Node> &begin, const Output<Node> &end, const Output<Node> &strides, const std::vector<int64_t> &begin_mask, const std::vector<int64_t> &end_mask, const std::vector<int64_t> &new_axis_mask = std::vector<int64_t>{}, const std::vector<int64_t> &shrink_axis_mask = std::vector<int64_t>{}, const std::vector<int64_t> &ellipsis_mask = std::vector<int64_t>{})#

動的テンソルのストライドスライス操作を構築します。

パラメーター:

data – スライスされるテンソル。
begin – 入力ブロブスライスの開始インデックスを持つ 1D テンソル。
end – 入力ブロブスライスの終了インデックスを持つ 1D テンソル。
strides – スライスストライド。例えば、ストライド {n,m} は、入力行列の n 行目と m 列目ごとに取得することを意味します。
begin_mask – begin_mask[i] が 1 の場合、開始入力の対応する次元は無視されます。
end_mask – end_mask[i] が 1 の場合、終了入力の対応する次元は無視されます。
new_axis_mask – new_axis_mask[i] が 1 の場合、長さ 1 の次元が入力テンソルの i 番目の位置に挿入されます。
shrink_axis_mask – shrink_axis_mask[i] が 1 の場合、i 番目の位置の次元が削除されます。
ellipsis_mask – 欠落している次元をゼロ以外のビットの位置に挿入します。

StridedSlice(const Output<Node> &data, const Output<Node> &begin, const Output<Node> &end, const std::vector<int64_t> &begin_mask, const std::vector<int64_t> &end_mask, const std::vector<int64_t> &new_axis_mask = std::vector<int64_t>{}, const std::vector<int64_t> &shrink_axis_mask = std::vector<int64_t>{}, const std::vector<int64_t> &ellipsis_mask = std::vector<int64_t>{})#

動的テンソルのストライドスライス操作を構築します。

パラメーター:

data – スライスされるテンソル。
begin – 入力ブロブスライスの開始インデックスを持つ 1D テンソル。
end – 入力ブロブスライスの終了インデックスを持つ 1D テンソル。
begin_mask – begin_mask[i] が 1 の場合、開始入力の対応する次元は無視されます。
end_mask – end_mask[i] が 1 の場合、終了入力の対応する次元は無視されます。
new_axis_mask – new_axis_mask[i] が 1 の場合、長さ 1 の次元が入力テンソルの i 番目の位置に挿入されます。
shrink_axis_mask – shrink_axis_mask[i] が 1 の場合、i 番目の位置の次元が削除されます。
ellipsis_mask – 欠落している次元をゼロ以外のビットの位置に挿入します。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Subtract : public ov::op::util::BinaryElementwiseArithmetic #

#include <subtract.hpp>

要素ごとの減算操作。

パブリック関数

Subtract(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY))#

減算操作を構築します。

パラメーター:

arg0 – 最初の入力テンソルを生成する Node
arg1 – 2 番目の入力テンソルを生成する Node
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Swish : public ov::op::Op #

#include <swish.hpp>

Swish 活性化関数 f(x) = x / (1.0 + exp(-beta * x)) または f(x) = x * sigmoid(beta * x)

パブリック関数

Swish(const Output<Node> &arg, const Output<Node> &beta)#

Swish 操作を構築します。

パラメーター:

data – Input テンソル
beta – ベータ値を持つスカラー引数が指定されていない場合、デフォルト値 1.0 を使用します。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Tan : public ov::op::util::UnaryElementwiseArithmetic #

#include <tan.hpp>

要素ごとの正接操作。

入力

	タイプ	説明
`arg`	$N [d_{1}, \dots, d_{n}] (n \geq 0)$	任意の形状と数値要素タイプのテンソル。

タイプ	説明
$N [d_{1}, \dots, d_{n}]$	テンソル $T$ 、ここで $T [i_{1}, \dots, i_{n}] = \tan (arg [i_{1}, \dots, i_{n}])$

パブリック関数

Tan(const Output<Node> &arg)#

正接操作を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Tanh : public ov::op::util::UnaryElementwiseArithmetic #

#include <tanh.hpp>

要素ごとの双曲正接操作。

パブリック関数

Tanh(const Output<Node> &arg)#

双曲正接演算を構築します。

パラメーター:: arg – 入力テンソルを生成する Node

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class TensorIterator : public ov::op::util::SubGraphOp #

#include <tensor_iterator.hpp>

ボディーをテンソル上で反復処理し、テンソルに蓄積します。

パブリック関数

inline std::shared_ptr<Model> get_body() const#

戻り値:: 反復のボディー

inline void set_body(const std::shared_ptr<Model> &body)#

パラメーター:: body – 反復のボディーを設定

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Tile : public ov::op::Op #

#include <tile.hpp>

各次元に沿ってテンソルを複数回繰り返す動的タイリング操作。

パブリック関数

Tile(const Output<Node> &data, const Output<Node> &repeats)#

テンソルの動的パディングを実行します。

パラメーター:

data – パディングする入力テンソルを生成するノード。
repeats – 次元ごとの複製係数を生成するノード。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

virtual bool evaluate(ov::TensorVector &outputs, const ov::TensorVector &inputs) const override#

input_values の op を評価し、結果を output_values に格納します。

パラメーター:

output_values – 計算する出力のテンソル。結果ごとに 1 つ
input_values – 入力用のテンソル。入力ごとに 1 つ

戻り値:

成功したら true

class TopK : public ov::op::util::TopKBase #

#include <topk.hpp>

指定された軸に沿った各スライスの k 個の最大/最小値のインデックスと値を計算します。

パブリック関数

TopK() = default#: TopK 操作を構築します。

TopK(const Output<Node> &data, const Output<Node> &k, const int64_t axis, const std::string &mode, const std::string &sort, const element::Type &index_element_type = element::i32)#

値とインデックスの 2 つの出力を持つ TopK 操作を構築します。デフォルトでは、インデックス出力は i32 データタイプで記述されます。

パラメーター:

data – 入力テンソル
k – 計算する最大/最小要素の数を指定します (注: スカラー入力テンソル)
axis – 上位 k 個のインデックスを計算する軸
mode – 2 つの要素のうち最大の要素を選択のに使用する演算 (最小または最大) を指定します。
sort – 出力要素および/またはインデックスの順序を指定します。許容値: none、index、value
index_element_type – 生成されるインデックスの種類を指定します

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class TopK : public ov::op::util::TopKBase #

#include <topk.hpp>

指定された軸に沿った各スライスの k 個の最大/最小値のインデックスと値を計算します。

パブリック関数

TopK() = default#: TopK 操作を構築します。

TopK(const Output<Node> &data, const Output<Node> &k, const int64_t axis, const std::string &mode, const std::string &sort, const element::Type &index_element_type = element::i32)#

値とインデックスの 2 つの出力を持つ TopK 操作を構築します。デフォルトでは、インデックス出力は i32 データタイプで記述されます。

パラメーター:

data – 入力テンソル
k – 計算する最大/最小要素の数を指定します (注: スカラー入力テンソル)
axis – 上位 k 個のインデックスを計算する軸
mode – 2 つの要素のうち最大の要素を選択のに使用する演算 (最小または最大) を指定します。
sort – 出力要素および/またはインデックスの順序を指定します。許容値: none、index、value
index_element_type – 生成されるインデックスの種類を指定します

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class TopK : public ov::op::util::TopKBase #

#include <topk.hpp>

指定された軸に沿って、指定されたテンソルの上位 K 要素を計算します。

パブリック関数

TopK() = default#: TopK 操作を構築します。

TopK(const Output<Node> &data, const Output<Node> &k, const int64_t axis, const std::string &mode, const std::string &sort, const element::Type &index_element_type = element::i32, const bool stable = false)#

値とインデックスの 2 つの出力を持つ TopK 操作を構築します。

パラメーター:

data – 入力テンソル
k – 計算される最大/最小要素の数を指定します。
axis – TopK 操作を実行する軸
mode – TopK が各スライスから最大の要素を選択するか、最小の要素を選択するかを指定します。
sort – 出力テンソルの対応する要素の順序を指定します。
index_element_type – ‘インデックス’ 出力テンソル内の要素のデータタイプを指定します。
stable – ソート中に同等の要素が入力テンソルから相対的な順序を維持するかどうかを指定します。

TopK(const Output<Node> &data, const Output<Node> &k, const int64_t axis, const TopKMode mode, const TopKSortType sort, const element::Type &index_element_type = element::i32, const bool stable = false)#

値とインデックスの 2 つの出力を持つ TopK 操作を構築します。

パラメーター:

data – 入力データテンソル
k – 計算される最大/最小要素の数を指定します。
axis – TopK 操作を実行する軸
mode – TopK が各スライスから最大の要素を選択するか、最小の要素を選択するかを指定します。
sort – 出力テンソルの対応する要素の順序を指定します。
index_element_type – ‘インデックス’ 出力テンソル内の要素のデータタイプを指定します。
stable – ソート中に同等の要素が入力テンソルから相対的な順序を維持するかどうかを指定します。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Transpose : public ov::op::Op #

#include <transpose.hpp>

Tensor のトランスポーズ操作。

パブリックタイプ

enum Ins#

インデックスとカウントを入力します。

値:

enumerator ARG#

enumerator ORDER#

enumerator IN_COUNT#

enum Outs#

インデックスとカウントを出力します。

値:

enumerator ARG_T#

enumerator OUT_COUNT#

パブリック関数

Transpose(const Output<Node> &arg, const Output<Node> &input_order)#

トランスポーズ操作を構築します。

パラメーター:

arg – 転置されるテンソルを生成する Node
input_order – 入力形状の軸に適用する順列を生成する Node形状が [n] のベクトルである必要があります。ここで n は arg のランクです。テンソルの値には、[0, n-1] の範囲内のすべての整数が含まれている必要があります。

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Unique : public ov::op::Op #

#include <unique.hpp>

入力テンソルの一意の要素または一意のスライスを選択して返すオペレーター。

パブリック関数

Unique(const Output<Node> &data, const bool sorted = true, const element::Type &index_element_type = element::i64, const element::Type &count_element_type = element::i64)#

Unique 操作を構築します。

パラメーター:

data – Input データテンソル
sorted – 返される一意の値の順序を制御します (true の場合は昇順に並べ替えます)
index_element_type – インデックスを含む出力のデータタイプ
count_element_type – 繰り返し回数を含む出力のデータタイプ

Unique(const Output<Node> &data, const Output<Node> &axis, const bool sorted = true, const element::Type &index_element_type = element::i64, const element::Type &count_element_type = element::i64)#

Unique 操作を構築します。

パラメーター:

data – Input データテンソル
axis – 軸値を含む入力テンソル
sorted – 返される一意の値の順序を制御します (true の場合は昇順に並べ替えます)
index_element_type – インデックスを含む出力のデータタイプ
count_element_type – 繰り返し回数を含む出力のデータタイプ

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

class Unsqueeze : public ov::op::Op #

#include <unsqueeze.hpp>

Unsqueeze 操作。

パブリック関数

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

virtual bool evaluate(ov::TensorVector &outputs, const ov::TensorVector &inputs) const override#

input_values の op を評価し、結果を output_values に格納します。

パラメーター:

output_values – 計算する出力のテンソル。結果ごとに 1 つ
input_values – 入力用のテンソル。入力ごとに 1 つ

戻り値:

成功したら true

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class VariadicSplit : public ov::op::Op #

#include <variadic_split.hpp>

VariadicSplit 操作は、入力テンソルをある軸に沿って分割します。ピースの長さは、“split_lengths” 属性に応じて変化する場合があります。

パブリック関数

VariadicSplit() = default#: 可変長分割操作を構築します。

VariadicSplit(const Output<Node> &data, const Output<Node> &axis, const Output<Node> &split_lengths)#

可変長分割操作を構築します。

出力 split_lengths の合計は data.shape[axis] と一致する必要があります。

パラメーター:

data – スプリットされるテンソル
axis – 分割を実行する “data” 内の軸のインデックス
split_lengths – 分割された “axis” に沿った各出力テンソルのサイズを含むリスト

virtual void validate_and_infer_types() override#

ノードが無効な場合にスローされます。

inline virtual size_t get_default_output_index() const override#: デフォルト出力の出力を返します。デフォルト出力がない場合はスローします。

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。

class Xor : public ov::op::util::BinaryElementwiseLogical #

#include <xor.hpp>

要素ごとの排他的論理和操作。

パブリック関数

Xor(const Output<Node> &arg0, const Output<Node> &arg1, const AutoBroadcastSpec &auto_broadcast = AutoBroadcastSpec())#

排他的論理和操作を構築します。

Output [d0, ...]

パラメーター:

arg0 – 入力テンソルを生成する Node。[d0, ...]
arg1 – 2 番目の入力テンソルを生成する Node。[d0, ...]
auto_broadcast – 自動ブロードキャスト仕様

virtual bool has_evaluate() const override#: 現在の操作の評価メソッドの可用性に関する情報を取得できます。