Win32 API 日本語リファレンス
ホームAI.MachineLearning.DirectML › DML_ADAM_OPTIMIZER_OPERATOR_DESC

DML_ADAM_OPTIMIZER_OPERATOR_DESC

構造体
サイズx64: 80 バイト / x86: 48 バイト

サイズ=各フィールドのバイト数(x64/x86 で異なる場合は x64/x86 と併記)。x64/x86 列=フィールドのバイトオフセット(HSPで dupptr / lpoke / wpoke 等に使用)。

フィールド

フィールドサイズx64x86説明
InputParametersTensorDML_TENSOR_DESC*8/4+0+0更新前のモデルパラメータを保持する入力テンソルへのポインタ。Adam最適化の対象。
InputFirstMomentTensorDML_TENSOR_DESC*8/4+8+4更新前の一次モーメント(勾配の指数移動平均)を保持する入力テンソルへのポインタ。
InputSecondMomentTensorDML_TENSOR_DESC*8/4+16+8更新前の二次モーメント(勾配二乗の指数移動平均)を保持する入力テンソルへのポインタ。
GradientTensorDML_TENSOR_DESC*8/4+24+12現在のステップの勾配を保持する入力テンソルへのポインタ。
TrainingStepTensorDML_TENSOR_DESC*8/4+32+16現在の学習ステップ数(タイムステップ)を保持する入力テンソルへのポインタ。バイアス補正に使う。
OutputParametersTensorDML_TENSOR_DESC*8/4+40+20更新後のパラメータを格納する出力テンソルへのポインタ。
OutputFirstMomentTensorDML_TENSOR_DESC*8/4+48+24更新後の一次モーメントを格納する出力テンソルへのポインタ。
OutputSecondMomentTensorDML_TENSOR_DESC*8/4+56+28更新後の二次モーメントを格納する出力テンソルへのポインタ。
LearningRateFLOAT4+64+32学習率。パラメータ更新量のスケールを決める単精度浮動小数の係数。
Beta1FLOAT4+68+36一次モーメントの指数減衰率。通常0.9前後を指定する単精度値。
Beta2FLOAT4+72+40二次モーメントの指数減衰率。通常0.999前後を指定する単精度値。
EpsilonFLOAT4+76+44ゼロ除算を防ぐための微小定数。分母に加算される単精度値。

各言語での定義

#include <windows.h>

// DML_ADAM_OPTIMIZER_OPERATOR_DESC  (x64 80 / x86 48 バイト)
typedef struct DML_ADAM_OPTIMIZER_OPERATOR_DESC {
    DML_TENSOR_DESC* InputParametersTensor;
    DML_TENSOR_DESC* InputFirstMomentTensor;
    DML_TENSOR_DESC* InputSecondMomentTensor;
    DML_TENSOR_DESC* GradientTensor;
    DML_TENSOR_DESC* TrainingStepTensor;
    DML_TENSOR_DESC* OutputParametersTensor;
    DML_TENSOR_DESC* OutputFirstMomentTensor;
    DML_TENSOR_DESC* OutputSecondMomentTensor;
    FLOAT LearningRate;
    FLOAT Beta1;
    FLOAT Beta2;
    FLOAT Epsilon;
} DML_ADAM_OPTIMIZER_OPERATOR_DESC;
using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DML_ADAM_OPTIMIZER_OPERATOR_DESC
{
    public IntPtr InputParametersTensor;
    public IntPtr InputFirstMomentTensor;
    public IntPtr InputSecondMomentTensor;
    public IntPtr GradientTensor;
    public IntPtr TrainingStepTensor;
    public IntPtr OutputParametersTensor;
    public IntPtr OutputFirstMomentTensor;
    public IntPtr OutputSecondMomentTensor;
    public float LearningRate;
    public float Beta1;
    public float Beta2;
    public float Epsilon;
}
Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DML_ADAM_OPTIMIZER_OPERATOR_DESC
    Public InputParametersTensor As IntPtr
    Public InputFirstMomentTensor As IntPtr
    Public InputSecondMomentTensor As IntPtr
    Public GradientTensor As IntPtr
    Public TrainingStepTensor As IntPtr
    Public OutputParametersTensor As IntPtr
    Public OutputFirstMomentTensor As IntPtr
    Public OutputSecondMomentTensor As IntPtr
    Public LearningRate As Single
    Public Beta1 As Single
    Public Beta2 As Single
    Public Epsilon As Single
End Structure
import ctypes
from ctypes import wintypes

