Kilokem/Reinforced-Learning-Godot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

I am done

Browse Source
This commit is contained in:
Kilokem
2024-10-30 22:14:35 +01:00
parent 720dc28c09
commit 40e2a747cf
36901 changed files with 5011519 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

342
rl/Lib/site-packages/onnx/defs/logical/defs.cc Normal file
View File

@ -0,0 +1,342 @@
/*
* SPDX-License-Identifier: Apache-2.0
*/
#include "onnx/defs/function.h"
#include "onnx/defs/schema.h"
namespace ONNX_NAMESPACE {
inline void unaryLogicalOpInference(InferenceContext& ctx) {
// Type inference
updateOutputElemType(ctx, 0, TensorProto::BOOL);
// Shape inference
if (hasInputShape(ctx, 0)) {
propagateShapeFromInputToOutput(ctx, 0, 0);
}
}
std::function<void(OpSchema&)> BinaryLogicDocGenerator(const char* name) {
return [=](OpSchema& schema) {
std::string doc;
POPULATE_OP_DOC_STR(doc = R"DOC(
Returns the tensor resulted from performing the `{name}` logical operation
elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
{broadcast_doc}
)DOC";
ReplaceAll(doc, "{name}", name);
ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
schema.SetDoc(doc);
schema.Input(
0,
"A",
"First input operand for the logical operator.",
"T",
OpSchema::Single,
true,
1,
OpSchema::NonDifferentiable);
schema.Input(
1,
"B",
"Second input operand for the logical operator.",
"T",
OpSchema::Single,
true,
1,
OpSchema::NonDifferentiable);
schema.Output(0, "C", "Result tensor.", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable);
schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
// Type inference
updateOutputElemType(ctx, 0, TensorProto::BOOL);
// Shape inference
if (hasNInputShapes(ctx, 2))
bidirectionalBroadcastShapeInference(
ctx.getInputType(0)->tensor_type().shape(),
ctx.getInputType(1)->tensor_type().shape(),
*ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
});
};
}
ONNX_OPERATOR_SET_SCHEMA(
And,
7,
OpSchema()
.FillUsing(BinaryLogicDocGenerator("and"))
.TypeConstraint("T", {"tensor(bool)"}, "Constrain input to boolean tensor.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Or,
7,
OpSchema()
.FillUsing(BinaryLogicDocGenerator("or"))
.TypeConstraint("T", {"tensor(bool)"}, "Constrain input to boolean tensor.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Xor,
7,
OpSchema()
.FillUsing(BinaryLogicDocGenerator("xor"))
.TypeConstraint("T", {"tensor(bool)"}, "Constrain input to boolean tensor.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Greater,
13,
OpSchema()
.FillUsing(BinaryLogicDocGenerator("greater"))
.TypeConstraint("T", OpSchema::all_numeric_types_ir4(), "Constrain input types to all numeric tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Less,
13,
OpSchema()
.FillUsing(BinaryLogicDocGenerator("less"))
.TypeConstraint("T", OpSchema::all_numeric_types_ir4(), "Constrain input types to all numeric tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Equal,
19,
OpSchema()
.FillUsing(BinaryLogicDocGenerator("equal"))
.TypeConstraint(
"T",
{"tensor(bool)",
"tensor(uint8)",
"tensor(uint16)",
"tensor(uint32)",
"tensor(uint64)",
"tensor(int8)",
"tensor(int16)",
"tensor(int32)",
"tensor(int64)",
"tensor(float16)",
"tensor(float)",
"tensor(double)",
"tensor(bfloat16)",
"tensor(string)"},
"Constrain input types to all (non-complex) tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
static const char* Not_ver1_doc = R"DOC(
Returns the negation of the input tensor element-wise.
)DOC";
ONNX_OPERATOR_SET_SCHEMA(
Not,
1,
OpSchema()
.SetDoc(Not_ver1_doc)
.Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
.Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
.TypeConstraint("T", {"tensor(bool)"}, "Constrain input/output to boolean tensors.")
.TypeAndShapeInferenceFunction(unaryLogicalOpInference));
static const char* BitShift_ver11_doc = R"DOC(
Bitwise shift operator performs element-wise operation. For each input element, if the
attribute "direction" is "RIGHT", this operator moves its binary representation toward
the right side so that the input value is effectively decreased. If the attribute "direction"
is "LEFT", bits of binary representation moves toward the left side, which results the
increase of its actual value. The input X is the tensor to be shifted and another input
Y specifies the amounts of shifting. For example, if "direction" is "Right", X is [1, 4],
and S is [1, 1], the corresponding output Z would be [0, 2]. If "direction" is "LEFT" with
X=[1, 2] and S=[1, 2], the corresponding output Y would be [2, 8].
Because this operator supports Numpy-style broadcasting, X's and Y's shapes are
not necessarily identical.
)DOC";
ONNX_OPERATOR_SET_SCHEMA(
BitShift,
11,
OpSchema()
.SetDoc(GET_OP_DOC_STR(std::string(BitShift_ver11_doc) + GenerateBroadcastingDocMul()))
.Input(
0,
"X",
"First operand, input to be shifted.",
"T",
OpSchema::Single,
true,
1,
OpSchema::NonDifferentiable)
.Input(1, "Y", "Second operand, amounts of shift.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
.Output(0, "Z", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
.TypeConstraint(
"T",
{"tensor(uint8)", "tensor(uint16)", "tensor(uint32)", "tensor(uint64)"},
"Constrain input and output types to integer tensors.")
.Attr(
"direction",
"Direction of moving bits. It can be either \"RIGHT\" (for right shift) "
"or \"LEFT\" (for left shift).",
AttributeProto::STRING)
.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
// Type inference
propagateElemTypeFromInputToOutput(ctx, 0, 0);
// Shape inference
if (hasNInputShapes(ctx, 2))
bidirectionalBroadcastShapeInference(
ctx.getInputType(0)->tensor_type().shape(),
ctx.getInputType(1)->tensor_type().shape(),
*ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
}));
ONNX_OPERATOR_SET_SCHEMA(
LessOrEqual,
16,
OpSchema()
.FillUsing(BinaryLogicDocGenerator("less_equal"))
.TypeConstraint("T", OpSchema::all_numeric_types_ir4(), "Constrain input types to all numeric tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor.")
.TypeAndShapeInferenceFunction(InferenceFunction())
.FunctionBody(R"ONNX(
{
O1 = Less (A, B)
O2 = Equal (A, B)
C = Or (O1, O2)
}
)ONNX"));
ONNX_OPERATOR_SET_SCHEMA(
GreaterOrEqual,
16,
OpSchema()
.FillUsing(BinaryLogicDocGenerator("greater_equal"))
.TypeConstraint("T", OpSchema::all_numeric_types_ir4(), "Constrain input types to all numeric tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor.")
.TypeAndShapeInferenceFunction(InferenceFunction())
.FunctionBody(R"ONNX(
{
O1 = Greater (A, B)
O2 = Equal (A, B)
C = Or (O1, O2)
}
)ONNX"));
static const char* BitwiseNot_ver18_doc = R"DOC(
Returns the bitwise not of the input tensor element-wise.
)DOC";
ONNX_OPERATOR_SET_SCHEMA(
BitwiseNot,
18,
OpSchema()
.SetDoc(BitwiseNot_ver18_doc)
.Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
.Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
.TypeConstraint(
"T",
{"tensor(uint8)",
"tensor(uint16)",
"tensor(uint32)",
"tensor(uint64)",
"tensor(int8)",
"tensor(int16)",
"tensor(int32)",
"tensor(int64)"},
"Constrain input/output to integer tensors.")
.TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
std::function<void(OpSchema&)> BinaryBitwiseDocGenerator(const char* name) {
return [=](OpSchema& schema) {
std::string doc;
POPULATE_OP_DOC_STR(doc = R"DOC(
Returns the tensor resulting from performing the bitwise `{name}` operation
elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
{broadcast_doc}
)DOC";
ReplaceAll(doc, "{name}", name);
ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
schema.SetDoc(doc);
schema.Input(
0,
"A",
"First input operand for the bitwise operator.",
"T",
OpSchema::Single,
true,
1,
OpSchema::NonDifferentiable);
schema.Input(
1,
"B",
"Second input operand for the bitwise operator.",
"T",
OpSchema::Single,
true,
1,
OpSchema::NonDifferentiable);
schema.Output(0, "C", "Result tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable);
schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
// Type inference
propagateElemTypeFromInputToOutput(ctx, 0, 0);
// Shape inference
if (hasNInputShapes(ctx, 2))
bidirectionalBroadcastShapeInference(
ctx.getInputType(0)->tensor_type().shape(),
ctx.getInputType(1)->tensor_type().shape(),
*ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
});
};
}
ONNX_OPERATOR_SET_SCHEMA(
BitwiseAnd,
18,
OpSchema()
.FillUsing(BinaryBitwiseDocGenerator("and"))
.TypeConstraint(
"T",
{"tensor(uint8)",
"tensor(uint16)",
"tensor(uint32)",
"tensor(uint64)",
"tensor(int8)",
"tensor(int16)",
"tensor(int32)",
"tensor(int64)"},
"Constrain input to integer tensors."));
ONNX_OPERATOR_SET_SCHEMA(
BitwiseOr,
18,
OpSchema()
.FillUsing(BinaryBitwiseDocGenerator("or"))
.TypeConstraint(
"T",
{"tensor(uint8)",
"tensor(uint16)",
"tensor(uint32)",
"tensor(uint64)",
"tensor(int8)",
"tensor(int16)",
"tensor(int32)",
"tensor(int64)"},
"Constrain input to integer tensors."));
ONNX_OPERATOR_SET_SCHEMA(
BitwiseXor,
18,
OpSchema()
.FillUsing(BinaryBitwiseDocGenerator("xor"))
.TypeConstraint(
"T",
{"tensor(uint8)",
"tensor(uint16)",
"tensor(uint32)",
"tensor(uint64)",
"tensor(int8)",
"tensor(int16)",
"tensor(int32)",
"tensor(int64)"},
"Constrain input to integer tensors."));
} // namespace ONNX_NAMESPACE

274
rl/Lib/site-packages/onnx/defs/logical/old.cc Normal file
View File

@ -0,0 +1,274 @@
/*
* SPDX-License-Identifier: Apache-2.0
*/
#include "onnx/defs/schema.h"
using namespace ONNX_NAMESPACE;
namespace ONNX_NAMESPACE {
std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset12(const char* name) {
return [=](OpSchema& schema) {
std::string doc;
POPULATE_OP_DOC_STR(doc = R"DOC(
Returns the tensor resulted from performing the `{name}` logical operation
elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
{broadcast_doc}
)DOC";
ReplaceAll(doc, "{name}", name);
ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
schema.SetDoc(doc);
schema.Input(0, "A", "First input operand for the logical operator.", "T");
schema.Input(1, "B", "Second input operand for the logical operator.", "T");
schema.Output(0, "C", "Result tensor.", "T1");
schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
// Type inference
updateOutputElemType(ctx, 0, TensorProto::BOOL);
// Shape inference
if (hasNInputShapes(ctx, 2))
bidirectionalBroadcastShapeInference(
ctx.getInputType(0)->tensor_type().shape(),
ctx.getInputType(1)->tensor_type().shape(),
*ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
});
};
}
ONNX_OPERATOR_SET_SCHEMA(
Greater,
9,
OpSchema()
.FillUsing(BinaryLogicDocGenerator_opset12("greater"))
.TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input types to all numeric tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Less,
9,
OpSchema()
.FillUsing(BinaryLogicDocGenerator_opset12("less"))
.TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input types to all numeric tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Equal,
11,
OpSchema()
.FillUsing(BinaryLogicDocGenerator_opset12("equal"))
.TypeConstraint(
"T",
{"tensor(bool)",
"tensor(uint8)",
"tensor(uint16)",
"tensor(uint32)",
"tensor(uint64)",
"tensor(int8)",
"tensor(int16)",
"tensor(int32)",
"tensor(int64)",
"tensor(float16)",
"tensor(float)",
"tensor(double)"},
"Constrain input types to all numeric tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
inline void logicalOpInference_opset1(InferenceContext& ctx) {
updateOutputElemType(ctx, 0, TensorProto::BOOL);
if (hasInputShape(ctx, 0)) {
propagateShapeFromInputToOutput(ctx, 0, 0);
}
}
std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset1(const char* name) {
return [=](OpSchema& schema) {
std::string doc;
POPULATE_OP_DOC_STR(doc = R"DOC(
Returns the tensor resulted from performing the `{name}` logical operation
elementwise on the input tensors `A` and `B`.
If broadcasting is enabled, the right-hand-side argument will be broadcasted
to match the shape of left-hand-side argument. See the doc of `Add` for a
detailed description of the broadcasting rules.
)DOC";
ReplaceAll(doc, "{name}", name););
schema.SetDoc(doc);
schema.Attr("broadcast", "Enable broadcasting", AttributeProto::INT, static_cast<int64_t>(0));
schema.Attr("axis", "If set, defines the broadcast dimensions.", AttributeProto::INT, OPTIONAL_VALUE);
schema.Input(0, "A", "Left input tensor for the logical operator.", "T");
schema.Input(1, "B", "Right input tensor for the logical operator.", "T");
schema.Output(0, "C", "Result tensor.", "T1");
schema.TypeAndShapeInferenceFunction(logicalOpInference_opset1);
};
}
std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset7(const char* name) {
return [=](OpSchema& schema) {
std::string doc;
POPULATE_OP_DOC_STR(doc = R"DOC(
Returns the tensor resulted from performing the `{name}` logical operation
elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
{broadcast_doc}
)DOC";
ReplaceAll(doc, "{name}", name);
ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
schema.SetDoc(doc);
schema.Input(0, "A", "First input operand for the logical operator.", "T");
schema.Input(1, "B", "Second input operand for the logical operator.", "T");
schema.Output(0, "C", "Result tensor.", "T1");
schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
updateOutputElemType(ctx, 0, TensorProto::BOOL);
if (hasNInputShapes(ctx, 2))
bidirectionalBroadcastShapeInference(
ctx.getInputType(0)->tensor_type().shape(),
ctx.getInputType(1)->tensor_type().shape(),
*ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
});
};
}
ONNX_OPERATOR_SET_SCHEMA(
And,
1,
OpSchema()
.FillUsing(BinaryLogicDocGenerator_opset1("and"))
.TypeConstraint("T", {"tensor(bool)"}, "Constrain input to boolean tensor.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Or,
1,
OpSchema()
.FillUsing(BinaryLogicDocGenerator_opset1("or"))
.TypeConstraint("T", {"tensor(bool)"}, "Constrain input to boolean tensor.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Xor,
1,
OpSchema()
.FillUsing(BinaryLogicDocGenerator_opset1("xor"))
.TypeConstraint("T", {"tensor(bool)"}, "Constrain input to boolean tensor.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Greater,
1,
OpSchema()
.FillUsing(BinaryLogicDocGenerator_opset1("greater"))
.TypeConstraint(
"T",
{"tensor(float16)", "tensor(float)", "tensor(double)"},
"Constrain input to float tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Less,
1,
OpSchema()
.FillUsing(BinaryLogicDocGenerator_opset1("less"))
.TypeConstraint(
"T",
{"tensor(float16)", "tensor(float)", "tensor(double)"},
"Constrain input to float tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Equal,
1,
OpSchema()
.FillUsing(BinaryLogicDocGenerator_opset1("equal"))
.TypeConstraint("T", {"tensor(bool)", "tensor(int32)", "tensor(int64)"}, "Constrain input to integral tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Equal,
7,
OpSchema()
.FillUsing(BinaryLogicDocGenerator_opset7("equal"))
.TypeConstraint("T", {"tensor(bool)", "tensor(int32)", "tensor(int64)"}, "Constrain input to integral tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Greater,
7,
OpSchema()
.FillUsing(BinaryLogicDocGenerator_opset7("greater"))
.TypeConstraint(
"T",
{"tensor(float16)", "tensor(float)", "tensor(double)"},
"Constrain input to float tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
ONNX_OPERATOR_SET_SCHEMA(
Less,
7,
OpSchema()
.FillUsing(BinaryLogicDocGenerator_opset7("less"))
.TypeConstraint(
"T",
{"tensor(float16)", "tensor(float)", "tensor(double)"},
"Constrain input to float tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
// Shares same doc generator as newer opset 16 version.
extern std::function<void(OpSchema&)> BinaryLogicDocGenerator(const char* name);
ONNX_OPERATOR_SET_SCHEMA(
LessOrEqual,
12,
OpSchema()
.FillUsing(BinaryLogicDocGenerator("less_equal"))
.TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input types to all numeric tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor.")
.TypeAndShapeInferenceFunction(InferenceFunction())
.FunctionBody(R"ONNX(
{
O1 = Less (A, B)
O2 = Equal (A, B)
C = Or (O1, O2)
}
)ONNX"));
ONNX_OPERATOR_SET_SCHEMA(
GreaterOrEqual,
12,
OpSchema()
.FillUsing(BinaryLogicDocGenerator("greater_equal"))
.TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input types to all numeric tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor.")
.TypeAndShapeInferenceFunction(InferenceFunction())
.FunctionBody(R"ONNX(
{
O1 = Greater (A, B)
O2 = Equal (A, B)
C = Or (O1, O2)
}
)ONNX"));
ONNX_OPERATOR_SET_SCHEMA(
Equal,
13,
OpSchema()
.FillUsing(BinaryLogicDocGenerator("equal"))
.TypeConstraint(
"T",
{"tensor(bool)",
"tensor(uint8)",
"tensor(uint16)",
"tensor(uint32)",
"tensor(uint64)",
"tensor(int8)",
"tensor(int16)",
"tensor(int32)",
"tensor(int64)",
"tensor(float16)",
"tensor(float)",
"tensor(double)",
"tensor(bfloat16)"},
"Constrain input types to all numeric tensors.")
.TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
} // namespace ONNX_NAMESPACE