mirror of
https://github.com/saymrwulf/onnxruntime.git
synced 2026-06-03 23:49:44 +00:00
Update DirectML from 1.14.1 to 1.15.0 (#21323)
Update DirectML from 1.14.1 to 1.15.0 --------- Co-authored-by: Sheil Kumar <sheilk@microsoft.com> Co-authored-by: Dwayne Robinson <dwayner@microsoft.com>
This commit is contained in:
Sheil Kumar
GitHub
parent
11ad299451
commit
dd010edb37
15 changed files with 231 additions and 67 deletions
|
|
@ -1,6 +1,6 @@
|
|||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<packages>
|
||||
<package id="python" version="3.9.7" targetFramework="native" />
|
||||
<package id="Microsoft.AI.DirectML" version="1.14.1" targetFramework="native" />
|
||||
<package id="Microsoft.AI.DirectML" version="1.15.0" targetFramework="native" />
|
||||
<package id="Microsoft.Windows.CppWinRT" version="2.0.201201.7" targetFramework="native" />
|
||||
</packages>
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<packages>
|
||||
<package id="pythonx86" version="3.9.7" targetFramework="native" />
|
||||
<package id="Microsoft.AI.DirectML" version="1.14.1" targetFramework="native" />
|
||||
<package id="Microsoft.AI.DirectML" version="1.15.0" targetFramework="native" />
|
||||
<package id="Microsoft.Windows.CppWinRT" version="2.0.201201.7" targetFramework="native" />
|
||||
</packages>
|
||||
|
|
|
|||
2
cmake/external/dml.cmake
vendored
2
cmake/external/dml.cmake
vendored
|
|
@ -41,7 +41,7 @@ if (NOT onnxruntime_USE_CUSTOM_DIRECTML)
|
|||
set(NUGET_CONFIG ${PROJECT_SOURCE_DIR}/../NuGet.config)
|
||||
set(PACKAGES_CONFIG ${PROJECT_SOURCE_DIR}/../packages.config)
|
||||
get_filename_component(PACKAGES_DIR ${CMAKE_CURRENT_BINARY_DIR}/../packages ABSOLUTE)
|
||||
set(DML_PACKAGE_DIR ${PACKAGES_DIR}/Microsoft.AI.DirectML.1.14.1)
|
||||
set(DML_PACKAGE_DIR ${PACKAGES_DIR}/Microsoft.AI.DirectML.1.15.0)
|
||||
|
||||
# Restore nuget packages, which will pull down the DirectML redist package.
|
||||
add_custom_command(
|
||||
|
|
|
|||
|
|
@ -970,6 +970,7 @@ Do not modify directly.*
|
|||
|||12+|**T** = tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|||11+|**T** = tensor(float), tensor(float16)|
|
||||
|||6+|**T** = tensor(float), tensor(float16)|
|
||||
|Col2Im|*in* input:**T**<br> *in* image_shape:**tensor(int64)**<br> *in* block_shape:**tensor(int64)**<br> *out* output:**T**|18+|**T** = tensor(bool), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|Concat|*in* inputs:**T**<br> *out* concat_result:**T**|13+|**T** = tensor(bool), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|||11+|**T** = tensor(bool), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|||4+|**T** = tensor(bool), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|
|
@ -1131,7 +1132,8 @@ Do not modify directly.*
|
|||
|PRelu|*in* X:**T**<br> *in* slope:**T**<br> *out* Y:**T**|16+|**T** = tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int8)|
|
||||
|||9+|**T** = tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int8)|
|
||||
|||7+|**T** = tensor(float), tensor(float16)|
|
||||
|Pad|*in* data:**T**<br> *in* pads:**tensor(int64)**<br> *in* constant_value:**T**<br> *in* axes:**Tind**<br> *out* output:**T**<br><br>or<br><br>*in* data:**T**<br> *in* pads:**tensor(int64)**<br> *in* constant_value:**T**<br> *out* output:**T**<br><br>or<br><br>*in* data:**T**<br> *out* output:**T**|18+|**T** = tensor(bool), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|Pad|*in* data:**T**<br> *in* pads:**tensor(int64)**<br> *in* constant_value:**T**<br> *in* axes:**Tind**<br> *out* output:**T**<br><br>or<br><br>*in* data:**T**<br> *in* pads:**tensor(int64)**<br> *in* constant_value:**T**<br> *out* output:**T**<br><br>or<br><br>*in* data:**T**<br> *out* output:**T**|19+|**T** = tensor(bool), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|||18+|**T** = tensor(bool), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|||13+|**T** = tensor(bool), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|||11+|**T** = tensor(bool), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|||2+|**T** = tensor(bool), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|
|
@ -1199,7 +1201,9 @@ Do not modify directly.*
|
|||
|||14+|**T** = tensor(bool), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|||13+|**T** = tensor(bool), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|||5+|**T** = tensor(bool), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|Resize|*in* X:**T**<br> *in* scales:**tensor(float)**<br> *out* Y:**T**<br><br>or<br><br>*in* X:**T1**<br> *in* roi:**T2**<br> *in* scales:**tensor(float)**<br> *in* sizes:**tensor(int64)**<br> *out* Y:**T1**|13+|**T1** = tensor(float), tensor(float16), tensor(int8), tensor(uint8)<br/> **T2** = tensor(float), tensor(float16)|
|
||||
|Resize|*in* X:**T**<br> *in* scales:**tensor(float)**<br> *out* Y:**T**<br><br>or<br><br>*in* X:**T1**<br> *in* roi:**T2**<br> *in* scales:**tensor(float)**<br> *in* sizes:**tensor(int64)**<br> *out* Y:**T1**|19+|**T1** = tensor(float), tensor(float16), tensor(int8), tensor(uint8)<br/> **T2** = tensor(float), tensor(float16)|
|
||||
|||18+|**T1** = tensor(float), tensor(float16), tensor(int8), tensor(uint8)<br/> **T2** = tensor(float), tensor(float16)|
|
||||
|||13+|**T1** = tensor(float), tensor(float16), tensor(int8), tensor(uint8)<br/> **T2** = tensor(float), tensor(float16)|
|
||||
|||11+|**T1** = tensor(float), tensor(float16), tensor(int8), tensor(uint8)<br/> **T2** = tensor(float), tensor(float16)|
|
||||
|||10+|**T** = tensor(float), tensor(float16)|
|
||||
|ReverseSequence|*in* input:**T**<br> *in* sequence_lens:**tensor(int64)**<br> *out* Y:**T**|10+|**T** = tensor(bool), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8)|
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
//---------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------
|
||||
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
//
|
||||
// This file is automatically generated. Please do not edit it directly.
|
||||
|
|
@ -241,6 +241,7 @@ DML_OPERATOR_TYPE ApiTraits::StringifyHelpers::FromString(std::string_view value
|
|||
{"DML_OPERATOR_ACTIVATION_SWISH", DML_OPERATOR_ACTIVATION_SWISH},
|
||||
{"DML_OPERATOR_ACTIVATION_HARD_SWISH", DML_OPERATOR_ACTIVATION_HARD_SWISH},
|
||||
{"DML_OPERATOR_RESAMPLE2", DML_OPERATOR_RESAMPLE2},
|
||||
{"DML_OPERATOR_RESAMPLE3", DML_OPERATOR_RESAMPLE3},
|
||||
{"DML_OPERATOR_RESAMPLE_GRAD1", DML_OPERATOR_RESAMPLE_GRAD1},
|
||||
{"DML_OPERATOR_DIAGONAL_MATRIX1", DML_OPERATOR_DIAGONAL_MATRIX1},
|
||||
{"DML_OPERATOR_MULTIHEAD_ATTENTION", DML_OPERATOR_MULTIHEAD_ATTENTION},
|
||||
|
|
@ -250,6 +251,9 @@ DML_OPERATOR_TYPE ApiTraits::StringifyHelpers::FromString(std::string_view value
|
|||
{"DML_OPERATOR_MULTIHEAD_ATTENTION1", DML_OPERATOR_MULTIHEAD_ATTENTION1},
|
||||
{"DML_OPERATOR_QUANTIZE", DML_OPERATOR_QUANTIZE},
|
||||
{"DML_OPERATOR_DEQUANTIZE", DML_OPERATOR_DEQUANTIZE},
|
||||
{"DML_OPERATOR_ROI_ALIGN_GRAD", DML_OPERATOR_ROI_ALIGN_GRAD},
|
||||
{"DML_OPERATOR_FOLD", DML_OPERATOR_FOLD},
|
||||
{"DML_OPERATOR_UNFOLD", DML_OPERATOR_UNFOLD},
|
||||
};
|
||||
auto index = StringUtil::MapToIndex(value, mapping);
|
||||
if (!index)
|
||||
|
|
@ -369,6 +373,7 @@ DML_PADDING_MODE ApiTraits::StringifyHelpers::FromString(std::string_view value)
|
|||
{"DML_PADDING_MODE_EDGE", DML_PADDING_MODE_EDGE},
|
||||
{"DML_PADDING_MODE_REFLECTION", DML_PADDING_MODE_REFLECTION},
|
||||
{"DML_PADDING_MODE_SYMMETRIC", DML_PADDING_MODE_SYMMETRIC},
|
||||
{"DML_PADDING_MODE_WRAP", DML_PADDING_MODE_WRAP},
|
||||
};
|
||||
auto index = StringUtil::MapToIndex(value, mapping);
|
||||
if (!index)
|
||||
|
|
@ -454,6 +459,7 @@ DML_FEATURE_LEVEL ApiTraits::StringifyHelpers::FromString(std::string_view value
|
|||
{"DML_FEATURE_LEVEL_6_1", DML_FEATURE_LEVEL_6_1},
|
||||
{"DML_FEATURE_LEVEL_6_2", DML_FEATURE_LEVEL_6_2},
|
||||
{"DML_FEATURE_LEVEL_6_3", DML_FEATURE_LEVEL_6_3},
|
||||
{"DML_FEATURE_LEVEL_6_4", DML_FEATURE_LEVEL_6_4},
|
||||
};
|
||||
auto index = StringUtil::MapToIndex(value, mapping);
|
||||
if (!index)
|
||||
|
|
|
|||
|
|
@ -29,6 +29,9 @@ union ActivationOperatorDescUnion
|
|||
DML_ACTIVATION_THRESHOLDED_RELU_OPERATOR_DESC thresholdedRelu;
|
||||
DML_ACTIVATION_SHRINK_OPERATOR_DESC shrink;
|
||||
DML_ACTIVATION_GELU_OPERATOR_DESC gelu;
|
||||
DML_ACTIVATION_SWISH_OPERATOR_DESC swish;
|
||||
DML_ACTIVATION_HARD_SWISH_OPERATOR_DESC hardSwish;
|
||||
DML_ELEMENT_WISE_CLIP_OPERATOR_DESC clip;
|
||||
};
|
||||
|
||||
struct ActivationOperatorDesc
|
||||
|
|
@ -46,7 +49,7 @@ struct ActivationOperatorDesc
|
|||
case DML_OPERATOR_ACTIVATION_CELU: return { activationType, ¶ms.celu };
|
||||
case DML_OPERATOR_ACTIVATION_HARDMAX: return { activationType, ¶ms.hardmax };
|
||||
case DML_OPERATOR_ACTIVATION_HARDMAX1: return { activationType, ¶ms.hardmax1 };
|
||||
case DML_OPERATOR_ACTIVATION_HARD_SIGMOID: return { activationType, ¶ms.sigmoid };
|
||||
case DML_OPERATOR_ACTIVATION_HARD_SIGMOID: return { activationType, ¶ms.hardSigmoid };
|
||||
case DML_OPERATOR_ACTIVATION_IDENTITY: return { activationType, ¶ms.identity };
|
||||
case DML_OPERATOR_ACTIVATION_LEAKY_RELU: return { activationType, ¶ms.leakyRelu };
|
||||
case DML_OPERATOR_ACTIVATION_LINEAR: return { activationType, ¶ms.linear };
|
||||
|
|
@ -66,6 +69,9 @@ struct ActivationOperatorDesc
|
|||
case DML_OPERATOR_ACTIVATION_THRESHOLDED_RELU: return { activationType, ¶ms.thresholdedRelu };
|
||||
case DML_OPERATOR_ACTIVATION_SHRINK: return { activationType, ¶ms.shrink };
|
||||
case DML_OPERATOR_ACTIVATION_GELU: return { activationType, ¶ms.gelu };
|
||||
case DML_OPERATOR_ACTIVATION_SWISH: return { activationType, ¶ms.swish };
|
||||
case DML_OPERATOR_ACTIVATION_HARD_SWISH: return { activationType, ¶ms.hardSwish };
|
||||
case DML_OPERATOR_ELEMENT_WISE_CLIP: return { activationType, ¶ms.clip };
|
||||
default:
|
||||
ORT_THROW_HR(E_INVALIDARG);
|
||||
return { activationType, ¶ms.relu };
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
// Licensed under the MIT License.
|
||||
#pragma once
|
||||
|
||||
|
|
@ -24,7 +24,7 @@ struct EnumTraits<DML_TENSOR_TYPE>
|
|||
template <>
|
||||
struct EnumTraits<DML_OPERATOR_TYPE>
|
||||
{
|
||||
static constexpr auto ValueCount = 174;
|
||||
static constexpr auto ValueCount = 178;
|
||||
static constexpr size_t ActivationFunctionCount = 26;
|
||||
};
|
||||
|
||||
|
|
@ -62,7 +62,7 @@ struct EnumTraits<DML_CONVOLUTION_DIRECTION>
|
|||
template <>
|
||||
struct EnumTraits<DML_PADDING_MODE>
|
||||
{
|
||||
static constexpr auto ValueCount = 4;
|
||||
static constexpr auto ValueCount = 5;
|
||||
};
|
||||
|
||||
template <>
|
||||
|
|
@ -86,7 +86,7 @@ struct EnumTraits<DML_FEATURE>
|
|||
template <>
|
||||
struct EnumTraits<DML_FEATURE_LEVEL>
|
||||
{
|
||||
static constexpr auto ValueCount = 14;
|
||||
static constexpr auto ValueCount = 15;
|
||||
};
|
||||
|
||||
template <>
|
||||
|
|
@ -1023,6 +1023,12 @@ struct OperatorDescTraits<DML_RESAMPLE2_OPERATOR_DESC>
|
|||
static constexpr DML_OPERATOR_TYPE Type = DML_OPERATOR_RESAMPLE2;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct OperatorDescTraits<DML_RESAMPLE3_OPERATOR_DESC>
|
||||
{
|
||||
static constexpr DML_OPERATOR_TYPE Type = DML_OPERATOR_RESAMPLE3;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct OperatorDescTraits<DML_RESAMPLE_GRAD1_OPERATOR_DESC>
|
||||
{
|
||||
|
|
@ -1053,6 +1059,18 @@ struct OperatorDescTraits<DML_MATRIX_MULTIPLY_INTEGER_TO_FLOAT_OPERATOR_DESC>
|
|||
static constexpr DML_OPERATOR_TYPE Type = DML_OPERATOR_MATRIX_MULTIPLY_INTEGER_TO_FLOAT;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct OperatorDescTraits<DML_FOLD_OPERATOR_DESC>
|
||||
{
|
||||
static constexpr DML_OPERATOR_TYPE Type = DML_OPERATOR_FOLD;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct OperatorDescTraits<DML_UNFOLD_OPERATOR_DESC>
|
||||
{
|
||||
static constexpr DML_OPERATOR_TYPE Type = DML_OPERATOR_UNFOLD;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct OperatorDescTraits<DML_MEAN_VARIANCE_NORMALIZATION2_OPERATOR_DESC>
|
||||
{
|
||||
|
|
@ -2073,6 +2091,12 @@ struct OperatorTypeTraits<(DML_OPERATOR_TYPE)DML_OPERATOR_RESAMPLE2>
|
|||
using DescType = DML_RESAMPLE2_OPERATOR_DESC;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct OperatorTypeTraits<(DML_OPERATOR_TYPE)DML_OPERATOR_RESAMPLE3>
|
||||
{
|
||||
using DescType = DML_RESAMPLE3_OPERATOR_DESC;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct OperatorTypeTraits<(DML_OPERATOR_TYPE)DML_OPERATOR_RESAMPLE_GRAD1>
|
||||
{
|
||||
|
|
@ -2103,6 +2127,18 @@ struct OperatorTypeTraits<(DML_OPERATOR_TYPE)DML_OPERATOR_MATRIX_MULTIPLY_INTEGE
|
|||
using DescType = DML_MATRIX_MULTIPLY_INTEGER_TO_FLOAT_OPERATOR_DESC;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct OperatorTypeTraits<(DML_OPERATOR_TYPE)DML_OPERATOR_FOLD>
|
||||
{
|
||||
using DescType = DML_FOLD_OPERATOR_DESC;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct OperatorTypeTraits<(DML_OPERATOR_TYPE)DML_OPERATOR_UNFOLD>
|
||||
{
|
||||
using DescType = DML_UNFOLD_OPERATOR_DESC;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct OperatorTypeTraits<(DML_OPERATOR_TYPE)DML_OPERATOR_MEAN_VARIANCE_NORMALIZATION2>
|
||||
{
|
||||
|
|
@ -2575,6 +2611,8 @@ auto OperatorTypeVisitor(DML_OPERATOR_TYPE type, Visitor&& visitor, Ts&&... args
|
|||
return std::invoke(std::forward<Visitor>(visitor), DML_BATCH_NORMALIZATION_TRAINING_OPERATOR_DESC{}, std::forward<Ts>(args)...);
|
||||
case DML_OPERATOR_RESAMPLE2:
|
||||
return std::invoke(std::forward<Visitor>(visitor), DML_RESAMPLE2_OPERATOR_DESC{}, std::forward<Ts>(args)...);
|
||||
case DML_OPERATOR_RESAMPLE3:
|
||||
return std::invoke(std::forward<Visitor>(visitor), DML_RESAMPLE3_OPERATOR_DESC{}, std::forward<Ts>(args)...);
|
||||
case DML_OPERATOR_RESAMPLE_GRAD1:
|
||||
return std::invoke(std::forward<Visitor>(visitor), DML_RESAMPLE_GRAD1_OPERATOR_DESC{}, std::forward<Ts>(args)...);
|
||||
case DML_OPERATOR_DIAGONAL_MATRIX1:
|
||||
|
|
@ -2585,6 +2623,10 @@ auto OperatorTypeVisitor(DML_OPERATOR_TYPE type, Visitor&& visitor, Ts&&... args
|
|||
return std::invoke(std::forward<Visitor>(visitor), DML_QUANTIZED_LINEAR_AVERAGE_POOLING_OPERATOR_DESC{}, std::forward<Ts>(args)...);
|
||||
case DML_OPERATOR_MATRIX_MULTIPLY_INTEGER_TO_FLOAT:
|
||||
return std::invoke(std::forward<Visitor>(visitor), DML_MATRIX_MULTIPLY_INTEGER_TO_FLOAT_OPERATOR_DESC{}, std::forward<Ts>(args)...);
|
||||
case DML_OPERATOR_FOLD:
|
||||
return std::invoke(std::forward<Visitor>(visitor), DML_FOLD_OPERATOR_DESC{}, std::forward<Ts>(args)...);
|
||||
case DML_OPERATOR_UNFOLD:
|
||||
return std::invoke(std::forward<Visitor>(visitor), DML_UNFOLD_OPERATOR_DESC{}, std::forward<Ts>(args)...);
|
||||
case DML_OPERATOR_MEAN_VARIANCE_NORMALIZATION2:
|
||||
return std::invoke(std::forward<Visitor>(visitor), DML_MEAN_VARIANCE_NORMALIZATION2_OPERATOR_DESC{}, std::forward<Ts>(args)...);
|
||||
case DML_OPERATOR_MULTIHEAD_ATTENTION1:
|
||||
|
|
@ -2650,7 +2692,6 @@ auto OperatorTypeVisitor(DML_OPERATOR_TYPE type, Visitor&& visitor, Ts&&... args
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
namespace StringifyHelpers
|
||||
{
|
||||
template <typename T>
|
||||
|
|
@ -2871,6 +2912,7 @@ inline gsl::czstring ToString(DML_OPERATOR_TYPE value)
|
|||
case DML_OPERATOR_ACTIVATION_SWISH: return "DML_OPERATOR_ACTIVATION_SWISH";
|
||||
case DML_OPERATOR_ACTIVATION_HARD_SWISH: return "DML_OPERATOR_ACTIVATION_HARD_SWISH";
|
||||
case DML_OPERATOR_RESAMPLE2: return "DML_OPERATOR_RESAMPLE2";
|
||||
case DML_OPERATOR_RESAMPLE3: return "DML_OPERATOR_RESAMPLE3";
|
||||
case DML_OPERATOR_RESAMPLE_GRAD1: return "DML_OPERATOR_RESAMPLE_GRAD1";
|
||||
case DML_OPERATOR_DIAGONAL_MATRIX1: return "DML_OPERATOR_DIAGONAL_MATRIX1";
|
||||
case DML_OPERATOR_MULTIHEAD_ATTENTION: return "DML_OPERATOR_MULTIHEAD_ATTENTION";
|
||||
|
|
@ -2880,6 +2922,9 @@ inline gsl::czstring ToString(DML_OPERATOR_TYPE value)
|
|||
case DML_OPERATOR_MULTIHEAD_ATTENTION1: return "DML_OPERATOR_MULTIHEAD_ATTENTION1";
|
||||
case DML_OPERATOR_QUANTIZE: return "DML_OPERATOR_QUANTIZE";
|
||||
case DML_OPERATOR_DEQUANTIZE: return "DML_OPERATOR_DEQUANTIZE";
|
||||
case DML_OPERATOR_ROI_ALIGN_GRAD: return "DML_OPERATOR_ROI_ALIGN_GRAD";
|
||||
case DML_OPERATOR_FOLD: return "DML_OPERATOR_FOLD";
|
||||
case DML_OPERATOR_UNFOLD: return "DML_OPERATOR_UNFOLD";
|
||||
default:
|
||||
assert(false);
|
||||
return "<unknown>";
|
||||
|
|
@ -2971,6 +3016,7 @@ inline gsl::czstring ToString(DML_PADDING_MODE value)
|
|||
case DML_PADDING_MODE_EDGE: return "DML_PADDING_MODE_EDGE";
|
||||
case DML_PADDING_MODE_REFLECTION: return "DML_PADDING_MODE_REFLECTION";
|
||||
case DML_PADDING_MODE_SYMMETRIC: return "DML_PADDING_MODE_SYMMETRIC";
|
||||
case DML_PADDING_MODE_WRAP: return "DML_PADDING_MODE_WRAP";
|
||||
default:
|
||||
assert(false);
|
||||
return "<unknown>";
|
||||
|
|
@ -3036,6 +3082,7 @@ inline gsl::czstring ToString(DML_FEATURE_LEVEL value)
|
|||
case DML_FEATURE_LEVEL_6_1: return "DML_FEATURE_LEVEL_6_1";
|
||||
case DML_FEATURE_LEVEL_6_2: return "DML_FEATURE_LEVEL_6_2";
|
||||
case DML_FEATURE_LEVEL_6_3: return "DML_FEATURE_LEVEL_6_3";
|
||||
case DML_FEATURE_LEVEL_6_4: return "DML_FEATURE_LEVEL_6_4";
|
||||
default:
|
||||
assert(false);
|
||||
return "<unknown>";
|
||||
|
|
|
|||
|
|
@ -2306,6 +2306,26 @@ constexpr DML_OPERATOR_SCHEMA DML_RESAMPLE2_OPERATOR_SCHEMA {
|
|||
DML_RESAMPLE2_OPERATOR_SCHEMA_FIELDS,
|
||||
};
|
||||
|
||||
constexpr DML_SCHEMA_FIELD DML_RESAMPLE3_OPERATOR_SCHEMA_FIELDS[9] {
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_INPUT_TENSOR, DML_SCHEMA_FIELD_TYPE_TENSOR_DESC, "InputTensor", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_OUTPUT_TENSOR, DML_SCHEMA_FIELD_TYPE_TENSOR_DESC, "OutputTensor", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT, "InterpolationMode", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT, "RoundingDirection", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT, "DimensionCount", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_FLOAT_ARRAY, "Scales", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_FLOAT_ARRAY, "InputPixelOffsets", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_FLOAT_ARRAY, "OutputPixelOffsets", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT, "Antialiased", false },
|
||||
};
|
||||
|
||||
constexpr DML_OPERATOR_SCHEMA DML_RESAMPLE3_OPERATOR_SCHEMA {
|
||||
"DML_OPERATOR_RESAMPLE3",
|
||||
DML_OPERATOR_RESAMPLE3,
|
||||
DML_SCHEMA_OPERATOR_SUPPORT_FLAG_NONE,
|
||||
9,
|
||||
DML_RESAMPLE3_OPERATOR_SCHEMA_FIELDS,
|
||||
};
|
||||
|
||||
constexpr DML_SCHEMA_FIELD DML_RESAMPLE_GRAD1_OPERATOR_SCHEMA_FIELDS[8] {
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_INPUT_TENSOR, DML_SCHEMA_FIELD_TYPE_TENSOR_DESC, "InputGradientTensor", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_OUTPUT_TENSOR, DML_SCHEMA_FIELD_TYPE_TENSOR_DESC, "OutputGradientTensor", false },
|
||||
|
|
@ -2414,6 +2434,44 @@ constexpr DML_OPERATOR_SCHEMA DML_MATRIX_MULTIPLY_INTEGER_TO_FLOAT_OPERATOR_SCHE
|
|||
DML_MATRIX_MULTIPLY_INTEGER_TO_FLOAT_OPERATOR_SCHEMA_FIELDS,
|
||||
};
|
||||
|
||||
constexpr DML_SCHEMA_FIELD DML_FOLD_OPERATOR_SCHEMA_FIELDS[8] {
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_INPUT_TENSOR, DML_SCHEMA_FIELD_TYPE_TENSOR_DESC, "InputTensor", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_OUTPUT_TENSOR, DML_SCHEMA_FIELD_TYPE_TENSOR_DESC, "OutputTensor", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT, "DimensionCount", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT_ARRAY, "WindowSizes", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT_ARRAY, "Strides", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT_ARRAY, "Dilations", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT_ARRAY, "StartPadding", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT_ARRAY, "EndPadding", false },
|
||||
};
|
||||
|
||||
constexpr DML_OPERATOR_SCHEMA DML_FOLD_OPERATOR_SCHEMA {
|
||||
"DML_OPERATOR_FOLD",
|
||||
DML_OPERATOR_FOLD,
|
||||
DML_SCHEMA_OPERATOR_SUPPORT_FLAG_NONE,
|
||||
8,
|
||||
DML_FOLD_OPERATOR_SCHEMA_FIELDS,
|
||||
};
|
||||
|
||||
constexpr DML_SCHEMA_FIELD DML_UNFOLD_OPERATOR_SCHEMA_FIELDS[8] {
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_INPUT_TENSOR, DML_SCHEMA_FIELD_TYPE_TENSOR_DESC, "InputTensor", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_OUTPUT_TENSOR, DML_SCHEMA_FIELD_TYPE_TENSOR_DESC, "OutputTensor", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT, "DimensionCount", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT_ARRAY, "WindowSizes", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT_ARRAY, "Strides", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT_ARRAY, "Dilations", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT_ARRAY, "StartPadding", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_ATTRIBUTE, DML_SCHEMA_FIELD_TYPE_UINT_ARRAY, "EndPadding", false },
|
||||
};
|
||||
|
||||
constexpr DML_OPERATOR_SCHEMA DML_UNFOLD_OPERATOR_SCHEMA {
|
||||
"DML_OPERATOR_UNFOLD",
|
||||
DML_OPERATOR_UNFOLD,
|
||||
DML_SCHEMA_OPERATOR_SUPPORT_FLAG_NONE,
|
||||
8,
|
||||
DML_UNFOLD_OPERATOR_SCHEMA_FIELDS,
|
||||
};
|
||||
|
||||
constexpr DML_SCHEMA_FIELD DML_MEAN_VARIANCE_NORMALIZATION2_OPERATOR_SCHEMA_FIELDS[10] {
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_INPUT_TENSOR, DML_SCHEMA_FIELD_TYPE_TENSOR_DESC, "InputTensor", false },
|
||||
DML_SCHEMA_FIELD { DML_SCHEMA_FIELD_KIND_INPUT_TENSOR, DML_SCHEMA_FIELD_TYPE_TENSOR_DESC, "ScaleTensor", true },
|
||||
|
|
|
|||
|
|
@ -11,4 +11,4 @@ struct NodeIndex
|
|||
|
||||
DmlSerializedGraphDesc DeserializeDmlGraph(
|
||||
const uint8_t* flatbufferGraphDescBlob,
|
||||
/*out*/ std::vector<std::unique_ptr<std::byte[]>>& rawData);
|
||||
/*out*/ std::vector<std::unique_ptr<std::byte[]>>& rawData);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
// Licensed under the MIT License.
|
||||
|
||||
#pragma once
|
||||
|
|
@ -1422,6 +1422,20 @@ inline std::vector<OperatorField> GetFields(const DML_RESAMPLE2_OPERATOR_DESC& d
|
|||
OperatorField(&DML_RESAMPLE2_OPERATOR_SCHEMA.Fields[7], ToOperatorFieldType(static_cast<const FLOAT*>(desc.OutputPixelOffsets), desc.DimensionCount)),
|
||||
};
|
||||
}
|
||||
inline std::vector<OperatorField> GetFields(const DML_RESAMPLE3_OPERATOR_DESC& desc)
|
||||
{
|
||||
return {
|
||||
OperatorField(&DML_RESAMPLE3_OPERATOR_SCHEMA.Fields[0], ToOperatorFieldType(static_cast<const DML_TENSOR_DESC*>(desc.InputTensor))),
|
||||
OperatorField(&DML_RESAMPLE3_OPERATOR_SCHEMA.Fields[1], ToOperatorFieldType(static_cast<const DML_TENSOR_DESC*>(desc.OutputTensor))),
|
||||
OperatorField(&DML_RESAMPLE3_OPERATOR_SCHEMA.Fields[2], ToOperatorFieldType(static_cast<UINT>(desc.InterpolationMode))),
|
||||
OperatorField(&DML_RESAMPLE3_OPERATOR_SCHEMA.Fields[3], ToOperatorFieldType(static_cast<UINT>(desc.RoundingDirection))),
|
||||
OperatorField(&DML_RESAMPLE3_OPERATOR_SCHEMA.Fields[4], ToOperatorFieldType(static_cast<UINT>(desc.DimensionCount))),
|
||||
OperatorField(&DML_RESAMPLE3_OPERATOR_SCHEMA.Fields[5], ToOperatorFieldType(static_cast<const FLOAT*>(desc.Scales), desc.DimensionCount)),
|
||||
OperatorField(&DML_RESAMPLE3_OPERATOR_SCHEMA.Fields[6], ToOperatorFieldType(static_cast<const FLOAT*>(desc.InputPixelOffsets), desc.DimensionCount)),
|
||||
OperatorField(&DML_RESAMPLE3_OPERATOR_SCHEMA.Fields[7], ToOperatorFieldType(static_cast<const FLOAT*>(desc.OutputPixelOffsets), desc.DimensionCount)),
|
||||
OperatorField(&DML_RESAMPLE3_OPERATOR_SCHEMA.Fields[8], ToOperatorFieldType(static_cast<UINT>(desc.Antialiased))),
|
||||
};
|
||||
}
|
||||
inline std::vector<OperatorField> GetFields(const DML_RESAMPLE_GRAD1_OPERATOR_DESC& desc)
|
||||
{
|
||||
return {
|
||||
|
|
@ -1500,6 +1514,32 @@ inline std::vector<OperatorField> GetFields(const DML_MATRIX_MULTIPLY_INTEGER_TO
|
|||
OperatorField(&DML_MATRIX_MULTIPLY_INTEGER_TO_FLOAT_OPERATOR_SCHEMA.Fields[7], ToOperatorFieldType(static_cast<const DML_TENSOR_DESC*>(desc.OutputTensor))),
|
||||
};
|
||||
}
|
||||
inline std::vector<OperatorField> GetFields(const DML_FOLD_OPERATOR_DESC& desc)
|
||||
{
|
||||
return {
|
||||
OperatorField(&DML_FOLD_OPERATOR_SCHEMA.Fields[0], ToOperatorFieldType(static_cast<const DML_TENSOR_DESC*>(desc.InputTensor))),
|
||||
OperatorField(&DML_FOLD_OPERATOR_SCHEMA.Fields[1], ToOperatorFieldType(static_cast<const DML_TENSOR_DESC*>(desc.OutputTensor))),
|
||||
OperatorField(&DML_FOLD_OPERATOR_SCHEMA.Fields[2], ToOperatorFieldType(static_cast<UINT>(desc.DimensionCount))),
|
||||
OperatorField(&DML_FOLD_OPERATOR_SCHEMA.Fields[3], ToOperatorFieldType(static_cast<const UINT*>(desc.WindowSizes), desc.DimensionCount)),
|
||||
OperatorField(&DML_FOLD_OPERATOR_SCHEMA.Fields[4], ToOperatorFieldType(static_cast<const UINT*>(desc.Strides), desc.DimensionCount)),
|
||||
OperatorField(&DML_FOLD_OPERATOR_SCHEMA.Fields[5], ToOperatorFieldType(static_cast<const UINT*>(desc.Dilations), desc.DimensionCount)),
|
||||
OperatorField(&DML_FOLD_OPERATOR_SCHEMA.Fields[6], ToOperatorFieldType(static_cast<const UINT*>(desc.StartPadding), desc.DimensionCount)),
|
||||
OperatorField(&DML_FOLD_OPERATOR_SCHEMA.Fields[7], ToOperatorFieldType(static_cast<const UINT*>(desc.EndPadding), desc.DimensionCount)),
|
||||
};
|
||||
}
|
||||
inline std::vector<OperatorField> GetFields(const DML_UNFOLD_OPERATOR_DESC& desc)
|
||||
{
|
||||
return {
|
||||
OperatorField(&DML_UNFOLD_OPERATOR_SCHEMA.Fields[0], ToOperatorFieldType(static_cast<const DML_TENSOR_DESC*>(desc.InputTensor))),
|
||||
OperatorField(&DML_UNFOLD_OPERATOR_SCHEMA.Fields[1], ToOperatorFieldType(static_cast<const DML_TENSOR_DESC*>(desc.OutputTensor))),
|
||||
OperatorField(&DML_UNFOLD_OPERATOR_SCHEMA.Fields[2], ToOperatorFieldType(static_cast<UINT>(desc.DimensionCount))),
|
||||
OperatorField(&DML_UNFOLD_OPERATOR_SCHEMA.Fields[3], ToOperatorFieldType(static_cast<const UINT*>(desc.WindowSizes), desc.DimensionCount)),
|
||||
OperatorField(&DML_UNFOLD_OPERATOR_SCHEMA.Fields[4], ToOperatorFieldType(static_cast<const UINT*>(desc.Strides), desc.DimensionCount)),
|
||||
OperatorField(&DML_UNFOLD_OPERATOR_SCHEMA.Fields[5], ToOperatorFieldType(static_cast<const UINT*>(desc.Dilations), desc.DimensionCount)),
|
||||
OperatorField(&DML_UNFOLD_OPERATOR_SCHEMA.Fields[6], ToOperatorFieldType(static_cast<const UINT*>(desc.StartPadding), desc.DimensionCount)),
|
||||
OperatorField(&DML_UNFOLD_OPERATOR_SCHEMA.Fields[7], ToOperatorFieldType(static_cast<const UINT*>(desc.EndPadding), desc.DimensionCount)),
|
||||
};
|
||||
}
|
||||
inline std::vector<OperatorField> GetFields(const DML_MEAN_VARIANCE_NORMALIZATION2_OPERATOR_DESC& desc)
|
||||
{
|
||||
return {
|
||||
|
|
@ -1912,11 +1952,14 @@ inline const DML_OPERATOR_SCHEMA& GetSchema(DML_OPERATOR_TYPE operatorType)
|
|||
case DML_OPERATOR_ROI_ALIGN_GRAD: return DML_ROI_ALIGN_GRAD_OPERATOR_SCHEMA;
|
||||
case DML_OPERATOR_BATCH_NORMALIZATION_TRAINING: return DML_BATCH_NORMALIZATION_TRAINING_OPERATOR_SCHEMA;
|
||||
case DML_OPERATOR_RESAMPLE2: return DML_RESAMPLE2_OPERATOR_SCHEMA;
|
||||
case DML_OPERATOR_RESAMPLE3: return DML_RESAMPLE3_OPERATOR_SCHEMA;
|
||||
case DML_OPERATOR_RESAMPLE_GRAD1: return DML_RESAMPLE_GRAD1_OPERATOR_SCHEMA;
|
||||
case DML_OPERATOR_DIAGONAL_MATRIX1: return DML_DIAGONAL_MATRIX1_OPERATOR_SCHEMA;
|
||||
case DML_OPERATOR_MULTIHEAD_ATTENTION: return DML_MULTIHEAD_ATTENTION_OPERATOR_SCHEMA;
|
||||
case DML_OPERATOR_QUANTIZED_LINEAR_AVERAGE_POOLING: return DML_QUANTIZED_LINEAR_AVERAGE_POOLING_OPERATOR_SCHEMA;
|
||||
case DML_OPERATOR_MATRIX_MULTIPLY_INTEGER_TO_FLOAT: return DML_MATRIX_MULTIPLY_INTEGER_TO_FLOAT_OPERATOR_SCHEMA;
|
||||
case DML_OPERATOR_FOLD: return DML_FOLD_OPERATOR_SCHEMA;
|
||||
case DML_OPERATOR_UNFOLD: return DML_UNFOLD_OPERATOR_SCHEMA;
|
||||
case DML_OPERATOR_MEAN_VARIANCE_NORMALIZATION2: return DML_MEAN_VARIANCE_NORMALIZATION2_OPERATOR_SCHEMA;
|
||||
case DML_OPERATOR_MULTIHEAD_ATTENTION1: return DML_MULTIHEAD_ATTENTION1_OPERATOR_SCHEMA;
|
||||
case DML_OPERATOR_QUANTIZE: return DML_QUANTIZE_OPERATOR_SCHEMA;
|
||||
|
|
@ -2095,11 +2138,14 @@ inline const bool IsValidOperator(DML_OPERATOR_TYPE operatorType)
|
|||
case DML_OPERATOR_ROI_ALIGN_GRAD:
|
||||
case DML_OPERATOR_BATCH_NORMALIZATION_TRAINING:
|
||||
case DML_OPERATOR_RESAMPLE2:
|
||||
case DML_OPERATOR_RESAMPLE3:
|
||||
case DML_OPERATOR_RESAMPLE_GRAD1:
|
||||
case DML_OPERATOR_DIAGONAL_MATRIX1:
|
||||
case DML_OPERATOR_MULTIHEAD_ATTENTION:
|
||||
case DML_OPERATOR_QUANTIZED_LINEAR_AVERAGE_POOLING:
|
||||
case DML_OPERATOR_MATRIX_MULTIPLY_INTEGER_TO_FLOAT:
|
||||
case DML_OPERATOR_FOLD:
|
||||
case DML_OPERATOR_UNFOLD:
|
||||
case DML_OPERATOR_MEAN_VARIANCE_NORMALIZATION2:
|
||||
case DML_OPERATOR_MULTIHEAD_ATTENTION1:
|
||||
case DML_OPERATOR_QUANTIZE:
|
||||
|
|
@ -2695,6 +2741,10 @@ inline AbstractOperatorDesc ConvertOperatorDesc(const DML_OPERATOR_DESC& opDesc)
|
|||
return AbstractOperatorDesc(
|
||||
&DML_RESAMPLE2_OPERATOR_SCHEMA,
|
||||
GetFields(*static_cast<const DML_RESAMPLE2_OPERATOR_DESC*>(opDesc.Desc)));
|
||||
case DML_OPERATOR_RESAMPLE3:
|
||||
return AbstractOperatorDesc(
|
||||
&DML_RESAMPLE3_OPERATOR_SCHEMA,
|
||||
GetFields(*static_cast<const DML_RESAMPLE3_OPERATOR_DESC*>(opDesc.Desc)));
|
||||
case DML_OPERATOR_RESAMPLE_GRAD1:
|
||||
return AbstractOperatorDesc(
|
||||
&DML_RESAMPLE_GRAD1_OPERATOR_SCHEMA,
|
||||
|
|
@ -2715,6 +2765,14 @@ inline AbstractOperatorDesc ConvertOperatorDesc(const DML_OPERATOR_DESC& opDesc)
|
|||
return AbstractOperatorDesc(
|
||||
&DML_MATRIX_MULTIPLY_INTEGER_TO_FLOAT_OPERATOR_SCHEMA,
|
||||
GetFields(*static_cast<const DML_MATRIX_MULTIPLY_INTEGER_TO_FLOAT_OPERATOR_DESC*>(opDesc.Desc)));
|
||||
case DML_OPERATOR_FOLD:
|
||||
return AbstractOperatorDesc(
|
||||
&DML_FOLD_OPERATOR_SCHEMA,
|
||||
GetFields(*static_cast<const DML_FOLD_OPERATOR_DESC*>(opDesc.Desc)));
|
||||
case DML_OPERATOR_UNFOLD:
|
||||
return AbstractOperatorDesc(
|
||||
&DML_UNFOLD_OPERATOR_SCHEMA,
|
||||
GetFields(*static_cast<const DML_UNFOLD_OPERATOR_DESC*>(opDesc.Desc)));
|
||||
case DML_OPERATOR_MEAN_VARIANCE_NORMALIZATION2:
|
||||
return AbstractOperatorDesc(
|
||||
&DML_MEAN_VARIANCE_NORMALIZATION2_OPERATOR_SCHEMA,
|
||||
|
|
|
|||
|
|
@ -1,21 +1,21 @@
|
|||
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
// Licensed under the MIT License.
|
||||
|
||||
#pragma once
|
||||
|
||||
using ApiAttributeVariant = std::variant<
|
||||
const DML_TENSOR_DESC*,
|
||||
const DML_OPERATOR_DESC*,
|
||||
UINT,
|
||||
UINT64,
|
||||
INT,
|
||||
FLOAT,
|
||||
const UINT*,
|
||||
const INT*,
|
||||
const FLOAT*,
|
||||
const DML_SCALE_BIAS*,
|
||||
DML_SIZE_2D,
|
||||
DML_SCALAR_UNION,
|
||||
const DML_TENSOR_DESC*,
|
||||
const DML_OPERATOR_DESC*,
|
||||
UINT,
|
||||
UINT64,
|
||||
INT,
|
||||
FLOAT,
|
||||
const UINT*,
|
||||
const INT*,
|
||||
const FLOAT*,
|
||||
const DML_SCALE_BIAS*,
|
||||
DML_SIZE_2D,
|
||||
DML_SCALAR_UNION,
|
||||
BOOL
|
||||
>;
|
||||
|
||||
|
|
@ -39,20 +39,20 @@ namespace OperatorFieldTypes
|
|||
}
|
||||
|
||||
using OperatorFieldVariant = std::variant<
|
||||
OperatorFieldTypes::TensorDesc,
|
||||
OperatorFieldTypes::TensorDescArray,
|
||||
OperatorFieldTypes::FusedActivationOperatorDesc,
|
||||
OperatorFieldTypes::FusedActivationOperatorDescArray,
|
||||
OperatorFieldTypes::UInt,
|
||||
OperatorFieldTypes::UInt64,
|
||||
OperatorFieldTypes::Int,
|
||||
OperatorFieldTypes::Float,
|
||||
OperatorFieldTypes::UIntArray,
|
||||
OperatorFieldTypes::IntArray,
|
||||
OperatorFieldTypes::FloatArray,
|
||||
OperatorFieldTypes::ScaleBias,
|
||||
OperatorFieldTypes::Size2D,
|
||||
OperatorFieldTypes::ScalarUnion,
|
||||
OperatorFieldTypes::TensorDesc,
|
||||
OperatorFieldTypes::TensorDescArray,
|
||||
OperatorFieldTypes::FusedActivationOperatorDesc,
|
||||
OperatorFieldTypes::FusedActivationOperatorDescArray,
|
||||
OperatorFieldTypes::UInt,
|
||||
OperatorFieldTypes::UInt64,
|
||||
OperatorFieldTypes::Int,
|
||||
OperatorFieldTypes::Float,
|
||||
OperatorFieldTypes::UIntArray,
|
||||
OperatorFieldTypes::IntArray,
|
||||
OperatorFieldTypes::FloatArray,
|
||||
OperatorFieldTypes::ScaleBias,
|
||||
OperatorFieldTypes::Size2D,
|
||||
OperatorFieldTypes::ScalarUnion,
|
||||
OperatorFieldTypes::Bool
|
||||
>;
|
||||
|
||||
|
|
@ -126,4 +126,3 @@ private:
|
|||
const DML_SCHEMA_FIELD* m_schema;
|
||||
OperatorFieldVariant m_data;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -263,11 +263,6 @@ public:
|
|||
std::string mode = kernelCreationContext.GetOptionalAttribute<std::string>(AttrName::Mode, "NEAREST");
|
||||
DML_INTERPOLATION_MODE interpolationMode = Dml::MapStringToInteropolationMode(mode);
|
||||
|
||||
|
||||
#if DML_TARGET_VERSION >= 0x6400
|
||||
const int antialiased = kernelCreationContext.GetOptionalAttribute<int>(AttrName::Antialiased, 0);
|
||||
#endif
|
||||
|
||||
// Map ONNX to DML's mode using offsets and rounding direction.
|
||||
// These offsets are in addition to the coordinate transform offsets.
|
||||
DML_AXIS_DIRECTION roundingDirection = DML_AXIS_DIRECTION_DECREASING;
|
||||
|
|
@ -307,12 +302,11 @@ public:
|
|||
std::vector<DML_TENSOR_DESC> inputDescs = GetDmlInputDescs();
|
||||
std::vector<DML_TENSOR_DESC> outputDescs = GetDmlOutputDescs();
|
||||
|
||||
#if DML_TARGET_VERSION >= 0x6400
|
||||
DML_OPERATOR_DESC opDesc = {};
|
||||
const int antialiased = kernelCreationContext.GetOptionalAttribute<int>(AttrName::Antialiased, 0);
|
||||
|
||||
DML_RESAMPLE3_OPERATOR_DESC operatorDesc = {};
|
||||
operatorDesc.Antialiased = static_cast<BOOL>(antialiased);
|
||||
#else
|
||||
DML_RESAMPLE2_OPERATOR_DESC operatorDesc = {};
|
||||
#endif
|
||||
operatorDesc.InputTensor = inputDescs.data();
|
||||
operatorDesc.OutputTensor = outputDescs.data();
|
||||
operatorDesc.InterpolationMode = interpolationMode;
|
||||
|
|
@ -321,11 +315,8 @@ public:
|
|||
operatorDesc.DimensionCount = gsl::narrow_cast<uint32_t>(paddedScales.size());
|
||||
operatorDesc.InputPixelOffsets = inputPixelOffsets.data();
|
||||
operatorDesc.OutputPixelOffsets = outputPixelOffsets.data();
|
||||
#if DML_TARGET_VERSION >= 0x6400
|
||||
DML_OPERATOR_DESC opDesc = { DML_OPERATOR_RESAMPLE3, &operatorDesc };
|
||||
#else
|
||||
DML_OPERATOR_DESC opDesc = { DML_OPERATOR_RESAMPLE2, &operatorDesc };
|
||||
#endif
|
||||
opDesc = { DML_OPERATOR_RESAMPLE3, &operatorDesc };
|
||||
|
||||
SetDmlOperatorDesc(opDesc, kernelCreationContext);
|
||||
}
|
||||
};
|
||||
|
|
@ -368,10 +359,8 @@ void CALLBACK QueryResize(IMLOperatorSupportQueryContextPrivate* context, bool*
|
|||
DML_OP_DEFINE_CREATION_FUNCTION(Resize10, VersionedKernel<DmlOperatorResize, 10>);
|
||||
DML_OP_DEFINE_CREATION_FUNCTION(Resize11, VersionedKernel<DmlOperatorResize, 11>);
|
||||
DML_OP_DEFINE_CREATION_FUNCTION(Resize13, VersionedKernel<DmlOperatorResize, 13>);
|
||||
#if DML_TARGET_VERSION >= 0x6400
|
||||
DML_OP_DEFINE_CREATION_FUNCTION(Resize18, VersionedKernel<DmlOperatorResize, 18>);
|
||||
DML_OP_DEFINE_CREATION_FUNCTION(Resize19, VersionedKernel<DmlOperatorResize, 19>);
|
||||
#endif
|
||||
DML_OP_DEFINE_CREATION_FUNCTION(Upsample7, VersionedKernel<DmlOperatorResize, 7>);
|
||||
DML_OP_DEFINE_CREATION_FUNCTION(Upsample9, VersionedKernel<DmlOperatorResize, 9>);
|
||||
DML_OP_DEFINE_CREATION_FUNCTION(Upsample10, VersionedKernel<DmlOperatorResize, 10>);
|
||||
|
|
|
|||
|
|
@ -852,7 +852,7 @@ namespace OperatorHelper
|
|||
{
|
||||
ML_CHECK_VALID_ARGUMENT(outputShape[C] == gsl::narrow_cast<int>(m_outputShapes[0].GetShape()[C]),
|
||||
"Output channel must be equivalent to filter channel.");
|
||||
}
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < m_kernel.spatialDimensionCount; ++i)
|
||||
{
|
||||
|
|
@ -1857,14 +1857,13 @@ namespace OperatorHelper
|
|||
DowncastDimensions(gsl::span(shapeData), /*out*/ m_blockShape);
|
||||
|
||||
const uint32_t dimCount = gsl::narrow_cast<uint32_t>(m_blockShape.size());
|
||||
m_dilations = {dimCount, 1};
|
||||
m_pads = {dimCount * 2, 0};
|
||||
m_strides = {dimCount, 1};
|
||||
m_dilations.assign(dimCount, 1);
|
||||
m_pads.assign(dimCount, 0);
|
||||
m_strides.assign(dimCount, 1);
|
||||
|
||||
if (kernelInformation.HasAttribute(AttrName::Dilations, MLOperatorAttributeType::IntArray))
|
||||
{
|
||||
shapeData = kernelInformation.GetAttributes().GetOptionalAttributeVectorInt32(AttrName::Dilations);
|
||||
m_dilations.resize(shapeData.size());
|
||||
DowncastDimensions(gsl::span(shapeData), /*out*/ m_dilations);
|
||||
ML_CHECK_VALID_ARGUMENT(m_dilations.size() == dimCount);
|
||||
}
|
||||
|
|
@ -1872,7 +1871,6 @@ namespace OperatorHelper
|
|||
if (kernelInformation.HasAttribute(AttrName::Pads, MLOperatorAttributeType::IntArray))
|
||||
{
|
||||
shapeData = kernelInformation.GetAttributes().GetOptionalAttributeVectorInt32(AttrName::Pads);
|
||||
m_pads.resize(shapeData.size());
|
||||
DowncastDimensions(gsl::span(shapeData), /*out*/ m_pads);
|
||||
ML_CHECK_VALID_ARGUMENT(m_pads.size() == dimCount * 2);
|
||||
}
|
||||
|
|
@ -1880,7 +1878,6 @@ namespace OperatorHelper
|
|||
if (kernelInformation.HasAttribute(AttrName::Strides, MLOperatorAttributeType::IntArray))
|
||||
{
|
||||
shapeData = kernelInformation.GetAttributes().GetOptionalAttributeVectorInt32(AttrName::Strides);
|
||||
m_strides.resize(shapeData.size());
|
||||
DowncastDimensions(gsl::span(shapeData), /*out*/ m_strides);
|
||||
ML_CHECK_VALID_ARGUMENT(m_strides.size() == dimCount);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<packages>
|
||||
<package id="Microsoft.AI.DirectML" version="1.14.1" targetFramework="native" />
|
||||
<package id="Microsoft.AI.DirectML" version="1.15.0" targetFramework="native" />
|
||||
<package id="Microsoft.Windows.CppWinRT" version="2.0.201201.7" targetFramework="native" />
|
||||
<package id="google.protobuf.tools" version="3.21.12" targetFramework="native" />
|
||||
</packages>
|
||||
|
|
|
|||
|
|
@ -219,7 +219,7 @@ def add_common_dependencies(xml_text, package_name, version):
|
|||
|
||||
|
||||
def generate_dependencies(xml_text, package_name, version):
|
||||
dml_dependency = '<dependency id="Microsoft.AI.DirectML" version="1.14.1"/>'
|
||||
dml_dependency = '<dependency id="Microsoft.AI.DirectML" version="1.15.0"/>'
|
||||
|
||||
if package_name == "Microsoft.AI.MachineLearning":
|
||||
xml_text.append("<dependencies>")
|
||||
|
|
|
|||
Loading…
Reference in a new issue