class DML_ADAM_OPTIMIZER_OPERATOR_DESC(ctypes.Structure):
    _fields_ = [
        ("InputParametersTensor", ctypes.c_void_p),
        ("InputFirstMomentTensor", ctypes.c_void_p),
        ("InputSecondMomentTensor", ctypes.c_void_p),
        ("GradientTensor", ctypes.c_void_p),
        ("TrainingStepTensor", ctypes.c_void_p),
        ("OutputParametersTensor", ctypes.c_void_p),
        ("OutputFirstMomentTensor", ctypes.c_void_p),
        ("OutputSecondMomentTensor", ctypes.c_void_p),
        ("LearningRate", ctypes.c_float),
        ("Beta1", ctypes.c_float),
        ("Beta2", ctypes.c_float),
        ("Epsilon", ctypes.c_float),
    ]
#[repr(C)]
pub struct DML_ADAM_OPTIMIZER_OPERATOR_DESC {
    pub InputParametersTensor: *mut core::ffi::c_void,
    pub InputFirstMomentTensor: *mut core::ffi::c_void,
    pub InputSecondMomentTensor: *mut core::ffi::c_void,
    pub GradientTensor: *mut core::ffi::c_void,
    pub TrainingStepTensor: *mut core::ffi::c_void,
    pub OutputParametersTensor: *mut core::ffi::c_void,
    pub OutputFirstMomentTensor: *mut core::ffi::c_void,
    pub OutputSecondMomentTensor: *mut core::ffi::c_void,
    pub LearningRate: f32,
    pub Beta1: f32,
    pub Beta2: f32,
    pub Epsilon: f32,
}
import "golang.org/x/sys/windows"

type DML_ADAM_OPTIMIZER_OPERATOR_DESC struct {
	InputParametersTensor uintptr
	InputFirstMomentTensor uintptr
	InputSecondMomentTensor uintptr
	GradientTensor uintptr
	TrainingStepTensor uintptr
	OutputParametersTensor uintptr
	OutputFirstMomentTensor uintptr
	OutputSecondMomentTensor uintptr
	LearningRate float32
	Beta1 float32
	Beta2 float32
	Epsilon float32
}
type
  DML_ADAM_OPTIMIZER_OPERATOR_DESC = record
    InputParametersTensor: Pointer;
    InputFirstMomentTensor: Pointer;
    InputSecondMomentTensor: Pointer;
    GradientTensor: Pointer;
    TrainingStepTensor: Pointer;
    OutputParametersTensor: Pointer;
    OutputFirstMomentTensor: Pointer;
    OutputSecondMomentTensor: Pointer;
    LearningRate: Single;
    Beta1: Single;
    Beta2: Single;
    Epsilon: Single;
  end;
const DML_ADAM_OPTIMIZER_OPERATOR_DESC = extern struct {
    InputParametersTensor: ?*anyopaque,
    InputFirstMomentTensor: ?*anyopaque,
    InputSecondMomentTensor: ?*anyopaque,
    GradientTensor: ?*anyopaque,
    TrainingStepTensor: ?*anyopaque,
    OutputParametersTensor: ?*anyopaque,
    OutputFirstMomentTensor: ?*anyopaque,
    OutputSecondMomentTensor: ?*anyopaque,
    LearningRate: f32,
    Beta1: f32,
    Beta2: f32,
    Epsilon: f32,
};
type
  DML_ADAM_OPTIMIZER_OPERATOR_DESC {.bycopy.} = object
    InputParametersTensor: pointer
    InputFirstMomentTensor: pointer
    InputSecondMomentTensor: pointer
    GradientTensor: pointer
    TrainingStepTensor: pointer
    OutputParametersTensor: pointer
    OutputFirstMomentTensor: pointer
    OutputSecondMomentTensor: pointer
    LearningRate: float32
    Beta1: float32
    Beta2: float32
    Epsilon: float32
struct DML_ADAM_OPTIMIZER_OPERATOR_DESC
{
    void* InputParametersTensor;
    void* InputFirstMomentTensor;
    void* InputSecondMomentTensor;
    void* GradientTensor;
    void* TrainingStepTensor;
    void* OutputParametersTensor;
    void* OutputFirstMomentTensor;
    void* OutputSecondMomentTensor;
    float LearningRate;
    float Beta1;
    float Beta2;
    float Epsilon;
}

HSP用 定義

HSP3.7/3.8 は構造体機能が無いため4byte整数配列(dim)+peek/poke で操作(32/64bitでサイズ・位置が異なる場合はタブで分割)。IronHSP は NSTRUCT(#defstruct/stdim/->)で32/64bit共通。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x86 レイアウト)
; DML_ADAM_OPTIMIZER_OPERATOR_DESC サイズ: 48 バイト(x86)
dim st, 12    ; 4byte整数×12(構造体サイズ 48 / 4 切り上げ)
; InputParametersTensor : DML_TENSOR_DESC* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; InputFirstMomentTensor : DML_TENSOR_DESC* (+4, 4byte)  varptr(st)+4 を基点に操作(4byte:入れ子/配列)
; InputSecondMomentTensor : DML_TENSOR_DESC* (+8, 4byte)  varptr(st)+8 を基点に操作(4byte:入れ子/配列)
; GradientTensor : DML_TENSOR_DESC* (+12, 4byte)  varptr(st)+12 を基点に操作(4byte:入れ子/配列)
; TrainingStepTensor : DML_TENSOR_DESC* (+16, 4byte)  varptr(st)+16 を基点に操作(4byte:入れ子/配列)
; OutputParametersTensor : DML_TENSOR_DESC* (+20, 4byte)  varptr(st)+20 を基点に操作(4byte:入れ子/配列)
; OutputFirstMomentTensor : DML_TENSOR_DESC* (+24, 4byte)  varptr(st)+24 を基点に操作(4byte:入れ子/配列)
; OutputSecondMomentTensor : DML_TENSOR_DESC* (+28, 4byte)  varptr(st)+28 を基点に操作(4byte:入れ子/配列)
; LearningRate : FLOAT (+32, 4byte)  st.8 = 値  /  値 = st.8   (lpoke/lpeek も可)
; Beta1 : FLOAT (+36, 4byte)  st.9 = 値  /  値 = st.9   (lpoke/lpeek も可)
; Beta2 : FLOAT (+40, 4byte)  st.10 = 値  /  値 = st.10   (lpoke/lpeek も可)
; Epsilon : FLOAT (+44, 4byte)  st.11 = 値  /  値 = st.11   (lpoke/lpeek も可)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; DML_ADAM_OPTIMIZER_OPERATOR_DESC サイズ: 80 バイト(x64)
dim st, 20    ; 4byte整数×20(構造体サイズ 80 / 4 切り上げ)
; InputParametersTensor : DML_TENSOR_DESC* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; InputFirstMomentTensor : DML_TENSOR_DESC* (+8, 8byte)  varptr(st)+8 を基点に操作(8byte:入れ子/配列)
; InputSecondMomentTensor : DML_TENSOR_DESC* (+16, 8byte)  varptr(st)+16 を基点に操作(8byte:入れ子/配列)
; GradientTensor : DML_TENSOR_DESC* (+24, 8byte)  varptr(st)+24 を基点に操作(8byte:入れ子/配列)
; TrainingStepTensor : DML_TENSOR_DESC* (+32, 8byte)  varptr(st)+32 を基点に操作(8byte:入れ子/配列)
; OutputParametersTensor : DML_TENSOR_DESC* (+40, 8byte)  varptr(st)+40 を基点に操作(8byte:入れ子/配列)
; OutputFirstMomentTensor : DML_TENSOR_DESC* (+48, 8byte)  varptr(st)+48 を基点に操作(8byte:入れ子/配列)
; OutputSecondMomentTensor : DML_TENSOR_DESC* (+56, 8byte)  varptr(st)+56 を基点に操作(8byte:入れ子/配列)
; LearningRate : FLOAT (+64, 4byte)  st.16 = 値  /  値 = st.16   (lpoke/lpeek も可)
; Beta1 : FLOAT (+68, 4byte)  st.17 = 値  /  値 = st.17   (lpoke/lpeek も可)
; Beta2 : FLOAT (+72, 4byte)  st.18 = 値  /  値 = st.18   (lpoke/lpeek も可)
; Epsilon : FLOAT (+76, 4byte)  st.19 = 値  /  値 = st.19   (lpoke/lpeek も可)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
#defstruct global DML_ADAM_OPTIMIZER_OPERATOR_DESC
    #field intptr InputParametersTensor
    #field intptr InputFirstMomentTensor
    #field intptr InputSecondMomentTensor
    #field intptr GradientTensor
    #field intptr TrainingStepTensor
    #field intptr OutputParametersTensor
    #field intptr OutputFirstMomentTensor
    #field intptr OutputSecondMomentTensor
    #field float LearningRate
    #field float Beta1
    #field float Beta2
    #field float Epsilon
#endstruct

stdim st, DML_ADAM_OPTIMIZER_OPERATOR_DESC        ; NSTRUCT 変数を確保
st->LearningRate = 100
mes "LearningRate=" + st->LearningRate