diff --git a/GraphLayout/GraphLayout.sln b/GraphLayout/GraphLayout.sln index 21492b07..356cc373 100644 --- a/GraphLayout/GraphLayout.sln +++ b/GraphLayout/GraphLayout.sln @@ -110,7 +110,13 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DrawingFromGeometryWithGtk" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EdgeDirectionTest", "Samples\EdgeDirectionTest\EdgeDirectionTest.csproj", "{02EAF869-FB5A-40BD-AD78-92E193946B5D}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBB}") = "FormForGViewer", "tools\FormForGViewer\FormForGViewer.csproj", "{AF9121C3-E4B7-464F-8EBB-96C9CF627C07}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FormForGViewer", "tools\FormForGViewer\FormForGViewer.csproj", "{AF9121C3-E4B7-464F-8EBB-96C9CF627C07}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WpfApplicationSample_OnnxViewer", "Samples\WpfApplicationSample_OnnxViewer\WpfApplicationSample_OnnxViewer.csproj", "{79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}" + ProjectSection(ProjectDependencies) = postProject + {415D3E3F-7105-46C1-84D2-7ECB34213D92} = {415D3E3F-7105-46C1-84D2-7ECB34213D92} + {B76F8F71-4B00-4242-BE36-C9F0732511F7} = {B76F8F71-4B00-4242-BE36-C9F0732511F7} + EndProjectSection EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -1066,6 +1072,26 @@ Global {AF9121C3-E4B7-464F-8EBB-96C9CF627C07}.Release|x64.Build.0 = Release|x64 {AF9121C3-E4B7-464F-8EBB-96C9CF627C07}.Release|x86.ActiveCfg = Release|x86 {AF9121C3-E4B7-464F-8EBB-96C9CF627C07}.Release|x86.Build.0 = Release|x86 + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Debug|ARM.ActiveCfg = Debug|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Debug|ARM.Build.0 = Debug|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Debug|ARM64.ActiveCfg = Debug|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Debug|ARM64.Build.0 = Debug|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Debug|x64.ActiveCfg = Debug|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Debug|x64.Build.0 = Debug|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Debug|x86.ActiveCfg = Debug|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Debug|x86.Build.0 = Debug|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Release|Any CPU.Build.0 = Release|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Release|ARM.ActiveCfg = Release|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Release|ARM.Build.0 = Release|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Release|ARM64.ActiveCfg = Release|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Release|ARM64.Build.0 = Release|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Release|x64.ActiveCfg = Release|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Release|x64.Build.0 = Release|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Release|x86.ActiveCfg = Release|Any CPU + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -1116,6 +1142,7 @@ Global {AA8D2135-1BD2-47DD-9DC9-2FC266711536} = {CAAD5476-353C-41F5-A6E7-88BA0C97C2C9} {02EAF869-FB5A-40BD-AD78-92E193946B5D} = {CAAD5476-353C-41F5-A6E7-88BA0C97C2C9} {AF9121C3-E4B7-464F-8EBB-96C9CF627C07} = {9E51C177-3DF6-474E-AC7A-ED036ED32F05} + {79FB22C1-EACD-4808-AEBB-B0D3A6C5F46F} = {CAAD5476-353C-41F5-A6E7-88BA0C97C2C9} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {0D81D757-911D-4F8B-A4B3-4C4F1CBD5B60} diff --git a/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/App.xaml b/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/App.xaml new file mode 100644 index 00000000..4620b72a --- /dev/null +++ b/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/App.xaml @@ -0,0 +1,9 @@ + + + + + diff --git a/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/App.xaml.cs b/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/App.xaml.cs new file mode 100644 index 00000000..d5860de9 --- /dev/null +++ b/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/App.xaml.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Configuration; +using System.Data; +using System.Linq; +using System.Threading.Tasks; +using System.Windows; + +namespace WpfApplicationSample_OnnxViewer { + /// + /// Interaction logic for App.xaml + /// + public partial class App : Application { + } +} diff --git a/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/AssemblyInfo.cs b/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/AssemblyInfo.cs new file mode 100644 index 00000000..8b5504ec --- /dev/null +++ b/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/AssemblyInfo.cs @@ -0,0 +1,10 @@ +using System.Windows; + +[assembly: ThemeInfo( + ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located + //(used if a resource is not found in the page, + // or application resource dictionaries) + ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located + //(used if a resource is not found in the page, + // app, or any theme specific resource dictionaries) +)] diff --git a/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/MainWindow.xaml b/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/MainWindow.xaml new file mode 100644 index 00000000..fb06198d --- /dev/null +++ b/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/MainWindow.xaml @@ -0,0 +1,10 @@ + + + diff --git a/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/MainWindow.xaml.cs b/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/MainWindow.xaml.cs new file mode 100644 index 00000000..21ed0b99 --- /dev/null +++ b/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/MainWindow.xaml.cs @@ -0,0 +1,162 @@ +using System; +using System.IO; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Data; +using System.Windows.Documents; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Imaging; +using System.Windows.Navigation; +using System.Windows.Shapes; +using Microsoft.Win32; +using Microsoft.Msagl.Drawing; +using Microsoft.Msagl.Layout.Layered; +using Microsoft.Msagl.WpfGraphControl; +using Microsoft.Msagl.Core.DataStructures; +using Color = Microsoft.Msagl.Drawing.Color; +using Onnx; +using Microsoft.Msagl.Core.Geometry.Curves; + +namespace WpfApplicationSample_OnnxViewer { + /// + /// Interaction logic for MainWindow.xaml + /// + public partial class MainWindow : Window { + + DockPanel graphViewerPanel = new DockPanel(); + GraphViewer graphViewer = new GraphViewer(); + int downX; + int downY; + PlaneTransformation downTransform; + + public MainWindow() { + InitializeComponent(); + + mainGrid.Children.Add(graphViewerPanel); + graphViewerPanel.Focusable = true; + graphViewerPanel.KeyDown += Graph_KeyDown; + graphViewerPanel.Focus(); + graphViewer.BindToPanel(graphViewerPanel); + graphViewer.MouseDown += MouseDown; + graphViewer.MouseMove += MouseMove; + } + + void Grid_DragOver(object sender, DragEventArgs e) { + e.Effects = e.Data.GetDataPresent(DataFormats.FileDrop) ? DragDropEffects.All : DragDropEffects.None; + e.Handled = true; + } + + void Grid_Drop(object sender, DragEventArgs e) { + if (e.Data.GetDataPresent(DataFormats.FileDrop)) { + var fileNames = (string[])e.Data.GetData(DataFormats.FileDrop); + LoadOnnxFile(fileNames[0]); + } + } + + private void Graph_KeyDown(object sender, KeyEventArgs e) { + double dx = 0; + double dy = 0; + if (Keyboard.IsKeyDown(Key.W)) dy += 10; + if (Keyboard.IsKeyDown(Key.A)) dx -= 10; + if (Keyboard.IsKeyDown(Key.S)) dy -= 10; + if (Keyboard.IsKeyDown(Key.D)) dx += 10; + var scale = graphViewer.CurrentScale; + dx /= scale; + dy /= scale; + var translate = new PlaneTransformation(1, 0, dx, 0, 1, dy); + graphViewer.Transform *= translate; + } + + void MouseDown(object sender, MsaglMouseEventArgs e) { + this.downX = e.X; + this.downY = e.Y; + this.downTransform = graphViewer.Transform; + graphViewer.GraphCanvas.CaptureMouse(); + } + + void MouseMove(object sender, MsaglMouseEventArgs e) { + if (!e.LeftButtonIsPressed || this.downTransform == null) + return; + var scale = graphViewer.CurrentScale; + var dx = (e.X - this.downX) / scale; + var dy = (this.downY - e.Y) / scale; + var translate = new PlaneTransformation(1, 0, dx, 0, 1, dy); + graphViewer.Transform = this.downTransform * translate; + } + + void LoadOnnxFile(string filePath) { + try + { + var model = ModelProto.Parser.ParseFrom(File.ReadAllBytes(filePath)); + var modelGraph = model.Graph; + Graph graph = new Graph("graph"); + graph.LayerConstraints.RemoveAllConstraints(); + SugiyamaLayoutSettings layoutSettings = (SugiyamaLayoutSettings)graph.LayoutAlgorithmSettings; + var inputs = new Dictionary>(); + var outputs = new Dictionary>(); + var nodes = new Set(); + var initializers = new Set(); + foreach(var initializer in modelGraph.Initializer) { + initializers.Insert(initializer.Name); + } + var limit = 3000; + var cnt = 0; + foreach(var node in modelGraph.Node) { + var gNode = new Node(node.Name); + gNode.LabelText = node.OpType.ToString(); + graph.AddNode(gNode); + nodes.Insert(node.Name); + foreach(var input in node.Input) { + if(!inputs.ContainsKey(input)) { + inputs.Add(input, new List()); + } + inputs[input].Add(node.Name); + } + foreach(var output in node.Output) { + if(!outputs.ContainsKey(output)) { + outputs.Add(output, new List()); + } + outputs[output].Add(node.Name); + } + if(++cnt > limit) + break; + } + cnt = 0; + foreach(var node in modelGraph.Node) { + foreach(var output in node.Output) { + if(!inputs.ContainsKey(output)) { + if(nodes.Contains(output)) { + graph.AddNode(output); + graph.AddEdge(node.Name, output); + } + } + else { + var inputs2 = inputs[output]; + inputs2.Reverse(); + foreach(var input in inputs2) { + if(nodes.Contains(input)) { + graph.AddEdge(node.Name, input); + } + } + } + } + if(++cnt > limit) + break; + } + graph.Attr.BackgroundColor = Color.Transparent; + graphViewer.Graph = graph; + this.Title = filePath + " - WpfApplicationSample OnnxViewer"; + } + catch (Exception e) + { + MessageBox.Show(e.ToString(), "Load Failed", MessageBoxButton.OK, MessageBoxImage.Error); + } + } + + } +} diff --git a/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/Onnx.cs b/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/Onnx.cs new file mode 100644 index 00000000..44432748 --- /dev/null +++ b/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/Onnx.cs @@ -0,0 +1,7902 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: onnx.proto3 +// +#pragma warning disable 1591, 0612, 3021, 8981 +#region Designer generated code + +using pb = global::Google.Protobuf; +using pbc = global::Google.Protobuf.Collections; +using pbr = global::Google.Protobuf.Reflection; +using scg = global::System.Collections.Generic; +namespace Onnx { + + /// Holder for reflection information generated from onnx.proto3 + public static partial class OnnxReflection { + + #region Descriptor + /// File descriptor for onnx.proto3 + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static OnnxReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "Cgtvbm54LnByb3RvMxIEb25ueCLMBQoOQXR0cmlidXRlUHJvdG8SDAoEbmFt", + "ZRgBIAEoCRIVCg1yZWZfYXR0cl9uYW1lGBUgASgJEhIKCmRvY19zdHJpbmcY", + "DSABKAkSMAoEdHlwZRgUIAEoDjIiLm9ubnguQXR0cmlidXRlUHJvdG8uQXR0", + "cmlidXRlVHlwZRIJCgFmGAIgASgCEgkKAWkYAyABKAMSCQoBcxgEIAEoDBIc", + "CgF0GAUgASgLMhEub25ueC5UZW5zb3JQcm90bxIbCgFnGAYgASgLMhAub25u", + "eC5HcmFwaFByb3RvEi4KDXNwYXJzZV90ZW5zb3IYFiABKAsyFy5vbm54LlNw", + "YXJzZVRlbnNvclByb3RvEhsKAnRwGA4gASgLMg8ub25ueC5UeXBlUHJvdG8S", + "DgoGZmxvYXRzGAcgAygCEgwKBGludHMYCCADKAMSDwoHc3RyaW5ncxgJIAMo", + "DBIiCgd0ZW5zb3JzGAogAygLMhEub25ueC5UZW5zb3JQcm90bxIgCgZncmFw", + "aHMYCyADKAsyEC5vbm54LkdyYXBoUHJvdG8SLwoOc3BhcnNlX3RlbnNvcnMY", + "FyADKAsyFy5vbm54LlNwYXJzZVRlbnNvclByb3RvEiQKC3R5cGVfcHJvdG9z", + "GA8gAygLMg8ub25ueC5UeXBlUHJvdG8i2QEKDUF0dHJpYnV0ZVR5cGUSDQoJ", + "VU5ERUZJTkVEEAASCQoFRkxPQVQQARIHCgNJTlQQAhIKCgZTVFJJTkcQAxIK", + "CgZURU5TT1IQBBIJCgVHUkFQSBAFEhEKDVNQQVJTRV9URU5TT1IQCxIOCgpU", + "WVBFX1BST1RPEA0SCgoGRkxPQVRTEAYSCAoESU5UUxAHEgsKB1NUUklOR1MQ", + "CBILCgdURU5TT1JTEAkSCgoGR1JBUEhTEAoSEgoOU1BBUlNFX1RFTlNPUlMQ", + "DBIPCgtUWVBFX1BST1RPUxAOIlEKDlZhbHVlSW5mb1Byb3RvEgwKBG5hbWUY", + "ASABKAkSHQoEdHlwZRgCIAEoCzIPLm9ubnguVHlwZVByb3RvEhIKCmRvY19z", + "dHJpbmcYAyABKAkilgEKCU5vZGVQcm90bxINCgVpbnB1dBgBIAMoCRIOCgZv", + "dXRwdXQYAiADKAkSDAoEbmFtZRgDIAEoCRIPCgdvcF90eXBlGAQgASgJEg4K", + "BmRvbWFpbhgHIAEoCRInCglhdHRyaWJ1dGUYBSADKAsyFC5vbm54LkF0dHJp", + "YnV0ZVByb3RvEhIKCmRvY19zdHJpbmcYBiABKAki1gEKEVRyYWluaW5nSW5m", + "b1Byb3RvEigKDmluaXRpYWxpemF0aW9uGAEgASgLMhAub25ueC5HcmFwaFBy", + "b3RvEiMKCWFsZ29yaXRobRgCIAEoCzIQLm9ubnguR3JhcGhQcm90bxI8ChZp", + "bml0aWFsaXphdGlvbl9iaW5kaW5nGAMgAygLMhwub25ueC5TdHJpbmdTdHJp", + "bmdFbnRyeVByb3RvEjQKDnVwZGF0ZV9iaW5kaW5nGAQgAygLMhwub25ueC5T", + "dHJpbmdTdHJpbmdFbnRyeVByb3RvIusCCgpNb2RlbFByb3RvEhIKCmlyX3Zl", + "cnNpb24YASABKAMSLgoMb3BzZXRfaW1wb3J0GAggAygLMhgub25ueC5PcGVy", + "YXRvclNldElkUHJvdG8SFQoNcHJvZHVjZXJfbmFtZRgCIAEoCRIYChBwcm9k", + "dWNlcl92ZXJzaW9uGAMgASgJEg4KBmRvbWFpbhgEIAEoCRIVCg1tb2RlbF92", + "ZXJzaW9uGAUgASgDEhIKCmRvY19zdHJpbmcYBiABKAkSHwoFZ3JhcGgYByAB", + "KAsyEC5vbm54LkdyYXBoUHJvdG8SNAoObWV0YWRhdGFfcHJvcHMYDiADKAsy", + "HC5vbm54LlN0cmluZ1N0cmluZ0VudHJ5UHJvdG8SLgoNdHJhaW5pbmdfaW5m", + "bxgUIAMoCzIXLm9ubnguVHJhaW5pbmdJbmZvUHJvdG8SJgoJZnVuY3Rpb25z", + "GBkgAygLMhMub25ueC5GdW5jdGlvblByb3RvIjQKFlN0cmluZ1N0cmluZ0Vu", + "dHJ5UHJvdG8SCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJImsKEFRlbnNv", + "ckFubm90YXRpb24SEwoLdGVuc29yX25hbWUYASABKAkSQgoccXVhbnRfcGFy", + "YW1ldGVyX3RlbnNvcl9uYW1lcxgCIAMoCzIcLm9ubnguU3RyaW5nU3RyaW5n", + "RW50cnlQcm90byKeAwoKR3JhcGhQcm90bxIdCgRub2RlGAEgAygLMg8ub25u", + "eC5Ob2RlUHJvdG8SDAoEbmFtZRgCIAEoCRImCgtpbml0aWFsaXplchgFIAMo", + "CzIRLm9ubnguVGVuc29yUHJvdG8SMwoSc3BhcnNlX2luaXRpYWxpemVyGA8g", + "AygLMhcub25ueC5TcGFyc2VUZW5zb3JQcm90bxISCgpkb2Nfc3RyaW5nGAog", + "ASgJEiMKBWlucHV0GAsgAygLMhQub25ueC5WYWx1ZUluZm9Qcm90bxIkCgZv", + "dXRwdXQYDCADKAsyFC5vbm54LlZhbHVlSW5mb1Byb3RvEigKCnZhbHVlX2lu", + "Zm8YDSADKAsyFC5vbm54LlZhbHVlSW5mb1Byb3RvEjcKF3F1YW50aXphdGlv", + "bl9hbm5vdGF0aW9uGA4gAygLMhYub25ueC5UZW5zb3JBbm5vdGF0aW9uSgQI", + "AxAESgQIBBAFSgQIBhAKUgppcl92ZXJzaW9uUhBwcm9kdWNlcl92ZXJzaW9u", + "Ugxwcm9kdWNlcl90YWdSBmRvbWFpbiKCBgoLVGVuc29yUHJvdG8SDAoEZGlt", + "cxgBIAMoAxIRCglkYXRhX3R5cGUYAiABKAUSKgoHc2VnbWVudBgDIAEoCzIZ", + "Lm9ubnguVGVuc29yUHJvdG8uU2VnbWVudBIWCgpmbG9hdF9kYXRhGAQgAygC", + "QgIQARIWCgppbnQzMl9kYXRhGAUgAygFQgIQARITCgtzdHJpbmdfZGF0YRgG", + "IAMoDBIWCgppbnQ2NF9kYXRhGAcgAygDQgIQARIMCgRuYW1lGAggASgJEhIK", + "CmRvY19zdHJpbmcYDCABKAkSEAoIcmF3X2RhdGEYCSABKAwSMwoNZXh0ZXJu", + "YWxfZGF0YRgNIAMoCzIcLm9ubnguU3RyaW5nU3RyaW5nRW50cnlQcm90bxI1", + "Cg1kYXRhX2xvY2F0aW9uGA4gASgOMh4ub25ueC5UZW5zb3JQcm90by5EYXRh", + "TG9jYXRpb24SFwoLZG91YmxlX2RhdGEYCiADKAFCAhABEhcKC3VpbnQ2NF9k", + "YXRhGAsgAygEQgIQARolCgdTZWdtZW50Eg0KBWJlZ2luGAEgASgDEgsKA2Vu", + "ZBgCIAEoAyKkAgoIRGF0YVR5cGUSDQoJVU5ERUZJTkVEEAASCQoFRkxPQVQQ", + "ARIJCgVVSU5UOBACEggKBElOVDgQAxIKCgZVSU5UMTYQBBIJCgVJTlQxNhAF", + "EgkKBUlOVDMyEAYSCQoFSU5UNjQQBxIKCgZTVFJJTkcQCBIICgRCT09MEAkS", + "CwoHRkxPQVQxNhAKEgoKBkRPVUJMRRALEgoKBlVJTlQzMhAMEgoKBlVJTlQ2", + "NBANEg0KCUNPTVBMRVg2NBAOEg4KCkNPTVBMRVgxMjgQDxIMCghCRkxPQVQx", + "NhAQEhAKDEZMT0FUOEU0TTNGThAREhIKDkZMT0FUOEU0TTNGTlVaEBISDgoK", + "RkxPQVQ4RTVNMhATEhIKDkZMT0FUOEU1TTJGTlVaEBQiKQoMRGF0YUxvY2F0", + "aW9uEgsKB0RFRkFVTFQQABIMCghFWFRFUk5BTBABImgKEVNwYXJzZVRlbnNv", + "clByb3RvEiEKBnZhbHVlcxgBIAEoCzIRLm9ubnguVGVuc29yUHJvdG8SIgoH", + "aW5kaWNlcxgCIAEoCzIRLm9ubnguVGVuc29yUHJvdG8SDAoEZGltcxgDIAMo", + "AyKVAQoQVGVuc29yU2hhcGVQcm90bxItCgNkaW0YASADKAsyIC5vbm54LlRl", + "bnNvclNoYXBlUHJvdG8uRGltZW5zaW9uGlIKCURpbWVuc2lvbhITCglkaW1f", + "dmFsdWUYASABKANIABITCglkaW1fcGFyYW0YAiABKAlIABISCgpkZW5vdGF0", + "aW9uGAMgASgJQgcKBXZhbHVlIs4ECglUeXBlUHJvdG8SLQoLdGVuc29yX3R5", + "cGUYASABKAsyFi5vbm54LlR5cGVQcm90by5UZW5zb3JIABIxCg1zZXF1ZW5j", + "ZV90eXBlGAQgASgLMhgub25ueC5UeXBlUHJvdG8uU2VxdWVuY2VIABInCght", + "YXBfdHlwZRgFIAEoCzITLm9ubnguVHlwZVByb3RvLk1hcEgAEjEKDW9wdGlv", + "bmFsX3R5cGUYCSABKAsyGC5vbm54LlR5cGVQcm90by5PcHRpb25hbEgAEjoK", + "EnNwYXJzZV90ZW5zb3JfdHlwZRgIIAEoCzIcLm9ubnguVHlwZVByb3RvLlNw", + "YXJzZVRlbnNvckgAEhIKCmRlbm90YXRpb24YBiABKAkaQgoGVGVuc29yEhEK", + "CWVsZW1fdHlwZRgBIAEoBRIlCgVzaGFwZRgCIAEoCzIWLm9ubnguVGVuc29y", + "U2hhcGVQcm90bxouCghTZXF1ZW5jZRIiCgllbGVtX3R5cGUYASABKAsyDy5v", + "bm54LlR5cGVQcm90bxo8CgNNYXASEAoIa2V5X3R5cGUYASABKAUSIwoKdmFs", + "dWVfdHlwZRgCIAEoCzIPLm9ubnguVHlwZVByb3RvGi4KCE9wdGlvbmFsEiIK", + "CWVsZW1fdHlwZRgBIAEoCzIPLm9ubnguVHlwZVByb3RvGkgKDFNwYXJzZVRl", + "bnNvchIRCgllbGVtX3R5cGUYASABKAUSJQoFc2hhcGUYAiABKAsyFi5vbm54", + "LlRlbnNvclNoYXBlUHJvdG9CBwoFdmFsdWUiNQoST3BlcmF0b3JTZXRJZFBy", + "b3RvEg4KBmRvbWFpbhgBIAEoCRIPCgd2ZXJzaW9uGAIgASgDIpQCCg1GdW5j", + "dGlvblByb3RvEgwKBG5hbWUYASABKAkSDQoFaW5wdXQYBCADKAkSDgoGb3V0", + "cHV0GAUgAygJEhEKCWF0dHJpYnV0ZRgGIAMoCRItCg9hdHRyaWJ1dGVfcHJv", + "dG8YCyADKAsyFC5vbm54LkF0dHJpYnV0ZVByb3RvEh0KBG5vZGUYByADKAsy", + "Dy5vbm54Lk5vZGVQcm90bxISCgpkb2Nfc3RyaW5nGAggASgJEi4KDG9wc2V0", + "X2ltcG9ydBgJIAMoCzIYLm9ubnguT3BlcmF0b3JTZXRJZFByb3RvEg4KBmRv", + "bWFpbhgKIAEoCUoECAIQA0oECAMQBFINc2luY2VfdmVyc2lvblIGc3RhdHVz", + "Kv4BCgdWZXJzaW9uEhIKDl9TVEFSVF9WRVJTSU9OEAASGQoVSVJfVkVSU0lP", + "Tl8yMDE3XzEwXzEwEAESGQoVSVJfVkVSU0lPTl8yMDE3XzEwXzMwEAISGAoU", + "SVJfVkVSU0lPTl8yMDE3XzExXzMQAxIYChRJUl9WRVJTSU9OXzIwMTlfMV8y", + "MhAEEhgKFElSX1ZFUlNJT05fMjAxOV8zXzE4EAUSGAoUSVJfVkVSU0lPTl8y", + "MDE5XzlfMTkQBhIXChNJUl9WRVJTSU9OXzIwMjBfNV84EAcSGAoUSVJfVkVS", + "U0lPTl8yMDIxXzdfMzAQCBIOCgpJUl9WRVJTSU9OEAkqLgoOT3BlcmF0b3JT", + "dGF0dXMSEAoMRVhQRVJJTUVOVEFMEAASCgoGU1RBQkxFEAFCAkgDYgZwcm90", + "bzM=")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { }, + new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Onnx.Version), typeof(global::Onnx.OperatorStatus), }, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.AttributeProto), global::Onnx.AttributeProto.Parser, new[]{ "Name", "RefAttrName", "DocString", "Type", "F", "I", "S", "T", "G", "SparseTensor", "Tp", "Floats", "Ints", "Strings", "Tensors", "Graphs", "SparseTensors", "TypeProtos" }, null, new[]{ typeof(global::Onnx.AttributeProto.Types.AttributeType) }, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.ValueInfoProto), global::Onnx.ValueInfoProto.Parser, new[]{ "Name", "Type", "DocString" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.NodeProto), global::Onnx.NodeProto.Parser, new[]{ "Input", "Output", "Name", "OpType", "Domain", "Attribute", "DocString" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.TrainingInfoProto), global::Onnx.TrainingInfoProto.Parser, new[]{ "Initialization", "Algorithm", "InitializationBinding", "UpdateBinding" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.ModelProto), global::Onnx.ModelProto.Parser, new[]{ "IrVersion", "OpsetImport", "ProducerName", "ProducerVersion", "Domain", "ModelVersion", "DocString", "Graph", "MetadataProps", "TrainingInfo", "Functions" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.StringStringEntryProto), global::Onnx.StringStringEntryProto.Parser, new[]{ "Key", "Value" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.TensorAnnotation), global::Onnx.TensorAnnotation.Parser, new[]{ "TensorName", "QuantParameterTensorNames" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.GraphProto), global::Onnx.GraphProto.Parser, new[]{ "Node", "Name", "Initializer", "SparseInitializer", "DocString", "Input", "Output", "ValueInfo", "QuantizationAnnotation" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.TensorProto), global::Onnx.TensorProto.Parser, new[]{ "Dims", "DataType", "Segment", "FloatData", "Int32Data", "StringData", "Int64Data", "Name", "DocString", "RawData", "ExternalData", "DataLocation", "DoubleData", "Uint64Data" }, null, new[]{ typeof(global::Onnx.TensorProto.Types.DataType), typeof(global::Onnx.TensorProto.Types.DataLocation) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.TensorProto.Types.Segment), global::Onnx.TensorProto.Types.Segment.Parser, new[]{ "Begin", "End" }, null, null, null, null)}), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.SparseTensorProto), global::Onnx.SparseTensorProto.Parser, new[]{ "Values", "Indices", "Dims" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.TensorShapeProto), global::Onnx.TensorShapeProto.Parser, new[]{ "Dim" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.TensorShapeProto.Types.Dimension), global::Onnx.TensorShapeProto.Types.Dimension.Parser, new[]{ "DimValue", "DimParam", "Denotation" }, new[]{ "Value" }, null, null, null)}), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.TypeProto), global::Onnx.TypeProto.Parser, new[]{ "TensorType", "SequenceType", "MapType", "OptionalType", "SparseTensorType", "Denotation" }, new[]{ "Value" }, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.TypeProto.Types.Tensor), global::Onnx.TypeProto.Types.Tensor.Parser, new[]{ "ElemType", "Shape" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.TypeProto.Types.Sequence), global::Onnx.TypeProto.Types.Sequence.Parser, new[]{ "ElemType" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.TypeProto.Types.Map), global::Onnx.TypeProto.Types.Map.Parser, new[]{ "KeyType", "ValueType" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.TypeProto.Types.Optional), global::Onnx.TypeProto.Types.Optional.Parser, new[]{ "ElemType" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.TypeProto.Types.SparseTensor), global::Onnx.TypeProto.Types.SparseTensor.Parser, new[]{ "ElemType", "Shape" }, null, null, null, null)}), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.OperatorSetIdProto), global::Onnx.OperatorSetIdProto.Parser, new[]{ "Domain", "Version" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Onnx.FunctionProto), global::Onnx.FunctionProto.Parser, new[]{ "Name", "Input", "Output", "Attribute", "AttributeProto", "Node", "DocString", "OpsetImport", "Domain" }, null, null, null, null) + })); + } + #endregion + + } + #region Enums + /// + /// Versioning + /// + /// ONNX versioning is specified in docs/IR.md and elaborated on in docs/Versioning.md + /// + /// To be compatible with both proto2 and proto3, we will use a version number + /// that is not defined by the default value but an explicit enum number. + /// + public enum Version { + /// + /// proto3 requires the first enum value to be zero. + /// We add this just to appease the compiler. + /// + [pbr::OriginalName("_START_VERSION")] StartVersion = 0, + /// + /// The version field is always serialized and we will use it to store the + /// version that the graph is generated from. This helps us set up version + /// control. + /// For the IR, we are using simple numbers starting with 0x00000001, + /// which was the version we published on Oct 10, 2017. + /// + [pbr::OriginalName("IR_VERSION_2017_10_10")] IrVersion20171010 = 1, + /// + /// IR_VERSION 2 published on Oct 30, 2017 + /// - Added type discriminator to AttributeProto to support proto3 users + /// + [pbr::OriginalName("IR_VERSION_2017_10_30")] IrVersion20171030 = 2, + /// + /// IR VERSION 3 published on Nov 3, 2017 + /// - For operator versioning: + /// - Added new message OperatorSetIdProto + /// - Added opset_import in ModelProto + /// - For vendor extensions, added domain in NodeProto + /// + [pbr::OriginalName("IR_VERSION_2017_11_3")] IrVersion2017113 = 3, + /// + /// IR VERSION 4 published on Jan 22, 2019 + /// - Relax constraint that initializers should be a subset of graph inputs + /// - Add type BFLOAT16 + /// + [pbr::OriginalName("IR_VERSION_2019_1_22")] IrVersion2019122 = 4, + /// + /// IR VERSION 5 published on March 18, 2019 + /// - Add message TensorAnnotation. + /// - Add quantization annotation in GraphProto to map tensor with its scale and zero point quantization parameters. + /// + [pbr::OriginalName("IR_VERSION_2019_3_18")] IrVersion2019318 = 5, + /// + /// IR VERSION 6 published on Sep 19, 2019 + /// - Add support for sparse tensor constants stored in model. + /// - Add message SparseTensorProto + /// - Add sparse initializers + /// + [pbr::OriginalName("IR_VERSION_2019_9_19")] IrVersion2019919 = 6, + /// + /// IR VERSION 7 published on May 8, 2020 + /// - Add support to allow function body graph to rely on multiple external opreator sets. + /// - Add a list to promote inference graph's initializers to global and + /// mutable variables. Global variables are visible in all graphs of the + /// stored models. + /// - Add message TrainingInfoProto to store initialization + /// method and training algorithm. The execution of TrainingInfoProto + /// can modify the values of mutable variables. + /// - Implicitly add inference graph into each TrainingInfoProto's algorithm. + /// + [pbr::OriginalName("IR_VERSION_2020_5_8")] IrVersion202058 = 7, + /// + /// IR VERSION 8 published on July 30, 2021 + /// Introduce TypeProto.SparseTensor + /// Introduce TypeProto.Optional + /// Added a list of FunctionProtos local to the model + /// Deprecated since_version and operator status from FunctionProto + /// + [pbr::OriginalName("IR_VERSION_2021_7_30")] IrVersion2021730 = 8, + /// + /// IR VERSION 9 published on TBD + /// Added AttributeProto to FunctionProto so that default attribute values can be set. + /// Added FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ. + /// + [pbr::OriginalName("IR_VERSION")] IrVersion = 9, + } + + /// + /// Operator/function status. + /// + public enum OperatorStatus { + [pbr::OriginalName("EXPERIMENTAL")] Experimental = 0, + [pbr::OriginalName("STABLE")] Stable = 1, + } + + #endregion + + #region Messages + /// + /// Attributes + /// + /// A named attribute containing either singular float, integer, string, graph, + /// and tensor values, or repeated float, integer, string, graph, and tensor values. + /// An AttributeProto MUST contain the name field, and *only one* of the + /// following content fields, effectively enforcing a C/C++ union equivalent. + /// + public sealed partial class AttributeProto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AttributeProto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.OnnxReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AttributeProto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AttributeProto(AttributeProto other) : this() { + name_ = other.name_; + refAttrName_ = other.refAttrName_; + docString_ = other.docString_; + type_ = other.type_; + f_ = other.f_; + i_ = other.i_; + s_ = other.s_; + t_ = other.t_ != null ? other.t_.Clone() : null; + g_ = other.g_ != null ? other.g_.Clone() : null; + sparseTensor_ = other.sparseTensor_ != null ? other.sparseTensor_.Clone() : null; + tp_ = other.tp_ != null ? other.tp_.Clone() : null; + floats_ = other.floats_.Clone(); + ints_ = other.ints_.Clone(); + strings_ = other.strings_.Clone(); + tensors_ = other.tensors_.Clone(); + graphs_ = other.graphs_.Clone(); + sparseTensors_ = other.sparseTensors_.Clone(); + typeProtos_ = other.typeProtos_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AttributeProto Clone() { + return new AttributeProto(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + /// + /// The name field MUST be present for this version of the IR. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "ref_attr_name" field. + public const int RefAttrNameFieldNumber = 21; + private string refAttrName_ = ""; + /// + /// if ref_attr_name is not empty, ref_attr_name is the attribute name in parent function. + /// In this case, this AttributeProto does not contain data, and it's a reference of attribute + /// in parent scope. + /// NOTE: This should ONLY be used in function (sub-graph). It's invalid to be used in main graph. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string RefAttrName { + get { return refAttrName_; } + set { + refAttrName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "doc_string" field. + public const int DocStringFieldNumber = 13; + private string docString_ = ""; + /// + /// A human-readable documentation for this attribute. Markdown is allowed. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DocString { + get { return docString_; } + set { + docString_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "type" field. + public const int TypeFieldNumber = 20; + private global::Onnx.AttributeProto.Types.AttributeType type_ = global::Onnx.AttributeProto.Types.AttributeType.Undefined; + /// + /// The type field MUST be present for this version of the IR. + /// For 0.0.1 versions of the IR, this field was not defined, and + /// implementations needed to use has_field heuristics to determine + /// which value field was in use. For IR_VERSION 0.0.2 or later, this + /// field MUST be set and match the f|i|s|t|... field in use. This + /// change was made to accommodate proto3 implementations. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.AttributeProto.Types.AttributeType Type { + get { return type_; } + set { + type_ = value; + } + } + + /// Field number for the "f" field. + public const int FFieldNumber = 2; + private float f_; + /// + /// Exactly ONE of the following fields must be present for this version of the IR + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public float F { + get { return f_; } + set { + f_ = value; + } + } + + /// Field number for the "i" field. + public const int IFieldNumber = 3; + private long i_; + /// + /// int + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public long I { + get { return i_; } + set { + i_ = value; + } + } + + /// Field number for the "s" field. + public const int SFieldNumber = 4; + private pb::ByteString s_ = pb::ByteString.Empty; + /// + /// UTF-8 string + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pb::ByteString S { + get { return s_; } + set { + s_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "t" field. + public const int TFieldNumber = 5; + private global::Onnx.TensorProto t_; + /// + /// tensor value + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TensorProto T { + get { return t_; } + set { + t_ = value; + } + } + + /// Field number for the "g" field. + public const int GFieldNumber = 6; + private global::Onnx.GraphProto g_; + /// + /// graph + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.GraphProto G { + get { return g_; } + set { + g_ = value; + } + } + + /// Field number for the "sparse_tensor" field. + public const int SparseTensorFieldNumber = 22; + private global::Onnx.SparseTensorProto sparseTensor_; + /// + /// sparse tensor value + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.SparseTensorProto SparseTensor { + get { return sparseTensor_; } + set { + sparseTensor_ = value; + } + } + + /// Field number for the "tp" field. + public const int TpFieldNumber = 14; + private global::Onnx.TypeProto tp_; + /// + /// Do not use field below, it's deprecated. + /// optional ValueProto v = 12; // value - subsumes everything but graph + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TypeProto Tp { + get { return tp_; } + set { + tp_ = value; + } + } + + /// Field number for the "floats" field. + public const int FloatsFieldNumber = 7; + private static readonly pb::FieldCodec _repeated_floats_codec + = pb::FieldCodec.ForFloat(58); + private readonly pbc::RepeatedField floats_ = new pbc::RepeatedField(); + /// + /// list of floats + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Floats { + get { return floats_; } + } + + /// Field number for the "ints" field. + public const int IntsFieldNumber = 8; + private static readonly pb::FieldCodec _repeated_ints_codec + = pb::FieldCodec.ForInt64(66); + private readonly pbc::RepeatedField ints_ = new pbc::RepeatedField(); + /// + /// list of ints + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Ints { + get { return ints_; } + } + + /// Field number for the "strings" field. + public const int StringsFieldNumber = 9; + private static readonly pb::FieldCodec _repeated_strings_codec + = pb::FieldCodec.ForBytes(74); + private readonly pbc::RepeatedField strings_ = new pbc::RepeatedField(); + /// + /// list of UTF-8 strings + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Strings { + get { return strings_; } + } + + /// Field number for the "tensors" field. + public const int TensorsFieldNumber = 10; + private static readonly pb::FieldCodec _repeated_tensors_codec + = pb::FieldCodec.ForMessage(82, global::Onnx.TensorProto.Parser); + private readonly pbc::RepeatedField tensors_ = new pbc::RepeatedField(); + /// + /// list of tensors + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Tensors { + get { return tensors_; } + } + + /// Field number for the "graphs" field. + public const int GraphsFieldNumber = 11; + private static readonly pb::FieldCodec _repeated_graphs_codec + = pb::FieldCodec.ForMessage(90, global::Onnx.GraphProto.Parser); + private readonly pbc::RepeatedField graphs_ = new pbc::RepeatedField(); + /// + /// list of graph + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Graphs { + get { return graphs_; } + } + + /// Field number for the "sparse_tensors" field. + public const int SparseTensorsFieldNumber = 23; + private static readonly pb::FieldCodec _repeated_sparseTensors_codec + = pb::FieldCodec.ForMessage(186, global::Onnx.SparseTensorProto.Parser); + private readonly pbc::RepeatedField sparseTensors_ = new pbc::RepeatedField(); + /// + /// list of sparse tensors + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField SparseTensors { + get { return sparseTensors_; } + } + + /// Field number for the "type_protos" field. + public const int TypeProtosFieldNumber = 15; + private static readonly pb::FieldCodec _repeated_typeProtos_codec + = pb::FieldCodec.ForMessage(122, global::Onnx.TypeProto.Parser); + private readonly pbc::RepeatedField typeProtos_ = new pbc::RepeatedField(); + /// + /// list of type protos + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField TypeProtos { + get { return typeProtos_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as AttributeProto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(AttributeProto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (RefAttrName != other.RefAttrName) return false; + if (DocString != other.DocString) return false; + if (Type != other.Type) return false; + if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(F, other.F)) return false; + if (I != other.I) return false; + if (S != other.S) return false; + if (!object.Equals(T, other.T)) return false; + if (!object.Equals(G, other.G)) return false; + if (!object.Equals(SparseTensor, other.SparseTensor)) return false; + if (!object.Equals(Tp, other.Tp)) return false; + if(!floats_.Equals(other.floats_)) return false; + if(!ints_.Equals(other.ints_)) return false; + if(!strings_.Equals(other.strings_)) return false; + if(!tensors_.Equals(other.tensors_)) return false; + if(!graphs_.Equals(other.graphs_)) return false; + if(!sparseTensors_.Equals(other.sparseTensors_)) return false; + if(!typeProtos_.Equals(other.typeProtos_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (RefAttrName.Length != 0) hash ^= RefAttrName.GetHashCode(); + if (DocString.Length != 0) hash ^= DocString.GetHashCode(); + if (Type != global::Onnx.AttributeProto.Types.AttributeType.Undefined) hash ^= Type.GetHashCode(); + if (F != 0F) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(F); + if (I != 0L) hash ^= I.GetHashCode(); + if (S.Length != 0) hash ^= S.GetHashCode(); + if (t_ != null) hash ^= T.GetHashCode(); + if (g_ != null) hash ^= G.GetHashCode(); + if (sparseTensor_ != null) hash ^= SparseTensor.GetHashCode(); + if (tp_ != null) hash ^= Tp.GetHashCode(); + hash ^= floats_.GetHashCode(); + hash ^= ints_.GetHashCode(); + hash ^= strings_.GetHashCode(); + hash ^= tensors_.GetHashCode(); + hash ^= graphs_.GetHashCode(); + hash ^= sparseTensors_.GetHashCode(); + hash ^= typeProtos_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (F != 0F) { + output.WriteRawTag(21); + output.WriteFloat(F); + } + if (I != 0L) { + output.WriteRawTag(24); + output.WriteInt64(I); + } + if (S.Length != 0) { + output.WriteRawTag(34); + output.WriteBytes(S); + } + if (t_ != null) { + output.WriteRawTag(42); + output.WriteMessage(T); + } + if (g_ != null) { + output.WriteRawTag(50); + output.WriteMessage(G); + } + floats_.WriteTo(output, _repeated_floats_codec); + ints_.WriteTo(output, _repeated_ints_codec); + strings_.WriteTo(output, _repeated_strings_codec); + tensors_.WriteTo(output, _repeated_tensors_codec); + graphs_.WriteTo(output, _repeated_graphs_codec); + if (DocString.Length != 0) { + output.WriteRawTag(106); + output.WriteString(DocString); + } + if (tp_ != null) { + output.WriteRawTag(114); + output.WriteMessage(Tp); + } + typeProtos_.WriteTo(output, _repeated_typeProtos_codec); + if (Type != global::Onnx.AttributeProto.Types.AttributeType.Undefined) { + output.WriteRawTag(160, 1); + output.WriteEnum((int) Type); + } + if (RefAttrName.Length != 0) { + output.WriteRawTag(170, 1); + output.WriteString(RefAttrName); + } + if (sparseTensor_ != null) { + output.WriteRawTag(178, 1); + output.WriteMessage(SparseTensor); + } + sparseTensors_.WriteTo(output, _repeated_sparseTensors_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (F != 0F) { + output.WriteRawTag(21); + output.WriteFloat(F); + } + if (I != 0L) { + output.WriteRawTag(24); + output.WriteInt64(I); + } + if (S.Length != 0) { + output.WriteRawTag(34); + output.WriteBytes(S); + } + if (t_ != null) { + output.WriteRawTag(42); + output.WriteMessage(T); + } + if (g_ != null) { + output.WriteRawTag(50); + output.WriteMessage(G); + } + floats_.WriteTo(ref output, _repeated_floats_codec); + ints_.WriteTo(ref output, _repeated_ints_codec); + strings_.WriteTo(ref output, _repeated_strings_codec); + tensors_.WriteTo(ref output, _repeated_tensors_codec); + graphs_.WriteTo(ref output, _repeated_graphs_codec); + if (DocString.Length != 0) { + output.WriteRawTag(106); + output.WriteString(DocString); + } + if (tp_ != null) { + output.WriteRawTag(114); + output.WriteMessage(Tp); + } + typeProtos_.WriteTo(ref output, _repeated_typeProtos_codec); + if (Type != global::Onnx.AttributeProto.Types.AttributeType.Undefined) { + output.WriteRawTag(160, 1); + output.WriteEnum((int) Type); + } + if (RefAttrName.Length != 0) { + output.WriteRawTag(170, 1); + output.WriteString(RefAttrName); + } + if (sparseTensor_ != null) { + output.WriteRawTag(178, 1); + output.WriteMessage(SparseTensor); + } + sparseTensors_.WriteTo(ref output, _repeated_sparseTensors_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (RefAttrName.Length != 0) { + size += 2 + pb::CodedOutputStream.ComputeStringSize(RefAttrName); + } + if (DocString.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DocString); + } + if (Type != global::Onnx.AttributeProto.Types.AttributeType.Undefined) { + size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) Type); + } + if (F != 0F) { + size += 1 + 4; + } + if (I != 0L) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(I); + } + if (S.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(S); + } + if (t_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(T); + } + if (g_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(G); + } + if (sparseTensor_ != null) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SparseTensor); + } + if (tp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Tp); + } + size += floats_.CalculateSize(_repeated_floats_codec); + size += ints_.CalculateSize(_repeated_ints_codec); + size += strings_.CalculateSize(_repeated_strings_codec); + size += tensors_.CalculateSize(_repeated_tensors_codec); + size += graphs_.CalculateSize(_repeated_graphs_codec); + size += sparseTensors_.CalculateSize(_repeated_sparseTensors_codec); + size += typeProtos_.CalculateSize(_repeated_typeProtos_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(AttributeProto other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.RefAttrName.Length != 0) { + RefAttrName = other.RefAttrName; + } + if (other.DocString.Length != 0) { + DocString = other.DocString; + } + if (other.Type != global::Onnx.AttributeProto.Types.AttributeType.Undefined) { + Type = other.Type; + } + if (other.F != 0F) { + F = other.F; + } + if (other.I != 0L) { + I = other.I; + } + if (other.S.Length != 0) { + S = other.S; + } + if (other.t_ != null) { + if (t_ == null) { + T = new global::Onnx.TensorProto(); + } + T.MergeFrom(other.T); + } + if (other.g_ != null) { + if (g_ == null) { + G = new global::Onnx.GraphProto(); + } + G.MergeFrom(other.G); + } + if (other.sparseTensor_ != null) { + if (sparseTensor_ == null) { + SparseTensor = new global::Onnx.SparseTensorProto(); + } + SparseTensor.MergeFrom(other.SparseTensor); + } + if (other.tp_ != null) { + if (tp_ == null) { + Tp = new global::Onnx.TypeProto(); + } + Tp.MergeFrom(other.Tp); + } + floats_.Add(other.floats_); + ints_.Add(other.ints_); + strings_.Add(other.strings_); + tensors_.Add(other.tensors_); + graphs_.Add(other.graphs_); + sparseTensors_.Add(other.sparseTensors_); + typeProtos_.Add(other.typeProtos_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 21: { + F = input.ReadFloat(); + break; + } + case 24: { + I = input.ReadInt64(); + break; + } + case 34: { + S = input.ReadBytes(); + break; + } + case 42: { + if (t_ == null) { + T = new global::Onnx.TensorProto(); + } + input.ReadMessage(T); + break; + } + case 50: { + if (g_ == null) { + G = new global::Onnx.GraphProto(); + } + input.ReadMessage(G); + break; + } + case 58: + case 61: { + floats_.AddEntriesFrom(input, _repeated_floats_codec); + break; + } + case 66: + case 64: { + ints_.AddEntriesFrom(input, _repeated_ints_codec); + break; + } + case 74: { + strings_.AddEntriesFrom(input, _repeated_strings_codec); + break; + } + case 82: { + tensors_.AddEntriesFrom(input, _repeated_tensors_codec); + break; + } + case 90: { + graphs_.AddEntriesFrom(input, _repeated_graphs_codec); + break; + } + case 106: { + DocString = input.ReadString(); + break; + } + case 114: { + if (tp_ == null) { + Tp = new global::Onnx.TypeProto(); + } + input.ReadMessage(Tp); + break; + } + case 122: { + typeProtos_.AddEntriesFrom(input, _repeated_typeProtos_codec); + break; + } + case 160: { + Type = (global::Onnx.AttributeProto.Types.AttributeType) input.ReadEnum(); + break; + } + case 170: { + RefAttrName = input.ReadString(); + break; + } + case 178: { + if (sparseTensor_ == null) { + SparseTensor = new global::Onnx.SparseTensorProto(); + } + input.ReadMessage(SparseTensor); + break; + } + case 186: { + sparseTensors_.AddEntriesFrom(input, _repeated_sparseTensors_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 21: { + F = input.ReadFloat(); + break; + } + case 24: { + I = input.ReadInt64(); + break; + } + case 34: { + S = input.ReadBytes(); + break; + } + case 42: { + if (t_ == null) { + T = new global::Onnx.TensorProto(); + } + input.ReadMessage(T); + break; + } + case 50: { + if (g_ == null) { + G = new global::Onnx.GraphProto(); + } + input.ReadMessage(G); + break; + } + case 58: + case 61: { + floats_.AddEntriesFrom(ref input, _repeated_floats_codec); + break; + } + case 66: + case 64: { + ints_.AddEntriesFrom(ref input, _repeated_ints_codec); + break; + } + case 74: { + strings_.AddEntriesFrom(ref input, _repeated_strings_codec); + break; + } + case 82: { + tensors_.AddEntriesFrom(ref input, _repeated_tensors_codec); + break; + } + case 90: { + graphs_.AddEntriesFrom(ref input, _repeated_graphs_codec); + break; + } + case 106: { + DocString = input.ReadString(); + break; + } + case 114: { + if (tp_ == null) { + Tp = new global::Onnx.TypeProto(); + } + input.ReadMessage(Tp); + break; + } + case 122: { + typeProtos_.AddEntriesFrom(ref input, _repeated_typeProtos_codec); + break; + } + case 160: { + Type = (global::Onnx.AttributeProto.Types.AttributeType) input.ReadEnum(); + break; + } + case 170: { + RefAttrName = input.ReadString(); + break; + } + case 178: { + if (sparseTensor_ == null) { + SparseTensor = new global::Onnx.SparseTensorProto(); + } + input.ReadMessage(SparseTensor); + break; + } + case 186: { + sparseTensors_.AddEntriesFrom(ref input, _repeated_sparseTensors_codec); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the AttributeProto message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static partial class Types { + /// + /// Note: this enum is structurally identical to the OpSchema::AttrType + /// enum defined in schema.h. If you rev one, you likely need to rev the other. + /// + public enum AttributeType { + [pbr::OriginalName("UNDEFINED")] Undefined = 0, + [pbr::OriginalName("FLOAT")] Float = 1, + [pbr::OriginalName("INT")] Int = 2, + [pbr::OriginalName("STRING")] String = 3, + [pbr::OriginalName("TENSOR")] Tensor = 4, + [pbr::OriginalName("GRAPH")] Graph = 5, + [pbr::OriginalName("SPARSE_TENSOR")] SparseTensor = 11, + [pbr::OriginalName("TYPE_PROTO")] TypeProto = 13, + [pbr::OriginalName("FLOATS")] Floats = 6, + [pbr::OriginalName("INTS")] Ints = 7, + [pbr::OriginalName("STRINGS")] Strings = 8, + [pbr::OriginalName("TENSORS")] Tensors = 9, + [pbr::OriginalName("GRAPHS")] Graphs = 10, + [pbr::OriginalName("SPARSE_TENSORS")] SparseTensors = 12, + [pbr::OriginalName("TYPE_PROTOS")] TypeProtos = 14, + } + + } + #endregion + + } + + /// + /// Defines information on value, including the name, the type, and + /// the shape of the value. + /// + public sealed partial class ValueInfoProto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ValueInfoProto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.OnnxReflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ValueInfoProto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ValueInfoProto(ValueInfoProto other) : this() { + name_ = other.name_; + type_ = other.type_ != null ? other.type_.Clone() : null; + docString_ = other.docString_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ValueInfoProto Clone() { + return new ValueInfoProto(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + /// + /// This field MUST be present in this version of the IR. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "type" field. + public const int TypeFieldNumber = 2; + private global::Onnx.TypeProto type_; + /// + /// This field MUST be present in this version of the IR for + /// inputs and outputs of the top-level graph. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TypeProto Type { + get { return type_; } + set { + type_ = value; + } + } + + /// Field number for the "doc_string" field. + public const int DocStringFieldNumber = 3; + private string docString_ = ""; + /// + /// A human-readable documentation for this value. Markdown is allowed. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DocString { + get { return docString_; } + set { + docString_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ValueInfoProto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ValueInfoProto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (!object.Equals(Type, other.Type)) return false; + if (DocString != other.DocString) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (type_ != null) hash ^= Type.GetHashCode(); + if (DocString.Length != 0) hash ^= DocString.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (type_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Type); + } + if (DocString.Length != 0) { + output.WriteRawTag(26); + output.WriteString(DocString); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (type_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Type); + } + if (DocString.Length != 0) { + output.WriteRawTag(26); + output.WriteString(DocString); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (type_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Type); + } + if (DocString.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DocString); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ValueInfoProto other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.type_ != null) { + if (type_ == null) { + Type = new global::Onnx.TypeProto(); + } + Type.MergeFrom(other.Type); + } + if (other.DocString.Length != 0) { + DocString = other.DocString; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + if (type_ == null) { + Type = new global::Onnx.TypeProto(); + } + input.ReadMessage(Type); + break; + } + case 26: { + DocString = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + if (type_ == null) { + Type = new global::Onnx.TypeProto(); + } + input.ReadMessage(Type); + break; + } + case 26: { + DocString = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// Nodes + /// + /// Computation graphs are made up of a DAG of nodes, which represent what is + /// commonly called a "layer" or "pipeline stage" in machine learning frameworks. + /// + /// For example, it can be a node of type "Conv" that takes in an image, a filter + /// tensor and a bias tensor, and produces the convolved output. + /// + public sealed partial class NodeProto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NodeProto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.OnnxReflection.Descriptor.MessageTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NodeProto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NodeProto(NodeProto other) : this() { + input_ = other.input_.Clone(); + output_ = other.output_.Clone(); + name_ = other.name_; + opType_ = other.opType_; + domain_ = other.domain_; + attribute_ = other.attribute_.Clone(); + docString_ = other.docString_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NodeProto Clone() { + return new NodeProto(this); + } + + /// Field number for the "input" field. + public const int InputFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_input_codec + = pb::FieldCodec.ForString(10); + private readonly pbc::RepeatedField input_ = new pbc::RepeatedField(); + /// + /// namespace Value + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Input { + get { return input_; } + } + + /// Field number for the "output" field. + public const int OutputFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_output_codec + = pb::FieldCodec.ForString(18); + private readonly pbc::RepeatedField output_ = new pbc::RepeatedField(); + /// + /// namespace Value + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Output { + get { return output_; } + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 3; + private string name_ = ""; + /// + /// An optional identifier for this node in a graph. + /// This field MAY be absent in ths version of the IR. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "op_type" field. + public const int OpTypeFieldNumber = 4; + private string opType_ = ""; + /// + /// The symbolic identifier of the Operator to execute. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string OpType { + get { return opType_; } + set { + opType_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "domain" field. + public const int DomainFieldNumber = 7; + private string domain_ = ""; + /// + /// The domain of the OperatorSet that specifies the operator named by op_type. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Domain { + get { return domain_; } + set { + domain_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "attribute" field. + public const int AttributeFieldNumber = 5; + private static readonly pb::FieldCodec _repeated_attribute_codec + = pb::FieldCodec.ForMessage(42, global::Onnx.AttributeProto.Parser); + private readonly pbc::RepeatedField attribute_ = new pbc::RepeatedField(); + /// + /// Additional named attributes. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Attribute { + get { return attribute_; } + } + + /// Field number for the "doc_string" field. + public const int DocStringFieldNumber = 6; + private string docString_ = ""; + /// + /// A human-readable documentation for this node. Markdown is allowed. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DocString { + get { return docString_; } + set { + docString_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as NodeProto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(NodeProto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!input_.Equals(other.input_)) return false; + if(!output_.Equals(other.output_)) return false; + if (Name != other.Name) return false; + if (OpType != other.OpType) return false; + if (Domain != other.Domain) return false; + if(!attribute_.Equals(other.attribute_)) return false; + if (DocString != other.DocString) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= input_.GetHashCode(); + hash ^= output_.GetHashCode(); + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (OpType.Length != 0) hash ^= OpType.GetHashCode(); + if (Domain.Length != 0) hash ^= Domain.GetHashCode(); + hash ^= attribute_.GetHashCode(); + if (DocString.Length != 0) hash ^= DocString.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + input_.WriteTo(output, _repeated_input_codec); + output_.WriteTo(output, _repeated_output_codec); + if (Name.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Name); + } + if (OpType.Length != 0) { + output.WriteRawTag(34); + output.WriteString(OpType); + } + attribute_.WriteTo(output, _repeated_attribute_codec); + if (DocString.Length != 0) { + output.WriteRawTag(50); + output.WriteString(DocString); + } + if (Domain.Length != 0) { + output.WriteRawTag(58); + output.WriteString(Domain); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + input_.WriteTo(ref output, _repeated_input_codec); + output_.WriteTo(ref output, _repeated_output_codec); + if (Name.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Name); + } + if (OpType.Length != 0) { + output.WriteRawTag(34); + output.WriteString(OpType); + } + attribute_.WriteTo(ref output, _repeated_attribute_codec); + if (DocString.Length != 0) { + output.WriteRawTag(50); + output.WriteString(DocString); + } + if (Domain.Length != 0) { + output.WriteRawTag(58); + output.WriteString(Domain); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += input_.CalculateSize(_repeated_input_codec); + size += output_.CalculateSize(_repeated_output_codec); + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (OpType.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OpType); + } + if (Domain.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Domain); + } + size += attribute_.CalculateSize(_repeated_attribute_codec); + if (DocString.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DocString); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(NodeProto other) { + if (other == null) { + return; + } + input_.Add(other.input_); + output_.Add(other.output_); + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.OpType.Length != 0) { + OpType = other.OpType; + } + if (other.Domain.Length != 0) { + Domain = other.Domain; + } + attribute_.Add(other.attribute_); + if (other.DocString.Length != 0) { + DocString = other.DocString; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + input_.AddEntriesFrom(input, _repeated_input_codec); + break; + } + case 18: { + output_.AddEntriesFrom(input, _repeated_output_codec); + break; + } + case 26: { + Name = input.ReadString(); + break; + } + case 34: { + OpType = input.ReadString(); + break; + } + case 42: { + attribute_.AddEntriesFrom(input, _repeated_attribute_codec); + break; + } + case 50: { + DocString = input.ReadString(); + break; + } + case 58: { + Domain = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + input_.AddEntriesFrom(ref input, _repeated_input_codec); + break; + } + case 18: { + output_.AddEntriesFrom(ref input, _repeated_output_codec); + break; + } + case 26: { + Name = input.ReadString(); + break; + } + case 34: { + OpType = input.ReadString(); + break; + } + case 42: { + attribute_.AddEntriesFrom(ref input, _repeated_attribute_codec); + break; + } + case 50: { + DocString = input.ReadString(); + break; + } + case 58: { + Domain = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// Training information + /// TrainingInfoProto stores information for training a model. + /// In particular, this defines two functionalities: an initialization-step + /// and a training-algorithm-step. Initialization resets the model + /// back to its original state as if no training has been performed. + /// Training algorithm improves the model based on input data. + /// + /// The semantics of the initialization-step is that the initializers + /// in ModelProto.graph and in TrainingInfoProto.algorithm are first + /// initialized as specified by the initializers in the graph, and then + /// updated by the "initialization_binding" in every instance in + /// ModelProto.training_info. + /// + /// The field "algorithm" defines a computation graph which represents a + /// training algorithm's step. After the execution of a + /// TrainingInfoProto.algorithm, the initializers specified by "update_binding" + /// may be immediately updated. If the targeted training algorithm contains + /// consecutive update steps (such as block coordinate descent methods), + /// the user needs to create a TrainingInfoProto for each step. + /// + public sealed partial class TrainingInfoProto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TrainingInfoProto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.OnnxReflection.Descriptor.MessageTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TrainingInfoProto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TrainingInfoProto(TrainingInfoProto other) : this() { + initialization_ = other.initialization_ != null ? other.initialization_.Clone() : null; + algorithm_ = other.algorithm_ != null ? other.algorithm_.Clone() : null; + initializationBinding_ = other.initializationBinding_.Clone(); + updateBinding_ = other.updateBinding_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TrainingInfoProto Clone() { + return new TrainingInfoProto(this); + } + + /// Field number for the "initialization" field. + public const int InitializationFieldNumber = 1; + private global::Onnx.GraphProto initialization_; + /// + /// This field describes a graph to compute the initial tensors + /// upon starting the training process. Initialization graph has no input + /// and can have multiple outputs. Usually, trainable tensors in neural + /// networks are randomly initialized. To achieve that, for each tensor, + /// the user can put a random number operator such as RandomNormal or + /// RandomUniform in TrainingInfoProto.initialization.node and assign its + /// random output to the specific tensor using "initialization_binding". + /// This graph can also set the initializers in "algorithm" in the same + /// TrainingInfoProto; a use case is resetting the number of training + /// iteration to zero. + /// + /// By default, this field is an empty graph and its evaluation does not + /// produce any output. Thus, no initializer would be changed by default. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.GraphProto Initialization { + get { return initialization_; } + set { + initialization_ = value; + } + } + + /// Field number for the "algorithm" field. + public const int AlgorithmFieldNumber = 2; + private global::Onnx.GraphProto algorithm_; + /// + /// This field represents a training algorithm step. Given required inputs, + /// it computes outputs to update initializers in its own or inference graph's + /// initializer lists. In general, this field contains loss node, gradient node, + /// optimizer node, increment of iteration count. + /// + /// An execution of the training algorithm step is performed by executing the + /// graph obtained by combining the inference graph (namely "ModelProto.graph") + /// and the "algorithm" graph. That is, the actual the actual + /// input/initializer/output/node/value_info/sparse_initializer list of + /// the training graph is the concatenation of + /// "ModelProto.graph.input/initializer/output/node/value_info/sparse_initializer" + /// and "algorithm.input/initializer/output/node/value_info/sparse_initializer" + /// in that order. This combined graph must satisfy the normal ONNX conditions. + /// Now, let's provide a visualization of graph combination for clarity. + /// Let the inference graph (i.e., "ModelProto.graph") be + /// tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d + /// and the "algorithm" graph be + /// tensor_d -> Add -> tensor_e + /// The combination process results + /// tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d -> Add -> tensor_e + /// + /// Notice that an input of a node in the "algorithm" graph may reference the + /// output of a node in the inference graph (but not the other way round). Also, inference + /// node cannot reference inputs of "algorithm". With these restrictions, inference graph + /// can always be run independently without training information. + /// + /// By default, this field is an empty graph and its evaluation does not + /// produce any output. Evaluating the default training step never + /// update any initializers. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.GraphProto Algorithm { + get { return algorithm_; } + set { + algorithm_ = value; + } + } + + /// Field number for the "initialization_binding" field. + public const int InitializationBindingFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_initializationBinding_codec + = pb::FieldCodec.ForMessage(26, global::Onnx.StringStringEntryProto.Parser); + private readonly pbc::RepeatedField initializationBinding_ = new pbc::RepeatedField(); + /// + /// This field specifies the bindings from the outputs of "initialization" to + /// some initializers in "ModelProto.graph.initializer" and + /// the "algorithm.initializer" in the same TrainingInfoProto. + /// See "update_binding" below for details. + /// + /// By default, this field is empty and no initializer would be changed + /// by the execution of "initialization". + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField InitializationBinding { + get { return initializationBinding_; } + } + + /// Field number for the "update_binding" field. + public const int UpdateBindingFieldNumber = 4; + private static readonly pb::FieldCodec _repeated_updateBinding_codec + = pb::FieldCodec.ForMessage(34, global::Onnx.StringStringEntryProto.Parser); + private readonly pbc::RepeatedField updateBinding_ = new pbc::RepeatedField(); + /// + /// Gradient-based training is usually an iterative procedure. In one gradient + /// descent iteration, we apply + /// + /// x = x - r * g + /// + /// where "x" is the optimized tensor, "r" stands for learning rate, and "g" is + /// gradient of "x" with respect to a chosen loss. To avoid adding assignments + /// into the training graph, we split the update equation into + /// + /// y = x - r * g + /// x = y + /// + /// The user needs to save "y = x - r * g" into TrainingInfoProto.algorithm. To + /// tell that "y" should be assigned to "x", the field "update_binding" may + /// contain a key-value pair of strings, "x" (key of StringStringEntryProto) + /// and "y" (value of StringStringEntryProto). + /// For a neural network with multiple trainable (mutable) tensors, there can + /// be multiple key-value pairs in "update_binding". + /// + /// The initializers appears as keys in "update_binding" are considered + /// mutable variables. This implies some behaviors + /// as described below. + /// + /// 1. We have only unique keys in all "update_binding"s so that two + /// variables may not have the same name. This ensures that one + /// variable is assigned up to once. + /// 2. The keys must appear in names of "ModelProto.graph.initializer" or + /// "TrainingInfoProto.algorithm.initializer". + /// 3. The values must be output names of "algorithm" or "ModelProto.graph.output". + /// 4. Mutable variables are initialized to the value specified by the + /// corresponding initializer, and then potentially updated by + /// "initializer_binding"s and "update_binding"s in "TrainingInfoProto"s. + /// + /// This field usually contains names of trainable tensors + /// (in ModelProto.graph), optimizer states such as momentums in advanced + /// stochastic gradient methods (in TrainingInfoProto.graph), + /// and number of training iterations (in TrainingInfoProto.graph). + /// + /// By default, this field is empty and no initializer would be changed + /// by the execution of "algorithm". + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField UpdateBinding { + get { return updateBinding_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TrainingInfoProto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TrainingInfoProto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Initialization, other.Initialization)) return false; + if (!object.Equals(Algorithm, other.Algorithm)) return false; + if(!initializationBinding_.Equals(other.initializationBinding_)) return false; + if(!updateBinding_.Equals(other.updateBinding_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (initialization_ != null) hash ^= Initialization.GetHashCode(); + if (algorithm_ != null) hash ^= Algorithm.GetHashCode(); + hash ^= initializationBinding_.GetHashCode(); + hash ^= updateBinding_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (initialization_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Initialization); + } + if (algorithm_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Algorithm); + } + initializationBinding_.WriteTo(output, _repeated_initializationBinding_codec); + updateBinding_.WriteTo(output, _repeated_updateBinding_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (initialization_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Initialization); + } + if (algorithm_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Algorithm); + } + initializationBinding_.WriteTo(ref output, _repeated_initializationBinding_codec); + updateBinding_.WriteTo(ref output, _repeated_updateBinding_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (initialization_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Initialization); + } + if (algorithm_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Algorithm); + } + size += initializationBinding_.CalculateSize(_repeated_initializationBinding_codec); + size += updateBinding_.CalculateSize(_repeated_updateBinding_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TrainingInfoProto other) { + if (other == null) { + return; + } + if (other.initialization_ != null) { + if (initialization_ == null) { + Initialization = new global::Onnx.GraphProto(); + } + Initialization.MergeFrom(other.Initialization); + } + if (other.algorithm_ != null) { + if (algorithm_ == null) { + Algorithm = new global::Onnx.GraphProto(); + } + Algorithm.MergeFrom(other.Algorithm); + } + initializationBinding_.Add(other.initializationBinding_); + updateBinding_.Add(other.updateBinding_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (initialization_ == null) { + Initialization = new global::Onnx.GraphProto(); + } + input.ReadMessage(Initialization); + break; + } + case 18: { + if (algorithm_ == null) { + Algorithm = new global::Onnx.GraphProto(); + } + input.ReadMessage(Algorithm); + break; + } + case 26: { + initializationBinding_.AddEntriesFrom(input, _repeated_initializationBinding_codec); + break; + } + case 34: { + updateBinding_.AddEntriesFrom(input, _repeated_updateBinding_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (initialization_ == null) { + Initialization = new global::Onnx.GraphProto(); + } + input.ReadMessage(Initialization); + break; + } + case 18: { + if (algorithm_ == null) { + Algorithm = new global::Onnx.GraphProto(); + } + input.ReadMessage(Algorithm); + break; + } + case 26: { + initializationBinding_.AddEntriesFrom(ref input, _repeated_initializationBinding_codec); + break; + } + case 34: { + updateBinding_.AddEntriesFrom(ref input, _repeated_updateBinding_codec); + break; + } + } + } + } + #endif + + } + + /// + /// Models + /// + /// ModelProto is a top-level file/container format for bundling a ML model and + /// associating its computation graph with metadata. + /// + /// The semantics of the model are described by the associated GraphProto's. + /// + public sealed partial class ModelProto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ModelProto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.OnnxReflection.Descriptor.MessageTypes[4]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ModelProto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ModelProto(ModelProto other) : this() { + irVersion_ = other.irVersion_; + opsetImport_ = other.opsetImport_.Clone(); + producerName_ = other.producerName_; + producerVersion_ = other.producerVersion_; + domain_ = other.domain_; + modelVersion_ = other.modelVersion_; + docString_ = other.docString_; + graph_ = other.graph_ != null ? other.graph_.Clone() : null; + metadataProps_ = other.metadataProps_.Clone(); + trainingInfo_ = other.trainingInfo_.Clone(); + functions_ = other.functions_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ModelProto Clone() { + return new ModelProto(this); + } + + /// Field number for the "ir_version" field. + public const int IrVersionFieldNumber = 1; + private long irVersion_; + /// + /// The version of the IR this model targets. See Version enum above. + /// This field MUST be present. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public long IrVersion { + get { return irVersion_; } + set { + irVersion_ = value; + } + } + + /// Field number for the "opset_import" field. + public const int OpsetImportFieldNumber = 8; + private static readonly pb::FieldCodec _repeated_opsetImport_codec + = pb::FieldCodec.ForMessage(66, global::Onnx.OperatorSetIdProto.Parser); + private readonly pbc::RepeatedField opsetImport_ = new pbc::RepeatedField(); + /// + /// The OperatorSets this model relies on. + /// All ModelProtos MUST have at least one entry that + /// specifies which version of the ONNX OperatorSet is + /// being imported. + /// + /// All nodes in the ModelProto's graph will bind against the operator + /// with the same-domain/same-op_type operator with the HIGHEST version + /// in the referenced operator sets. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField OpsetImport { + get { return opsetImport_; } + } + + /// Field number for the "producer_name" field. + public const int ProducerNameFieldNumber = 2; + private string producerName_ = ""; + /// + /// The name of the framework or tool used to generate this model. + /// This field SHOULD be present to indicate which implementation/tool/framework + /// emitted the model. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ProducerName { + get { return producerName_; } + set { + producerName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "producer_version" field. + public const int ProducerVersionFieldNumber = 3; + private string producerVersion_ = ""; + /// + /// The version of the framework or tool used to generate this model. + /// This field SHOULD be present to indicate which implementation/tool/framework + /// emitted the model. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ProducerVersion { + get { return producerVersion_; } + set { + producerVersion_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "domain" field. + public const int DomainFieldNumber = 4; + private string domain_ = ""; + /// + /// Domain name of the model. + /// We use reverse domain names as name space indicators. For example: + /// `com.facebook.fair` or `com.microsoft.cognitiveservices` + /// + /// Together with `model_version` and GraphProto.name, this forms the unique identity of + /// the graph. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Domain { + get { return domain_; } + set { + domain_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "model_version" field. + public const int ModelVersionFieldNumber = 5; + private long modelVersion_; + /// + /// The version of the graph encoded. See Version enum below. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public long ModelVersion { + get { return modelVersion_; } + set { + modelVersion_ = value; + } + } + + /// Field number for the "doc_string" field. + public const int DocStringFieldNumber = 6; + private string docString_ = ""; + /// + /// A human-readable documentation for this model. Markdown is allowed. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DocString { + get { return docString_; } + set { + docString_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "graph" field. + public const int GraphFieldNumber = 7; + private global::Onnx.GraphProto graph_; + /// + /// The parameterized graph that is evaluated to execute the model. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.GraphProto Graph { + get { return graph_; } + set { + graph_ = value; + } + } + + /// Field number for the "metadata_props" field. + public const int MetadataPropsFieldNumber = 14; + private static readonly pb::FieldCodec _repeated_metadataProps_codec + = pb::FieldCodec.ForMessage(114, global::Onnx.StringStringEntryProto.Parser); + private readonly pbc::RepeatedField metadataProps_ = new pbc::RepeatedField(); + /// + /// Named metadata values; keys should be distinct. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField MetadataProps { + get { return metadataProps_; } + } + + /// Field number for the "training_info" field. + public const int TrainingInfoFieldNumber = 20; + private static readonly pb::FieldCodec _repeated_trainingInfo_codec + = pb::FieldCodec.ForMessage(162, global::Onnx.TrainingInfoProto.Parser); + private readonly pbc::RepeatedField trainingInfo_ = new pbc::RepeatedField(); + /// + /// Training-specific information. Sequentially executing all stored + /// `TrainingInfoProto.algorithm`s and assigning their outputs following + /// the corresponding `TrainingInfoProto.update_binding`s is one training + /// iteration. Similarly, to initialize the model + /// (as if training hasn't happened), the user should sequentially execute + /// all stored `TrainingInfoProto.initialization`s and assigns their outputs + /// using `TrainingInfoProto.initialization_binding`s. + /// + /// If this field is empty, the training behavior of the model is undefined. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField TrainingInfo { + get { return trainingInfo_; } + } + + /// Field number for the "functions" field. + public const int FunctionsFieldNumber = 25; + private static readonly pb::FieldCodec _repeated_functions_codec + = pb::FieldCodec.ForMessage(202, global::Onnx.FunctionProto.Parser); + private readonly pbc::RepeatedField functions_ = new pbc::RepeatedField(); + /// + /// A list of function protos local to the model. + /// + /// Name of the function "FunctionProto.name" should be unique within the domain "FunctionProto.domain". + /// In case of any conflicts the behavior (whether the model local functions are given higher priority, + /// or standard opserator sets are given higher priotity or this is treated as error) is defined by + /// the runtimes. + /// + /// The operator sets imported by FunctionProto should be compatible with the ones + /// imported by ModelProto and other model local FunctionProtos. + /// Example, if same operator set say 'A' is imported by a FunctionProto and ModelProto + /// or by 2 FunctionProtos then versions for the operator set may be different but, + /// the operator schema returned for op_type, domain, version combination + /// for both the versions should be same for every node in the function body. + /// + /// One FunctionProto can reference other FunctionProto in the model, however, recursive reference + /// is not allowed. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Functions { + get { return functions_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ModelProto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ModelProto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (IrVersion != other.IrVersion) return false; + if(!opsetImport_.Equals(other.opsetImport_)) return false; + if (ProducerName != other.ProducerName) return false; + if (ProducerVersion != other.ProducerVersion) return false; + if (Domain != other.Domain) return false; + if (ModelVersion != other.ModelVersion) return false; + if (DocString != other.DocString) return false; + if (!object.Equals(Graph, other.Graph)) return false; + if(!metadataProps_.Equals(other.metadataProps_)) return false; + if(!trainingInfo_.Equals(other.trainingInfo_)) return false; + if(!functions_.Equals(other.functions_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (IrVersion != 0L) hash ^= IrVersion.GetHashCode(); + hash ^= opsetImport_.GetHashCode(); + if (ProducerName.Length != 0) hash ^= ProducerName.GetHashCode(); + if (ProducerVersion.Length != 0) hash ^= ProducerVersion.GetHashCode(); + if (Domain.Length != 0) hash ^= Domain.GetHashCode(); + if (ModelVersion != 0L) hash ^= ModelVersion.GetHashCode(); + if (DocString.Length != 0) hash ^= DocString.GetHashCode(); + if (graph_ != null) hash ^= Graph.GetHashCode(); + hash ^= metadataProps_.GetHashCode(); + hash ^= trainingInfo_.GetHashCode(); + hash ^= functions_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (IrVersion != 0L) { + output.WriteRawTag(8); + output.WriteInt64(IrVersion); + } + if (ProducerName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(ProducerName); + } + if (ProducerVersion.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ProducerVersion); + } + if (Domain.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Domain); + } + if (ModelVersion != 0L) { + output.WriteRawTag(40); + output.WriteInt64(ModelVersion); + } + if (DocString.Length != 0) { + output.WriteRawTag(50); + output.WriteString(DocString); + } + if (graph_ != null) { + output.WriteRawTag(58); + output.WriteMessage(Graph); + } + opsetImport_.WriteTo(output, _repeated_opsetImport_codec); + metadataProps_.WriteTo(output, _repeated_metadataProps_codec); + trainingInfo_.WriteTo(output, _repeated_trainingInfo_codec); + functions_.WriteTo(output, _repeated_functions_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (IrVersion != 0L) { + output.WriteRawTag(8); + output.WriteInt64(IrVersion); + } + if (ProducerName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(ProducerName); + } + if (ProducerVersion.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ProducerVersion); + } + if (Domain.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Domain); + } + if (ModelVersion != 0L) { + output.WriteRawTag(40); + output.WriteInt64(ModelVersion); + } + if (DocString.Length != 0) { + output.WriteRawTag(50); + output.WriteString(DocString); + } + if (graph_ != null) { + output.WriteRawTag(58); + output.WriteMessage(Graph); + } + opsetImport_.WriteTo(ref output, _repeated_opsetImport_codec); + metadataProps_.WriteTo(ref output, _repeated_metadataProps_codec); + trainingInfo_.WriteTo(ref output, _repeated_trainingInfo_codec); + functions_.WriteTo(ref output, _repeated_functions_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (IrVersion != 0L) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(IrVersion); + } + size += opsetImport_.CalculateSize(_repeated_opsetImport_codec); + if (ProducerName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ProducerName); + } + if (ProducerVersion.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ProducerVersion); + } + if (Domain.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Domain); + } + if (ModelVersion != 0L) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(ModelVersion); + } + if (DocString.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DocString); + } + if (graph_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Graph); + } + size += metadataProps_.CalculateSize(_repeated_metadataProps_codec); + size += trainingInfo_.CalculateSize(_repeated_trainingInfo_codec); + size += functions_.CalculateSize(_repeated_functions_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ModelProto other) { + if (other == null) { + return; + } + if (other.IrVersion != 0L) { + IrVersion = other.IrVersion; + } + opsetImport_.Add(other.opsetImport_); + if (other.ProducerName.Length != 0) { + ProducerName = other.ProducerName; + } + if (other.ProducerVersion.Length != 0) { + ProducerVersion = other.ProducerVersion; + } + if (other.Domain.Length != 0) { + Domain = other.Domain; + } + if (other.ModelVersion != 0L) { + ModelVersion = other.ModelVersion; + } + if (other.DocString.Length != 0) { + DocString = other.DocString; + } + if (other.graph_ != null) { + if (graph_ == null) { + Graph = new global::Onnx.GraphProto(); + } + Graph.MergeFrom(other.Graph); + } + metadataProps_.Add(other.metadataProps_); + trainingInfo_.Add(other.trainingInfo_); + functions_.Add(other.functions_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + IrVersion = input.ReadInt64(); + break; + } + case 18: { + ProducerName = input.ReadString(); + break; + } + case 26: { + ProducerVersion = input.ReadString(); + break; + } + case 34: { + Domain = input.ReadString(); + break; + } + case 40: { + ModelVersion = input.ReadInt64(); + break; + } + case 50: { + DocString = input.ReadString(); + break; + } + case 58: { + if (graph_ == null) { + Graph = new global::Onnx.GraphProto(); + } + input.ReadMessage(Graph); + break; + } + case 66: { + opsetImport_.AddEntriesFrom(input, _repeated_opsetImport_codec); + break; + } + case 114: { + metadataProps_.AddEntriesFrom(input, _repeated_metadataProps_codec); + break; + } + case 162: { + trainingInfo_.AddEntriesFrom(input, _repeated_trainingInfo_codec); + break; + } + case 202: { + functions_.AddEntriesFrom(input, _repeated_functions_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + IrVersion = input.ReadInt64(); + break; + } + case 18: { + ProducerName = input.ReadString(); + break; + } + case 26: { + ProducerVersion = input.ReadString(); + break; + } + case 34: { + Domain = input.ReadString(); + break; + } + case 40: { + ModelVersion = input.ReadInt64(); + break; + } + case 50: { + DocString = input.ReadString(); + break; + } + case 58: { + if (graph_ == null) { + Graph = new global::Onnx.GraphProto(); + } + input.ReadMessage(Graph); + break; + } + case 66: { + opsetImport_.AddEntriesFrom(ref input, _repeated_opsetImport_codec); + break; + } + case 114: { + metadataProps_.AddEntriesFrom(ref input, _repeated_metadataProps_codec); + break; + } + case 162: { + trainingInfo_.AddEntriesFrom(ref input, _repeated_trainingInfo_codec); + break; + } + case 202: { + functions_.AddEntriesFrom(ref input, _repeated_functions_codec); + break; + } + } + } + } + #endif + + } + + /// + /// StringStringEntryProto follows the pattern for cross-proto-version maps. + /// See https://developers.google.com/protocol-buffers/docs/proto3#maps + /// + public sealed partial class StringStringEntryProto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new StringStringEntryProto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.OnnxReflection.Descriptor.MessageTypes[5]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StringStringEntryProto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StringStringEntryProto(StringStringEntryProto other) : this() { + key_ = other.key_; + value_ = other.value_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StringStringEntryProto Clone() { + return new StringStringEntryProto(this); + } + + /// Field number for the "key" field. + public const int KeyFieldNumber = 1; + private string key_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Key { + get { return key_; } + set { + key_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "value" field. + public const int ValueFieldNumber = 2; + private string value_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Value { + get { return value_; } + set { + value_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as StringStringEntryProto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(StringStringEntryProto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Key.Length != 0) hash ^= Key.GetHashCode(); + if (Value.Length != 0) hash ^= Value.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Key.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Key); + } + if (Value.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Value); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Key.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Key); + } + if (Value.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Value); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Key.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Key); + } + if (Value.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Value); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(StringStringEntryProto other) { + if (other == null) { + return; + } + if (other.Key.Length != 0) { + Key = other.Key; + } + if (other.Value.Length != 0) { + Value = other.Value; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Key = input.ReadString(); + break; + } + case 18: { + Value = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Key = input.ReadString(); + break; + } + case 18: { + Value = input.ReadString(); + break; + } + } + } + } + #endif + + } + + public sealed partial class TensorAnnotation : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TensorAnnotation()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.OnnxReflection.Descriptor.MessageTypes[6]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TensorAnnotation() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TensorAnnotation(TensorAnnotation other) : this() { + tensorName_ = other.tensorName_; + quantParameterTensorNames_ = other.quantParameterTensorNames_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TensorAnnotation Clone() { + return new TensorAnnotation(this); + } + + /// Field number for the "tensor_name" field. + public const int TensorNameFieldNumber = 1; + private string tensorName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string TensorName { + get { return tensorName_; } + set { + tensorName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "quant_parameter_tensor_names" field. + public const int QuantParameterTensorNamesFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_quantParameterTensorNames_codec + = pb::FieldCodec.ForMessage(18, global::Onnx.StringStringEntryProto.Parser); + private readonly pbc::RepeatedField quantParameterTensorNames_ = new pbc::RepeatedField(); + /// + /// <key, value> pairs to annotate tensor specified by <tensor_name> above. + /// The keys used in the mapping below must be pre-defined in ONNX spec. + /// For example, for 8-bit linear quantization case, 'SCALE_TENSOR', 'ZERO_POINT_TENSOR' will be pre-defined as + /// quantization parameter keys. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField QuantParameterTensorNames { + get { return quantParameterTensorNames_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TensorAnnotation); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TensorAnnotation other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (TensorName != other.TensorName) return false; + if(!quantParameterTensorNames_.Equals(other.quantParameterTensorNames_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (TensorName.Length != 0) hash ^= TensorName.GetHashCode(); + hash ^= quantParameterTensorNames_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (TensorName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(TensorName); + } + quantParameterTensorNames_.WriteTo(output, _repeated_quantParameterTensorNames_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (TensorName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(TensorName); + } + quantParameterTensorNames_.WriteTo(ref output, _repeated_quantParameterTensorNames_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (TensorName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TensorName); + } + size += quantParameterTensorNames_.CalculateSize(_repeated_quantParameterTensorNames_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TensorAnnotation other) { + if (other == null) { + return; + } + if (other.TensorName.Length != 0) { + TensorName = other.TensorName; + } + quantParameterTensorNames_.Add(other.quantParameterTensorNames_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + TensorName = input.ReadString(); + break; + } + case 18: { + quantParameterTensorNames_.AddEntriesFrom(input, _repeated_quantParameterTensorNames_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + TensorName = input.ReadString(); + break; + } + case 18: { + quantParameterTensorNames_.AddEntriesFrom(ref input, _repeated_quantParameterTensorNames_codec); + break; + } + } + } + } + #endif + + } + + /// + /// Graphs + /// + /// A graph defines the computational logic of a model and is comprised of a parameterized + /// list of nodes that form a directed acyclic graph based on their inputs and outputs. + /// This is the equivalent of the "network" or "graph" in many deep learning + /// frameworks. + /// + public sealed partial class GraphProto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GraphProto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.OnnxReflection.Descriptor.MessageTypes[7]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GraphProto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GraphProto(GraphProto other) : this() { + node_ = other.node_.Clone(); + name_ = other.name_; + initializer_ = other.initializer_.Clone(); + sparseInitializer_ = other.sparseInitializer_.Clone(); + docString_ = other.docString_; + input_ = other.input_.Clone(); + output_ = other.output_.Clone(); + valueInfo_ = other.valueInfo_.Clone(); + quantizationAnnotation_ = other.quantizationAnnotation_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GraphProto Clone() { + return new GraphProto(this); + } + + /// Field number for the "node" field. + public const int NodeFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_node_codec + = pb::FieldCodec.ForMessage(10, global::Onnx.NodeProto.Parser); + private readonly pbc::RepeatedField node_ = new pbc::RepeatedField(); + /// + /// The nodes in the graph, sorted topologically. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Node { + get { return node_; } + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 2; + private string name_ = ""; + /// + /// The name of the graph. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "initializer" field. + public const int InitializerFieldNumber = 5; + private static readonly pb::FieldCodec _repeated_initializer_codec + = pb::FieldCodec.ForMessage(42, global::Onnx.TensorProto.Parser); + private readonly pbc::RepeatedField initializer_ = new pbc::RepeatedField(); + /// + /// A list of named tensor values, used to specify constant inputs of the graph. + /// Each initializer (both TensorProto as well SparseTensorProto) MUST have a name. + /// The name MUST be unique across both initializer and sparse_initializer, + /// but the name MAY also appear in the input list. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Initializer { + get { return initializer_; } + } + + /// Field number for the "sparse_initializer" field. + public const int SparseInitializerFieldNumber = 15; + private static readonly pb::FieldCodec _repeated_sparseInitializer_codec + = pb::FieldCodec.ForMessage(122, global::Onnx.SparseTensorProto.Parser); + private readonly pbc::RepeatedField sparseInitializer_ = new pbc::RepeatedField(); + /// + /// Initializers (see above) stored in sparse format. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField SparseInitializer { + get { return sparseInitializer_; } + } + + /// Field number for the "doc_string" field. + public const int DocStringFieldNumber = 10; + private string docString_ = ""; + /// + /// A human-readable documentation for this graph. Markdown is allowed. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DocString { + get { return docString_; } + set { + docString_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "input" field. + public const int InputFieldNumber = 11; + private static readonly pb::FieldCodec _repeated_input_codec + = pb::FieldCodec.ForMessage(90, global::Onnx.ValueInfoProto.Parser); + private readonly pbc::RepeatedField input_ = new pbc::RepeatedField(); + /// + /// The inputs and outputs of the graph. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Input { + get { return input_; } + } + + /// Field number for the "output" field. + public const int OutputFieldNumber = 12; + private static readonly pb::FieldCodec _repeated_output_codec + = pb::FieldCodec.ForMessage(98, global::Onnx.ValueInfoProto.Parser); + private readonly pbc::RepeatedField output_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Output { + get { return output_; } + } + + /// Field number for the "value_info" field. + public const int ValueInfoFieldNumber = 13; + private static readonly pb::FieldCodec _repeated_valueInfo_codec + = pb::FieldCodec.ForMessage(106, global::Onnx.ValueInfoProto.Parser); + private readonly pbc::RepeatedField valueInfo_ = new pbc::RepeatedField(); + /// + /// Information for the values in the graph. The ValueInfoProto.name's + /// must be distinct. It is optional for a value to appear in value_info list. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField ValueInfo { + get { return valueInfo_; } + } + + /// Field number for the "quantization_annotation" field. + public const int QuantizationAnnotationFieldNumber = 14; + private static readonly pb::FieldCodec _repeated_quantizationAnnotation_codec + = pb::FieldCodec.ForMessage(114, global::Onnx.TensorAnnotation.Parser); + private readonly pbc::RepeatedField quantizationAnnotation_ = new pbc::RepeatedField(); + /// + /// This field carries information to indicate the mapping among a tensor and its + /// quantization parameter tensors. For example: + /// For tensor 'a', it may have {'SCALE_TENSOR', 'a_scale'} and {'ZERO_POINT_TENSOR', 'a_zero_point'} annotated, + /// which means, tensor 'a_scale' and tensor 'a_zero_point' are scale and zero point of tensor 'a' in the model. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField QuantizationAnnotation { + get { return quantizationAnnotation_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as GraphProto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(GraphProto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!node_.Equals(other.node_)) return false; + if (Name != other.Name) return false; + if(!initializer_.Equals(other.initializer_)) return false; + if(!sparseInitializer_.Equals(other.sparseInitializer_)) return false; + if (DocString != other.DocString) return false; + if(!input_.Equals(other.input_)) return false; + if(!output_.Equals(other.output_)) return false; + if(!valueInfo_.Equals(other.valueInfo_)) return false; + if(!quantizationAnnotation_.Equals(other.quantizationAnnotation_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= node_.GetHashCode(); + if (Name.Length != 0) hash ^= Name.GetHashCode(); + hash ^= initializer_.GetHashCode(); + hash ^= sparseInitializer_.GetHashCode(); + if (DocString.Length != 0) hash ^= DocString.GetHashCode(); + hash ^= input_.GetHashCode(); + hash ^= output_.GetHashCode(); + hash ^= valueInfo_.GetHashCode(); + hash ^= quantizationAnnotation_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + node_.WriteTo(output, _repeated_node_codec); + if (Name.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Name); + } + initializer_.WriteTo(output, _repeated_initializer_codec); + if (DocString.Length != 0) { + output.WriteRawTag(82); + output.WriteString(DocString); + } + input_.WriteTo(output, _repeated_input_codec); + output_.WriteTo(output, _repeated_output_codec); + valueInfo_.WriteTo(output, _repeated_valueInfo_codec); + quantizationAnnotation_.WriteTo(output, _repeated_quantizationAnnotation_codec); + sparseInitializer_.WriteTo(output, _repeated_sparseInitializer_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + node_.WriteTo(ref output, _repeated_node_codec); + if (Name.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Name); + } + initializer_.WriteTo(ref output, _repeated_initializer_codec); + if (DocString.Length != 0) { + output.WriteRawTag(82); + output.WriteString(DocString); + } + input_.WriteTo(ref output, _repeated_input_codec); + output_.WriteTo(ref output, _repeated_output_codec); + valueInfo_.WriteTo(ref output, _repeated_valueInfo_codec); + quantizationAnnotation_.WriteTo(ref output, _repeated_quantizationAnnotation_codec); + sparseInitializer_.WriteTo(ref output, _repeated_sparseInitializer_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += node_.CalculateSize(_repeated_node_codec); + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + size += initializer_.CalculateSize(_repeated_initializer_codec); + size += sparseInitializer_.CalculateSize(_repeated_sparseInitializer_codec); + if (DocString.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DocString); + } + size += input_.CalculateSize(_repeated_input_codec); + size += output_.CalculateSize(_repeated_output_codec); + size += valueInfo_.CalculateSize(_repeated_valueInfo_codec); + size += quantizationAnnotation_.CalculateSize(_repeated_quantizationAnnotation_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(GraphProto other) { + if (other == null) { + return; + } + node_.Add(other.node_); + if (other.Name.Length != 0) { + Name = other.Name; + } + initializer_.Add(other.initializer_); + sparseInitializer_.Add(other.sparseInitializer_); + if (other.DocString.Length != 0) { + DocString = other.DocString; + } + input_.Add(other.input_); + output_.Add(other.output_); + valueInfo_.Add(other.valueInfo_); + quantizationAnnotation_.Add(other.quantizationAnnotation_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + node_.AddEntriesFrom(input, _repeated_node_codec); + break; + } + case 18: { + Name = input.ReadString(); + break; + } + case 42: { + initializer_.AddEntriesFrom(input, _repeated_initializer_codec); + break; + } + case 82: { + DocString = input.ReadString(); + break; + } + case 90: { + input_.AddEntriesFrom(input, _repeated_input_codec); + break; + } + case 98: { + output_.AddEntriesFrom(input, _repeated_output_codec); + break; + } + case 106: { + valueInfo_.AddEntriesFrom(input, _repeated_valueInfo_codec); + break; + } + case 114: { + quantizationAnnotation_.AddEntriesFrom(input, _repeated_quantizationAnnotation_codec); + break; + } + case 122: { + sparseInitializer_.AddEntriesFrom(input, _repeated_sparseInitializer_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + node_.AddEntriesFrom(ref input, _repeated_node_codec); + break; + } + case 18: { + Name = input.ReadString(); + break; + } + case 42: { + initializer_.AddEntriesFrom(ref input, _repeated_initializer_codec); + break; + } + case 82: { + DocString = input.ReadString(); + break; + } + case 90: { + input_.AddEntriesFrom(ref input, _repeated_input_codec); + break; + } + case 98: { + output_.AddEntriesFrom(ref input, _repeated_output_codec); + break; + } + case 106: { + valueInfo_.AddEntriesFrom(ref input, _repeated_valueInfo_codec); + break; + } + case 114: { + quantizationAnnotation_.AddEntriesFrom(ref input, _repeated_quantizationAnnotation_codec); + break; + } + case 122: { + sparseInitializer_.AddEntriesFrom(ref input, _repeated_sparseInitializer_codec); + break; + } + } + } + } + #endif + + } + + /// + /// Tensors + /// + /// A serialized tensor value. + /// + public sealed partial class TensorProto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TensorProto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.OnnxReflection.Descriptor.MessageTypes[8]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TensorProto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TensorProto(TensorProto other) : this() { + dims_ = other.dims_.Clone(); + dataType_ = other.dataType_; + segment_ = other.segment_ != null ? other.segment_.Clone() : null; + floatData_ = other.floatData_.Clone(); + int32Data_ = other.int32Data_.Clone(); + stringData_ = other.stringData_.Clone(); + int64Data_ = other.int64Data_.Clone(); + name_ = other.name_; + docString_ = other.docString_; + rawData_ = other.rawData_; + externalData_ = other.externalData_.Clone(); + dataLocation_ = other.dataLocation_; + doubleData_ = other.doubleData_.Clone(); + uint64Data_ = other.uint64Data_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TensorProto Clone() { + return new TensorProto(this); + } + + /// Field number for the "dims" field. + public const int DimsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_dims_codec + = pb::FieldCodec.ForInt64(10); + private readonly pbc::RepeatedField dims_ = new pbc::RepeatedField(); + /// + /// The shape of the tensor. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Dims { + get { return dims_; } + } + + /// Field number for the "data_type" field. + public const int DataTypeFieldNumber = 2; + private int dataType_; + /// + /// The data type of the tensor. + /// This field MUST have a valid TensorProto.DataType value + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int DataType { + get { return dataType_; } + set { + dataType_ = value; + } + } + + /// Field number for the "segment" field. + public const int SegmentFieldNumber = 3; + private global::Onnx.TensorProto.Types.Segment segment_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TensorProto.Types.Segment Segment { + get { return segment_; } + set { + segment_ = value; + } + } + + /// Field number for the "float_data" field. + public const int FloatDataFieldNumber = 4; + private static readonly pb::FieldCodec _repeated_floatData_codec + = pb::FieldCodec.ForFloat(34); + private readonly pbc::RepeatedField floatData_ = new pbc::RepeatedField(); + /// + /// For float and complex64 values + /// Complex64 tensors are encoded as a single array of floats, + /// with the real components appearing in odd numbered positions, + /// and the corresponding imaginary component appearing in the + /// subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i] + /// is encoded as [1.0, 2.0 ,3.0 ,4.0] + /// When this field is present, the data_type field MUST be FLOAT or COMPLEX64. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField FloatData { + get { return floatData_; } + } + + /// Field number for the "int32_data" field. + public const int Int32DataFieldNumber = 5; + private static readonly pb::FieldCodec _repeated_int32Data_codec + = pb::FieldCodec.ForInt32(42); + private readonly pbc::RepeatedField int32Data_ = new pbc::RepeatedField(); + /// + /// For int32, uint8, int8, uint16, int16, bool, float8, and float16 values + /// float16 and float8 values must be bit-wise converted to an uint16_t prior + /// to writing to the buffer. + /// When this field is present, the data_type field MUST be + /// INT32, INT16, INT8, UINT16, UINT8, BOOL, FLOAT16, BFLOAT16, FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Int32Data { + get { return int32Data_; } + } + + /// Field number for the "string_data" field. + public const int StringDataFieldNumber = 6; + private static readonly pb::FieldCodec _repeated_stringData_codec + = pb::FieldCodec.ForBytes(50); + private readonly pbc::RepeatedField stringData_ = new pbc::RepeatedField(); + /// + /// For strings. + /// Each element of string_data is a UTF-8 encoded Unicode + /// string. No trailing null, no leading BOM. The protobuf "string" + /// scalar type is not used to match ML community conventions. + /// When this field is present, the data_type field MUST be STRING + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField StringData { + get { return stringData_; } + } + + /// Field number for the "int64_data" field. + public const int Int64DataFieldNumber = 7; + private static readonly pb::FieldCodec _repeated_int64Data_codec + = pb::FieldCodec.ForInt64(58); + private readonly pbc::RepeatedField int64Data_ = new pbc::RepeatedField(); + /// + /// For int64. + /// When this field is present, the data_type field MUST be INT64 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Int64Data { + get { return int64Data_; } + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 8; + private string name_ = ""; + /// + /// Optionally, a name for the tensor. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "doc_string" field. + public const int DocStringFieldNumber = 12; + private string docString_ = ""; + /// + /// A human-readable documentation for this tensor. Markdown is allowed. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DocString { + get { return docString_; } + set { + docString_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "raw_data" field. + public const int RawDataFieldNumber = 9; + private pb::ByteString rawData_ = pb::ByteString.Empty; + /// + /// Serializations can either use one of the fields above, or use this + /// raw bytes field. The only exception is the string case, where one is + /// required to store the content in the repeated bytes string_data field. + /// + /// When this raw_data field is used to store tensor value, elements MUST + /// be stored in as fixed-width, little-endian order. + /// Floating-point data types MUST be stored in IEEE 754 format. + /// Complex64 elements must be written as two consecutive FLOAT values, real component first. + /// Complex128 elements must be written as two consecutive DOUBLE values, real component first. + /// Boolean type MUST be written one byte per tensor element (00000001 for true, 00000000 for false). + /// + /// Note: the advantage of specific field rather than the raw_data field is + /// that in some cases (e.g. int data), protobuf does a better packing via + /// variable length storage, and may lead to smaller binary footprint. + /// When this field is present, the data_type field MUST NOT be STRING or UNDEFINED + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pb::ByteString RawData { + get { return rawData_; } + set { + rawData_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "external_data" field. + public const int ExternalDataFieldNumber = 13; + private static readonly pb::FieldCodec _repeated_externalData_codec + = pb::FieldCodec.ForMessage(106, global::Onnx.StringStringEntryProto.Parser); + private readonly pbc::RepeatedField externalData_ = new pbc::RepeatedField(); + /// + /// Data can be stored inside the protobuf file using type-specific fields or raw_data. + /// Alternatively, raw bytes data can be stored in an external file, using the external_data field. + /// external_data stores key-value pairs describing data location. Recognized keys are: + /// - "location" (required) - POSIX filesystem path relative to the directory where the ONNX + /// protobuf model was stored + /// - "offset" (optional) - position of byte at which stored data begins. Integer stored as string. + /// Offset values SHOULD be multiples 4096 (page size) to enable mmap support. + /// - "length" (optional) - number of bytes containing data. Integer stored as string. + /// - "checksum" (optional) - SHA1 digest of file specified in under 'location' key. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField ExternalData { + get { return externalData_; } + } + + /// Field number for the "data_location" field. + public const int DataLocationFieldNumber = 14; + private global::Onnx.TensorProto.Types.DataLocation dataLocation_ = global::Onnx.TensorProto.Types.DataLocation.Default; + /// + /// If value not set, data is stored in raw_data (if set) otherwise in type-specified field. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TensorProto.Types.DataLocation DataLocation { + get { return dataLocation_; } + set { + dataLocation_ = value; + } + } + + /// Field number for the "double_data" field. + public const int DoubleDataFieldNumber = 10; + private static readonly pb::FieldCodec _repeated_doubleData_codec + = pb::FieldCodec.ForDouble(82); + private readonly pbc::RepeatedField doubleData_ = new pbc::RepeatedField(); + /// + /// For double + /// Complex128 tensors are encoded as a single array of doubles, + /// with the real components appearing in odd numbered positions, + /// and the corresponding imaginary component appearing in the + /// subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i] + /// is encoded as [1.0, 2.0 ,3.0 ,4.0] + /// When this field is present, the data_type field MUST be DOUBLE or COMPLEX128 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField DoubleData { + get { return doubleData_; } + } + + /// Field number for the "uint64_data" field. + public const int Uint64DataFieldNumber = 11; + private static readonly pb::FieldCodec _repeated_uint64Data_codec + = pb::FieldCodec.ForUInt64(90); + private readonly pbc::RepeatedField uint64Data_ = new pbc::RepeatedField(); + /// + /// For uint64 and uint32 values + /// When this field is present, the data_type field MUST be + /// UINT32 or UINT64 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Uint64Data { + get { return uint64Data_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TensorProto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TensorProto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!dims_.Equals(other.dims_)) return false; + if (DataType != other.DataType) return false; + if (!object.Equals(Segment, other.Segment)) return false; + if(!floatData_.Equals(other.floatData_)) return false; + if(!int32Data_.Equals(other.int32Data_)) return false; + if(!stringData_.Equals(other.stringData_)) return false; + if(!int64Data_.Equals(other.int64Data_)) return false; + if (Name != other.Name) return false; + if (DocString != other.DocString) return false; + if (RawData != other.RawData) return false; + if(!externalData_.Equals(other.externalData_)) return false; + if (DataLocation != other.DataLocation) return false; + if(!doubleData_.Equals(other.doubleData_)) return false; + if(!uint64Data_.Equals(other.uint64Data_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= dims_.GetHashCode(); + if (DataType != 0) hash ^= DataType.GetHashCode(); + if (segment_ != null) hash ^= Segment.GetHashCode(); + hash ^= floatData_.GetHashCode(); + hash ^= int32Data_.GetHashCode(); + hash ^= stringData_.GetHashCode(); + hash ^= int64Data_.GetHashCode(); + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (DocString.Length != 0) hash ^= DocString.GetHashCode(); + if (RawData.Length != 0) hash ^= RawData.GetHashCode(); + hash ^= externalData_.GetHashCode(); + if (DataLocation != global::Onnx.TensorProto.Types.DataLocation.Default) hash ^= DataLocation.GetHashCode(); + hash ^= doubleData_.GetHashCode(); + hash ^= uint64Data_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + dims_.WriteTo(output, _repeated_dims_codec); + if (DataType != 0) { + output.WriteRawTag(16); + output.WriteInt32(DataType); + } + if (segment_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Segment); + } + floatData_.WriteTo(output, _repeated_floatData_codec); + int32Data_.WriteTo(output, _repeated_int32Data_codec); + stringData_.WriteTo(output, _repeated_stringData_codec); + int64Data_.WriteTo(output, _repeated_int64Data_codec); + if (Name.Length != 0) { + output.WriteRawTag(66); + output.WriteString(Name); + } + if (RawData.Length != 0) { + output.WriteRawTag(74); + output.WriteBytes(RawData); + } + doubleData_.WriteTo(output, _repeated_doubleData_codec); + uint64Data_.WriteTo(output, _repeated_uint64Data_codec); + if (DocString.Length != 0) { + output.WriteRawTag(98); + output.WriteString(DocString); + } + externalData_.WriteTo(output, _repeated_externalData_codec); + if (DataLocation != global::Onnx.TensorProto.Types.DataLocation.Default) { + output.WriteRawTag(112); + output.WriteEnum((int) DataLocation); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + dims_.WriteTo(ref output, _repeated_dims_codec); + if (DataType != 0) { + output.WriteRawTag(16); + output.WriteInt32(DataType); + } + if (segment_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Segment); + } + floatData_.WriteTo(ref output, _repeated_floatData_codec); + int32Data_.WriteTo(ref output, _repeated_int32Data_codec); + stringData_.WriteTo(ref output, _repeated_stringData_codec); + int64Data_.WriteTo(ref output, _repeated_int64Data_codec); + if (Name.Length != 0) { + output.WriteRawTag(66); + output.WriteString(Name); + } + if (RawData.Length != 0) { + output.WriteRawTag(74); + output.WriteBytes(RawData); + } + doubleData_.WriteTo(ref output, _repeated_doubleData_codec); + uint64Data_.WriteTo(ref output, _repeated_uint64Data_codec); + if (DocString.Length != 0) { + output.WriteRawTag(98); + output.WriteString(DocString); + } + externalData_.WriteTo(ref output, _repeated_externalData_codec); + if (DataLocation != global::Onnx.TensorProto.Types.DataLocation.Default) { + output.WriteRawTag(112); + output.WriteEnum((int) DataLocation); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += dims_.CalculateSize(_repeated_dims_codec); + if (DataType != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(DataType); + } + if (segment_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Segment); + } + size += floatData_.CalculateSize(_repeated_floatData_codec); + size += int32Data_.CalculateSize(_repeated_int32Data_codec); + size += stringData_.CalculateSize(_repeated_stringData_codec); + size += int64Data_.CalculateSize(_repeated_int64Data_codec); + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (DocString.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DocString); + } + if (RawData.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(RawData); + } + size += externalData_.CalculateSize(_repeated_externalData_codec); + if (DataLocation != global::Onnx.TensorProto.Types.DataLocation.Default) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) DataLocation); + } + size += doubleData_.CalculateSize(_repeated_doubleData_codec); + size += uint64Data_.CalculateSize(_repeated_uint64Data_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TensorProto other) { + if (other == null) { + return; + } + dims_.Add(other.dims_); + if (other.DataType != 0) { + DataType = other.DataType; + } + if (other.segment_ != null) { + if (segment_ == null) { + Segment = new global::Onnx.TensorProto.Types.Segment(); + } + Segment.MergeFrom(other.Segment); + } + floatData_.Add(other.floatData_); + int32Data_.Add(other.int32Data_); + stringData_.Add(other.stringData_); + int64Data_.Add(other.int64Data_); + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.DocString.Length != 0) { + DocString = other.DocString; + } + if (other.RawData.Length != 0) { + RawData = other.RawData; + } + externalData_.Add(other.externalData_); + if (other.DataLocation != global::Onnx.TensorProto.Types.DataLocation.Default) { + DataLocation = other.DataLocation; + } + doubleData_.Add(other.doubleData_); + uint64Data_.Add(other.uint64Data_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: + case 8: { + dims_.AddEntriesFrom(input, _repeated_dims_codec); + break; + } + case 16: { + DataType = input.ReadInt32(); + break; + } + case 26: { + if (segment_ == null) { + Segment = new global::Onnx.TensorProto.Types.Segment(); + } + input.ReadMessage(Segment); + break; + } + case 34: + case 37: { + floatData_.AddEntriesFrom(input, _repeated_floatData_codec); + break; + } + case 42: + case 40: { + int32Data_.AddEntriesFrom(input, _repeated_int32Data_codec); + break; + } + case 50: { + stringData_.AddEntriesFrom(input, _repeated_stringData_codec); + break; + } + case 58: + case 56: { + int64Data_.AddEntriesFrom(input, _repeated_int64Data_codec); + break; + } + case 66: { + Name = input.ReadString(); + break; + } + case 74: { + RawData = input.ReadBytes(); + break; + } + case 82: + case 81: { + doubleData_.AddEntriesFrom(input, _repeated_doubleData_codec); + break; + } + case 90: + case 88: { + uint64Data_.AddEntriesFrom(input, _repeated_uint64Data_codec); + break; + } + case 98: { + DocString = input.ReadString(); + break; + } + case 106: { + externalData_.AddEntriesFrom(input, _repeated_externalData_codec); + break; + } + case 112: { + DataLocation = (global::Onnx.TensorProto.Types.DataLocation) input.ReadEnum(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: + case 8: { + dims_.AddEntriesFrom(ref input, _repeated_dims_codec); + break; + } + case 16: { + DataType = input.ReadInt32(); + break; + } + case 26: { + if (segment_ == null) { + Segment = new global::Onnx.TensorProto.Types.Segment(); + } + input.ReadMessage(Segment); + break; + } + case 34: + case 37: { + floatData_.AddEntriesFrom(ref input, _repeated_floatData_codec); + break; + } + case 42: + case 40: { + int32Data_.AddEntriesFrom(ref input, _repeated_int32Data_codec); + break; + } + case 50: { + stringData_.AddEntriesFrom(ref input, _repeated_stringData_codec); + break; + } + case 58: + case 56: { + int64Data_.AddEntriesFrom(ref input, _repeated_int64Data_codec); + break; + } + case 66: { + Name = input.ReadString(); + break; + } + case 74: { + RawData = input.ReadBytes(); + break; + } + case 82: + case 81: { + doubleData_.AddEntriesFrom(ref input, _repeated_doubleData_codec); + break; + } + case 90: + case 88: { + uint64Data_.AddEntriesFrom(ref input, _repeated_uint64Data_codec); + break; + } + case 98: { + DocString = input.ReadString(); + break; + } + case 106: { + externalData_.AddEntriesFrom(ref input, _repeated_externalData_codec); + break; + } + case 112: { + DataLocation = (global::Onnx.TensorProto.Types.DataLocation) input.ReadEnum(); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the TensorProto message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static partial class Types { + public enum DataType { + [pbr::OriginalName("UNDEFINED")] Undefined = 0, + /// + /// Basic types. + /// + [pbr::OriginalName("FLOAT")] Float = 1, + /// + /// uint8_t + /// + [pbr::OriginalName("UINT8")] Uint8 = 2, + /// + /// int8_t + /// + [pbr::OriginalName("INT8")] Int8 = 3, + /// + /// uint16_t + /// + [pbr::OriginalName("UINT16")] Uint16 = 4, + /// + /// int16_t + /// + [pbr::OriginalName("INT16")] Int16 = 5, + /// + /// int32_t + /// + [pbr::OriginalName("INT32")] Int32 = 6, + /// + /// int64_t + /// + [pbr::OriginalName("INT64")] Int64 = 7, + /// + /// string + /// + [pbr::OriginalName("STRING")] String = 8, + /// + /// bool + /// + [pbr::OriginalName("BOOL")] Bool = 9, + /// + /// IEEE754 half-precision floating-point format (16 bits wide). + /// This format has 1 sign bit, 5 exponent bits, and 10 mantissa bits. + /// + [pbr::OriginalName("FLOAT16")] Float16 = 10, + [pbr::OriginalName("DOUBLE")] Double = 11, + [pbr::OriginalName("UINT32")] Uint32 = 12, + [pbr::OriginalName("UINT64")] Uint64 = 13, + /// + /// complex with float32 real and imaginary components + /// + [pbr::OriginalName("COMPLEX64")] Complex64 = 14, + /// + /// complex with float64 real and imaginary components + /// + [pbr::OriginalName("COMPLEX128")] Complex128 = 15, + /// + /// Non-IEEE floating-point format based on IEEE754 single-precision + /// floating-point number truncated to 16 bits. + /// This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits. + /// + [pbr::OriginalName("BFLOAT16")] Bfloat16 = 16, + /// + /// Non-IEEE floating-point format based on papers + /// FP8 Formats for Deep Learning, https://arxiv.org/abs/2209.05433, + /// 8-bit Numerical Formats For Deep Neural Networks, https://arxiv.org/pdf/2206.02915.pdf. + /// Operators supported FP8 are Cast, CastLike, QuantizeLinear, DequantizeLinear. + /// The computation usually happens inside a block quantize / dequantize + /// fused by the runtime. + /// + [pbr::OriginalName("FLOAT8E4M3FN")] Float8E4M3Fn = 17, + /// + /// float 8, mostly used for coefficients, supports nan, not inf, no negative zero + /// + [pbr::OriginalName("FLOAT8E4M3FNUZ")] Float8E4M3Fnuz = 18, + /// + /// follows IEEE 754, supports nan, inf, mostly used for gradients + /// + [pbr::OriginalName("FLOAT8E5M2")] Float8E5M2 = 19, + /// + /// follows IEEE 754, supports nan, inf, mostly used for gradients, no negative zero + /// + [pbr::OriginalName("FLOAT8E5M2FNUZ")] Float8E5M2Fnuz = 20, + } + + /// + /// Location of the data for this tensor. MUST be one of: + /// - DEFAULT - data stored inside the protobuf message. Data is stored in raw_data (if set) otherwise in type-specified field. + /// - EXTERNAL - data stored in an external location as described by external_data field. + /// + public enum DataLocation { + [pbr::OriginalName("DEFAULT")] Default = 0, + [pbr::OriginalName("EXTERNAL")] External = 1, + } + + /// + /// For very large tensors, we may want to store them in chunks, in which + /// case the following fields will specify the segment that is stored in + /// the current TensorProto. + /// + public sealed partial class Segment : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Segment()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.TensorProto.Descriptor.NestedTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Segment() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Segment(Segment other) : this() { + begin_ = other.begin_; + end_ = other.end_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Segment Clone() { + return new Segment(this); + } + + /// Field number for the "begin" field. + public const int BeginFieldNumber = 1; + private long begin_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public long Begin { + get { return begin_; } + set { + begin_ = value; + } + } + + /// Field number for the "end" field. + public const int EndFieldNumber = 2; + private long end_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public long End { + get { return end_; } + set { + end_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Segment); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Segment other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Begin != other.Begin) return false; + if (End != other.End) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Begin != 0L) hash ^= Begin.GetHashCode(); + if (End != 0L) hash ^= End.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Begin != 0L) { + output.WriteRawTag(8); + output.WriteInt64(Begin); + } + if (End != 0L) { + output.WriteRawTag(16); + output.WriteInt64(End); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Begin != 0L) { + output.WriteRawTag(8); + output.WriteInt64(Begin); + } + if (End != 0L) { + output.WriteRawTag(16); + output.WriteInt64(End); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Begin != 0L) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(Begin); + } + if (End != 0L) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(End); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Segment other) { + if (other == null) { + return; + } + if (other.Begin != 0L) { + Begin = other.Begin; + } + if (other.End != 0L) { + End = other.End; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Begin = input.ReadInt64(); + break; + } + case 16: { + End = input.ReadInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Begin = input.ReadInt64(); + break; + } + case 16: { + End = input.ReadInt64(); + break; + } + } + } + } + #endif + + } + + } + #endregion + + } + + /// + /// A serialized sparse-tensor value + /// + public sealed partial class SparseTensorProto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SparseTensorProto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.OnnxReflection.Descriptor.MessageTypes[9]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SparseTensorProto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SparseTensorProto(SparseTensorProto other) : this() { + values_ = other.values_ != null ? other.values_.Clone() : null; + indices_ = other.indices_ != null ? other.indices_.Clone() : null; + dims_ = other.dims_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SparseTensorProto Clone() { + return new SparseTensorProto(this); + } + + /// Field number for the "values" field. + public const int ValuesFieldNumber = 1; + private global::Onnx.TensorProto values_; + /// + /// The sequence of non-default values are encoded as a tensor of shape [NNZ]. + /// The default-value is zero for numeric tensors, and empty-string for string tensors. + /// values must have a non-empty name present which serves as a name for SparseTensorProto + /// when used in sparse_initializer list. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TensorProto Values { + get { return values_; } + set { + values_ = value; + } + } + + /// Field number for the "indices" field. + public const int IndicesFieldNumber = 2; + private global::Onnx.TensorProto indices_; + /// + /// The indices of the non-default values, which may be stored in one of two formats. + /// (a) Indices can be a tensor of shape [NNZ, rank] with the [i,j]-th value + /// corresponding to the j-th index of the i-th value (in the values tensor). + /// (b) Indices can be a tensor of shape [NNZ], in which case the i-th value + /// must be the linearized-index of the i-th value (in the values tensor). + /// The linearized-index can be converted into an index tuple (k_1,...,k_rank) + /// using the shape provided below. + /// The indices must appear in ascending order without duplication. + /// In the first format, the ordering is lexicographic-ordering: + /// e.g., index-value [1,4] must appear before [2,1] + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TensorProto Indices { + get { return indices_; } + set { + indices_ = value; + } + } + + /// Field number for the "dims" field. + public const int DimsFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_dims_codec + = pb::FieldCodec.ForInt64(26); + private readonly pbc::RepeatedField dims_ = new pbc::RepeatedField(); + /// + /// The shape of the underlying dense-tensor: [dim_1, dim_2, ... dim_rank] + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Dims { + get { return dims_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SparseTensorProto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SparseTensorProto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Values, other.Values)) return false; + if (!object.Equals(Indices, other.Indices)) return false; + if(!dims_.Equals(other.dims_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (values_ != null) hash ^= Values.GetHashCode(); + if (indices_ != null) hash ^= Indices.GetHashCode(); + hash ^= dims_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (values_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Values); + } + if (indices_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Indices); + } + dims_.WriteTo(output, _repeated_dims_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (values_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Values); + } + if (indices_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Indices); + } + dims_.WriteTo(ref output, _repeated_dims_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (values_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Values); + } + if (indices_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Indices); + } + size += dims_.CalculateSize(_repeated_dims_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SparseTensorProto other) { + if (other == null) { + return; + } + if (other.values_ != null) { + if (values_ == null) { + Values = new global::Onnx.TensorProto(); + } + Values.MergeFrom(other.Values); + } + if (other.indices_ != null) { + if (indices_ == null) { + Indices = new global::Onnx.TensorProto(); + } + Indices.MergeFrom(other.Indices); + } + dims_.Add(other.dims_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (values_ == null) { + Values = new global::Onnx.TensorProto(); + } + input.ReadMessage(Values); + break; + } + case 18: { + if (indices_ == null) { + Indices = new global::Onnx.TensorProto(); + } + input.ReadMessage(Indices); + break; + } + case 26: + case 24: { + dims_.AddEntriesFrom(input, _repeated_dims_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (values_ == null) { + Values = new global::Onnx.TensorProto(); + } + input.ReadMessage(Values); + break; + } + case 18: { + if (indices_ == null) { + Indices = new global::Onnx.TensorProto(); + } + input.ReadMessage(Indices); + break; + } + case 26: + case 24: { + dims_.AddEntriesFrom(ref input, _repeated_dims_codec); + break; + } + } + } + } + #endif + + } + + /// + /// Defines a tensor shape. A dimension can be either an integer value + /// or a symbolic variable. A symbolic variable represents an unknown + /// dimension. + /// + public sealed partial class TensorShapeProto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TensorShapeProto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.OnnxReflection.Descriptor.MessageTypes[10]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TensorShapeProto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TensorShapeProto(TensorShapeProto other) : this() { + dim_ = other.dim_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TensorShapeProto Clone() { + return new TensorShapeProto(this); + } + + /// Field number for the "dim" field. + public const int DimFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_dim_codec + = pb::FieldCodec.ForMessage(10, global::Onnx.TensorShapeProto.Types.Dimension.Parser); + private readonly pbc::RepeatedField dim_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Dim { + get { return dim_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TensorShapeProto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TensorShapeProto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!dim_.Equals(other.dim_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= dim_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + dim_.WriteTo(output, _repeated_dim_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + dim_.WriteTo(ref output, _repeated_dim_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += dim_.CalculateSize(_repeated_dim_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TensorShapeProto other) { + if (other == null) { + return; + } + dim_.Add(other.dim_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + dim_.AddEntriesFrom(input, _repeated_dim_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + dim_.AddEntriesFrom(ref input, _repeated_dim_codec); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the TensorShapeProto message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static partial class Types { + public sealed partial class Dimension : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Dimension()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.TensorShapeProto.Descriptor.NestedTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Dimension() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Dimension(Dimension other) : this() { + denotation_ = other.denotation_; + switch (other.ValueCase) { + case ValueOneofCase.DimValue: + DimValue = other.DimValue; + break; + case ValueOneofCase.DimParam: + DimParam = other.DimParam; + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Dimension Clone() { + return new Dimension(this); + } + + /// Field number for the "dim_value" field. + public const int DimValueFieldNumber = 1; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public long DimValue { + get { return valueCase_ == ValueOneofCase.DimValue ? (long) value_ : 0L; } + set { + value_ = value; + valueCase_ = ValueOneofCase.DimValue; + } + } + + /// Field number for the "dim_param" field. + public const int DimParamFieldNumber = 2; + /// + /// namespace Shape + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DimParam { + get { return valueCase_ == ValueOneofCase.DimParam ? (string) value_ : ""; } + set { + value_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + valueCase_ = ValueOneofCase.DimParam; + } + } + + /// Field number for the "denotation" field. + public const int DenotationFieldNumber = 3; + private string denotation_ = ""; + /// + /// Standard denotation can optionally be used to denote tensor + /// dimensions with standard semantic descriptions to ensure + /// that operations are applied to the correct axis of a tensor. + /// Refer to https://github.com/onnx/onnx/blob/main/docs/DimensionDenotation.md#denotation-definition + /// for pre-defined dimension denotations. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Denotation { + get { return denotation_; } + set { + denotation_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + private object value_; + /// Enum of possible cases for the "value" oneof. + public enum ValueOneofCase { + None = 0, + DimValue = 1, + DimParam = 2, + } + private ValueOneofCase valueCase_ = ValueOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ValueOneofCase ValueCase { + get { return valueCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearValue() { + valueCase_ = ValueOneofCase.None; + value_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Dimension); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Dimension other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (DimValue != other.DimValue) return false; + if (DimParam != other.DimParam) return false; + if (Denotation != other.Denotation) return false; + if (ValueCase != other.ValueCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (valueCase_ == ValueOneofCase.DimValue) hash ^= DimValue.GetHashCode(); + if (valueCase_ == ValueOneofCase.DimParam) hash ^= DimParam.GetHashCode(); + if (Denotation.Length != 0) hash ^= Denotation.GetHashCode(); + hash ^= (int) valueCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (valueCase_ == ValueOneofCase.DimValue) { + output.WriteRawTag(8); + output.WriteInt64(DimValue); + } + if (valueCase_ == ValueOneofCase.DimParam) { + output.WriteRawTag(18); + output.WriteString(DimParam); + } + if (Denotation.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Denotation); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (valueCase_ == ValueOneofCase.DimValue) { + output.WriteRawTag(8); + output.WriteInt64(DimValue); + } + if (valueCase_ == ValueOneofCase.DimParam) { + output.WriteRawTag(18); + output.WriteString(DimParam); + } + if (Denotation.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Denotation); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (valueCase_ == ValueOneofCase.DimValue) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(DimValue); + } + if (valueCase_ == ValueOneofCase.DimParam) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DimParam); + } + if (Denotation.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Denotation); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Dimension other) { + if (other == null) { + return; + } + if (other.Denotation.Length != 0) { + Denotation = other.Denotation; + } + switch (other.ValueCase) { + case ValueOneofCase.DimValue: + DimValue = other.DimValue; + break; + case ValueOneofCase.DimParam: + DimParam = other.DimParam; + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + DimValue = input.ReadInt64(); + break; + } + case 18: { + DimParam = input.ReadString(); + break; + } + case 26: { + Denotation = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + DimValue = input.ReadInt64(); + break; + } + case 18: { + DimParam = input.ReadString(); + break; + } + case 26: { + Denotation = input.ReadString(); + break; + } + } + } + } + #endif + + } + + } + #endregion + + } + + /// + /// Types + /// + /// The standard ONNX data types. + /// + public sealed partial class TypeProto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TypeProto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.OnnxReflection.Descriptor.MessageTypes[11]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TypeProto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TypeProto(TypeProto other) : this() { + denotation_ = other.denotation_; + switch (other.ValueCase) { + case ValueOneofCase.TensorType: + TensorType = other.TensorType.Clone(); + break; + case ValueOneofCase.SequenceType: + SequenceType = other.SequenceType.Clone(); + break; + case ValueOneofCase.MapType: + MapType = other.MapType.Clone(); + break; + case ValueOneofCase.OptionalType: + OptionalType = other.OptionalType.Clone(); + break; + case ValueOneofCase.SparseTensorType: + SparseTensorType = other.SparseTensorType.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TypeProto Clone() { + return new TypeProto(this); + } + + /// Field number for the "tensor_type" field. + public const int TensorTypeFieldNumber = 1; + /// + /// The type of a tensor. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TypeProto.Types.Tensor TensorType { + get { return valueCase_ == ValueOneofCase.TensorType ? (global::Onnx.TypeProto.Types.Tensor) value_ : null; } + set { + value_ = value; + valueCase_ = value == null ? ValueOneofCase.None : ValueOneofCase.TensorType; + } + } + + /// Field number for the "sequence_type" field. + public const int SequenceTypeFieldNumber = 4; + /// + /// The type of a sequence. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TypeProto.Types.Sequence SequenceType { + get { return valueCase_ == ValueOneofCase.SequenceType ? (global::Onnx.TypeProto.Types.Sequence) value_ : null; } + set { + value_ = value; + valueCase_ = value == null ? ValueOneofCase.None : ValueOneofCase.SequenceType; + } + } + + /// Field number for the "map_type" field. + public const int MapTypeFieldNumber = 5; + /// + /// The type of a map. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TypeProto.Types.Map MapType { + get { return valueCase_ == ValueOneofCase.MapType ? (global::Onnx.TypeProto.Types.Map) value_ : null; } + set { + value_ = value; + valueCase_ = value == null ? ValueOneofCase.None : ValueOneofCase.MapType; + } + } + + /// Field number for the "optional_type" field. + public const int OptionalTypeFieldNumber = 9; + /// + /// The type of an optional. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TypeProto.Types.Optional OptionalType { + get { return valueCase_ == ValueOneofCase.OptionalType ? (global::Onnx.TypeProto.Types.Optional) value_ : null; } + set { + value_ = value; + valueCase_ = value == null ? ValueOneofCase.None : ValueOneofCase.OptionalType; + } + } + + /// Field number for the "sparse_tensor_type" field. + public const int SparseTensorTypeFieldNumber = 8; + /// + /// Type of the sparse tensor + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TypeProto.Types.SparseTensor SparseTensorType { + get { return valueCase_ == ValueOneofCase.SparseTensorType ? (global::Onnx.TypeProto.Types.SparseTensor) value_ : null; } + set { + value_ = value; + valueCase_ = value == null ? ValueOneofCase.None : ValueOneofCase.SparseTensorType; + } + } + + /// Field number for the "denotation" field. + public const int DenotationFieldNumber = 6; + private string denotation_ = ""; + /// + /// An optional denotation can be used to denote the whole + /// type with a standard semantic description as to what is + /// stored inside. Refer to https://github.com/onnx/onnx/blob/main/docs/TypeDenotation.md#type-denotation-definition + /// for pre-defined type denotations. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Denotation { + get { return denotation_; } + set { + denotation_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + private object value_; + /// Enum of possible cases for the "value" oneof. + public enum ValueOneofCase { + None = 0, + TensorType = 1, + SequenceType = 4, + MapType = 5, + OptionalType = 9, + SparseTensorType = 8, + } + private ValueOneofCase valueCase_ = ValueOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ValueOneofCase ValueCase { + get { return valueCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearValue() { + valueCase_ = ValueOneofCase.None; + value_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TypeProto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TypeProto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(TensorType, other.TensorType)) return false; + if (!object.Equals(SequenceType, other.SequenceType)) return false; + if (!object.Equals(MapType, other.MapType)) return false; + if (!object.Equals(OptionalType, other.OptionalType)) return false; + if (!object.Equals(SparseTensorType, other.SparseTensorType)) return false; + if (Denotation != other.Denotation) return false; + if (ValueCase != other.ValueCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (valueCase_ == ValueOneofCase.TensorType) hash ^= TensorType.GetHashCode(); + if (valueCase_ == ValueOneofCase.SequenceType) hash ^= SequenceType.GetHashCode(); + if (valueCase_ == ValueOneofCase.MapType) hash ^= MapType.GetHashCode(); + if (valueCase_ == ValueOneofCase.OptionalType) hash ^= OptionalType.GetHashCode(); + if (valueCase_ == ValueOneofCase.SparseTensorType) hash ^= SparseTensorType.GetHashCode(); + if (Denotation.Length != 0) hash ^= Denotation.GetHashCode(); + hash ^= (int) valueCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (valueCase_ == ValueOneofCase.TensorType) { + output.WriteRawTag(10); + output.WriteMessage(TensorType); + } + if (valueCase_ == ValueOneofCase.SequenceType) { + output.WriteRawTag(34); + output.WriteMessage(SequenceType); + } + if (valueCase_ == ValueOneofCase.MapType) { + output.WriteRawTag(42); + output.WriteMessage(MapType); + } + if (Denotation.Length != 0) { + output.WriteRawTag(50); + output.WriteString(Denotation); + } + if (valueCase_ == ValueOneofCase.SparseTensorType) { + output.WriteRawTag(66); + output.WriteMessage(SparseTensorType); + } + if (valueCase_ == ValueOneofCase.OptionalType) { + output.WriteRawTag(74); + output.WriteMessage(OptionalType); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (valueCase_ == ValueOneofCase.TensorType) { + output.WriteRawTag(10); + output.WriteMessage(TensorType); + } + if (valueCase_ == ValueOneofCase.SequenceType) { + output.WriteRawTag(34); + output.WriteMessage(SequenceType); + } + if (valueCase_ == ValueOneofCase.MapType) { + output.WriteRawTag(42); + output.WriteMessage(MapType); + } + if (Denotation.Length != 0) { + output.WriteRawTag(50); + output.WriteString(Denotation); + } + if (valueCase_ == ValueOneofCase.SparseTensorType) { + output.WriteRawTag(66); + output.WriteMessage(SparseTensorType); + } + if (valueCase_ == ValueOneofCase.OptionalType) { + output.WriteRawTag(74); + output.WriteMessage(OptionalType); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (valueCase_ == ValueOneofCase.TensorType) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(TensorType); + } + if (valueCase_ == ValueOneofCase.SequenceType) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(SequenceType); + } + if (valueCase_ == ValueOneofCase.MapType) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(MapType); + } + if (valueCase_ == ValueOneofCase.OptionalType) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(OptionalType); + } + if (valueCase_ == ValueOneofCase.SparseTensorType) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(SparseTensorType); + } + if (Denotation.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Denotation); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TypeProto other) { + if (other == null) { + return; + } + if (other.Denotation.Length != 0) { + Denotation = other.Denotation; + } + switch (other.ValueCase) { + case ValueOneofCase.TensorType: + if (TensorType == null) { + TensorType = new global::Onnx.TypeProto.Types.Tensor(); + } + TensorType.MergeFrom(other.TensorType); + break; + case ValueOneofCase.SequenceType: + if (SequenceType == null) { + SequenceType = new global::Onnx.TypeProto.Types.Sequence(); + } + SequenceType.MergeFrom(other.SequenceType); + break; + case ValueOneofCase.MapType: + if (MapType == null) { + MapType = new global::Onnx.TypeProto.Types.Map(); + } + MapType.MergeFrom(other.MapType); + break; + case ValueOneofCase.OptionalType: + if (OptionalType == null) { + OptionalType = new global::Onnx.TypeProto.Types.Optional(); + } + OptionalType.MergeFrom(other.OptionalType); + break; + case ValueOneofCase.SparseTensorType: + if (SparseTensorType == null) { + SparseTensorType = new global::Onnx.TypeProto.Types.SparseTensor(); + } + SparseTensorType.MergeFrom(other.SparseTensorType); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + global::Onnx.TypeProto.Types.Tensor subBuilder = new global::Onnx.TypeProto.Types.Tensor(); + if (valueCase_ == ValueOneofCase.TensorType) { + subBuilder.MergeFrom(TensorType); + } + input.ReadMessage(subBuilder); + TensorType = subBuilder; + break; + } + case 34: { + global::Onnx.TypeProto.Types.Sequence subBuilder = new global::Onnx.TypeProto.Types.Sequence(); + if (valueCase_ == ValueOneofCase.SequenceType) { + subBuilder.MergeFrom(SequenceType); + } + input.ReadMessage(subBuilder); + SequenceType = subBuilder; + break; + } + case 42: { + global::Onnx.TypeProto.Types.Map subBuilder = new global::Onnx.TypeProto.Types.Map(); + if (valueCase_ == ValueOneofCase.MapType) { + subBuilder.MergeFrom(MapType); + } + input.ReadMessage(subBuilder); + MapType = subBuilder; + break; + } + case 50: { + Denotation = input.ReadString(); + break; + } + case 66: { + global::Onnx.TypeProto.Types.SparseTensor subBuilder = new global::Onnx.TypeProto.Types.SparseTensor(); + if (valueCase_ == ValueOneofCase.SparseTensorType) { + subBuilder.MergeFrom(SparseTensorType); + } + input.ReadMessage(subBuilder); + SparseTensorType = subBuilder; + break; + } + case 74: { + global::Onnx.TypeProto.Types.Optional subBuilder = new global::Onnx.TypeProto.Types.Optional(); + if (valueCase_ == ValueOneofCase.OptionalType) { + subBuilder.MergeFrom(OptionalType); + } + input.ReadMessage(subBuilder); + OptionalType = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + global::Onnx.TypeProto.Types.Tensor subBuilder = new global::Onnx.TypeProto.Types.Tensor(); + if (valueCase_ == ValueOneofCase.TensorType) { + subBuilder.MergeFrom(TensorType); + } + input.ReadMessage(subBuilder); + TensorType = subBuilder; + break; + } + case 34: { + global::Onnx.TypeProto.Types.Sequence subBuilder = new global::Onnx.TypeProto.Types.Sequence(); + if (valueCase_ == ValueOneofCase.SequenceType) { + subBuilder.MergeFrom(SequenceType); + } + input.ReadMessage(subBuilder); + SequenceType = subBuilder; + break; + } + case 42: { + global::Onnx.TypeProto.Types.Map subBuilder = new global::Onnx.TypeProto.Types.Map(); + if (valueCase_ == ValueOneofCase.MapType) { + subBuilder.MergeFrom(MapType); + } + input.ReadMessage(subBuilder); + MapType = subBuilder; + break; + } + case 50: { + Denotation = input.ReadString(); + break; + } + case 66: { + global::Onnx.TypeProto.Types.SparseTensor subBuilder = new global::Onnx.TypeProto.Types.SparseTensor(); + if (valueCase_ == ValueOneofCase.SparseTensorType) { + subBuilder.MergeFrom(SparseTensorType); + } + input.ReadMessage(subBuilder); + SparseTensorType = subBuilder; + break; + } + case 74: { + global::Onnx.TypeProto.Types.Optional subBuilder = new global::Onnx.TypeProto.Types.Optional(); + if (valueCase_ == ValueOneofCase.OptionalType) { + subBuilder.MergeFrom(OptionalType); + } + input.ReadMessage(subBuilder); + OptionalType = subBuilder; + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the TypeProto message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static partial class Types { + public sealed partial class Tensor : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Tensor()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.TypeProto.Descriptor.NestedTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Tensor() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Tensor(Tensor other) : this() { + elemType_ = other.elemType_; + shape_ = other.shape_ != null ? other.shape_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Tensor Clone() { + return new Tensor(this); + } + + /// Field number for the "elem_type" field. + public const int ElemTypeFieldNumber = 1; + private int elemType_; + /// + /// This field MUST NOT have the value of UNDEFINED + /// This field MUST have a valid TensorProto.DataType value + /// This field MUST be present for this version of the IR. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int ElemType { + get { return elemType_; } + set { + elemType_ = value; + } + } + + /// Field number for the "shape" field. + public const int ShapeFieldNumber = 2; + private global::Onnx.TensorShapeProto shape_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TensorShapeProto Shape { + get { return shape_; } + set { + shape_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Tensor); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Tensor other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ElemType != other.ElemType) return false; + if (!object.Equals(Shape, other.Shape)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ElemType != 0) hash ^= ElemType.GetHashCode(); + if (shape_ != null) hash ^= Shape.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ElemType != 0) { + output.WriteRawTag(8); + output.WriteInt32(ElemType); + } + if (shape_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Shape); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ElemType != 0) { + output.WriteRawTag(8); + output.WriteInt32(ElemType); + } + if (shape_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Shape); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ElemType != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(ElemType); + } + if (shape_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Shape); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Tensor other) { + if (other == null) { + return; + } + if (other.ElemType != 0) { + ElemType = other.ElemType; + } + if (other.shape_ != null) { + if (shape_ == null) { + Shape = new global::Onnx.TensorShapeProto(); + } + Shape.MergeFrom(other.Shape); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + ElemType = input.ReadInt32(); + break; + } + case 18: { + if (shape_ == null) { + Shape = new global::Onnx.TensorShapeProto(); + } + input.ReadMessage(Shape); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + ElemType = input.ReadInt32(); + break; + } + case 18: { + if (shape_ == null) { + Shape = new global::Onnx.TensorShapeProto(); + } + input.ReadMessage(Shape); + break; + } + } + } + } + #endif + + } + + /// + /// repeated T + /// + public sealed partial class Sequence : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Sequence()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.TypeProto.Descriptor.NestedTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Sequence() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Sequence(Sequence other) : this() { + elemType_ = other.elemType_ != null ? other.elemType_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Sequence Clone() { + return new Sequence(this); + } + + /// Field number for the "elem_type" field. + public const int ElemTypeFieldNumber = 1; + private global::Onnx.TypeProto elemType_; + /// + /// The type and optional shape of each element of the sequence. + /// This field MUST be present for this version of the IR. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TypeProto ElemType { + get { return elemType_; } + set { + elemType_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Sequence); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Sequence other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(ElemType, other.ElemType)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (elemType_ != null) hash ^= ElemType.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (elemType_ != null) { + output.WriteRawTag(10); + output.WriteMessage(ElemType); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (elemType_ != null) { + output.WriteRawTag(10); + output.WriteMessage(ElemType); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (elemType_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ElemType); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Sequence other) { + if (other == null) { + return; + } + if (other.elemType_ != null) { + if (elemType_ == null) { + ElemType = new global::Onnx.TypeProto(); + } + ElemType.MergeFrom(other.ElemType); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (elemType_ == null) { + ElemType = new global::Onnx.TypeProto(); + } + input.ReadMessage(ElemType); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (elemType_ == null) { + ElemType = new global::Onnx.TypeProto(); + } + input.ReadMessage(ElemType); + break; + } + } + } + } + #endif + + } + + /// + /// map<K,V> + /// + public sealed partial class Map : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Map()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.TypeProto.Descriptor.NestedTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Map() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Map(Map other) : this() { + keyType_ = other.keyType_; + valueType_ = other.valueType_ != null ? other.valueType_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Map Clone() { + return new Map(this); + } + + /// Field number for the "key_type" field. + public const int KeyTypeFieldNumber = 1; + private int keyType_; + /// + /// This field MUST have a valid TensorProto.DataType value + /// This field MUST be present for this version of the IR. + /// This field MUST refer to an integral type ([U]INT{8|16|32|64}) or STRING + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int KeyType { + get { return keyType_; } + set { + keyType_ = value; + } + } + + /// Field number for the "value_type" field. + public const int ValueTypeFieldNumber = 2; + private global::Onnx.TypeProto valueType_; + /// + /// This field MUST be present for this version of the IR. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TypeProto ValueType { + get { return valueType_; } + set { + valueType_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Map); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Map other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (KeyType != other.KeyType) return false; + if (!object.Equals(ValueType, other.ValueType)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (KeyType != 0) hash ^= KeyType.GetHashCode(); + if (valueType_ != null) hash ^= ValueType.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (KeyType != 0) { + output.WriteRawTag(8); + output.WriteInt32(KeyType); + } + if (valueType_ != null) { + output.WriteRawTag(18); + output.WriteMessage(ValueType); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (KeyType != 0) { + output.WriteRawTag(8); + output.WriteInt32(KeyType); + } + if (valueType_ != null) { + output.WriteRawTag(18); + output.WriteMessage(ValueType); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (KeyType != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(KeyType); + } + if (valueType_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ValueType); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Map other) { + if (other == null) { + return; + } + if (other.KeyType != 0) { + KeyType = other.KeyType; + } + if (other.valueType_ != null) { + if (valueType_ == null) { + ValueType = new global::Onnx.TypeProto(); + } + ValueType.MergeFrom(other.ValueType); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + KeyType = input.ReadInt32(); + break; + } + case 18: { + if (valueType_ == null) { + ValueType = new global::Onnx.TypeProto(); + } + input.ReadMessage(ValueType); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + KeyType = input.ReadInt32(); + break; + } + case 18: { + if (valueType_ == null) { + ValueType = new global::Onnx.TypeProto(); + } + input.ReadMessage(ValueType); + break; + } + } + } + } + #endif + + } + + /// + /// wrapper for Tensor, Sequence, or Map + /// + public sealed partial class Optional : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Optional()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.TypeProto.Descriptor.NestedTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Optional() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Optional(Optional other) : this() { + elemType_ = other.elemType_ != null ? other.elemType_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Optional Clone() { + return new Optional(this); + } + + /// Field number for the "elem_type" field. + public const int ElemTypeFieldNumber = 1; + private global::Onnx.TypeProto elemType_; + /// + /// The type and optional shape of the element wrapped. + /// This field MUST be present for this version of the IR. + /// Possible values correspond to OptionalProto.DataType enum + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TypeProto ElemType { + get { return elemType_; } + set { + elemType_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Optional); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Optional other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(ElemType, other.ElemType)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (elemType_ != null) hash ^= ElemType.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (elemType_ != null) { + output.WriteRawTag(10); + output.WriteMessage(ElemType); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (elemType_ != null) { + output.WriteRawTag(10); + output.WriteMessage(ElemType); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (elemType_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ElemType); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Optional other) { + if (other == null) { + return; + } + if (other.elemType_ != null) { + if (elemType_ == null) { + ElemType = new global::Onnx.TypeProto(); + } + ElemType.MergeFrom(other.ElemType); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (elemType_ == null) { + ElemType = new global::Onnx.TypeProto(); + } + input.ReadMessage(ElemType); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (elemType_ == null) { + ElemType = new global::Onnx.TypeProto(); + } + input.ReadMessage(ElemType); + break; + } + } + } + } + #endif + + } + + public sealed partial class SparseTensor : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SparseTensor()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.TypeProto.Descriptor.NestedTypes[4]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SparseTensor() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SparseTensor(SparseTensor other) : this() { + elemType_ = other.elemType_; + shape_ = other.shape_ != null ? other.shape_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SparseTensor Clone() { + return new SparseTensor(this); + } + + /// Field number for the "elem_type" field. + public const int ElemTypeFieldNumber = 1; + private int elemType_; + /// + /// This field MUST NOT have the value of UNDEFINED + /// This field MUST have a valid TensorProto.DataType value + /// This field MUST be present for this version of the IR. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int ElemType { + get { return elemType_; } + set { + elemType_ = value; + } + } + + /// Field number for the "shape" field. + public const int ShapeFieldNumber = 2; + private global::Onnx.TensorShapeProto shape_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Onnx.TensorShapeProto Shape { + get { return shape_; } + set { + shape_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SparseTensor); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SparseTensor other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ElemType != other.ElemType) return false; + if (!object.Equals(Shape, other.Shape)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ElemType != 0) hash ^= ElemType.GetHashCode(); + if (shape_ != null) hash ^= Shape.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ElemType != 0) { + output.WriteRawTag(8); + output.WriteInt32(ElemType); + } + if (shape_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Shape); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ElemType != 0) { + output.WriteRawTag(8); + output.WriteInt32(ElemType); + } + if (shape_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Shape); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ElemType != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(ElemType); + } + if (shape_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Shape); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SparseTensor other) { + if (other == null) { + return; + } + if (other.ElemType != 0) { + ElemType = other.ElemType; + } + if (other.shape_ != null) { + if (shape_ == null) { + Shape = new global::Onnx.TensorShapeProto(); + } + Shape.MergeFrom(other.Shape); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + ElemType = input.ReadInt32(); + break; + } + case 18: { + if (shape_ == null) { + Shape = new global::Onnx.TensorShapeProto(); + } + input.ReadMessage(Shape); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + ElemType = input.ReadInt32(); + break; + } + case 18: { + if (shape_ == null) { + Shape = new global::Onnx.TensorShapeProto(); + } + input.ReadMessage(Shape); + break; + } + } + } + } + #endif + + } + + } + #endregion + + } + + /// + /// Operator Sets + /// + /// OperatorSets are uniquely identified by a (domain, opset_version) pair. + /// + public sealed partial class OperatorSetIdProto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OperatorSetIdProto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.OnnxReflection.Descriptor.MessageTypes[12]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OperatorSetIdProto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OperatorSetIdProto(OperatorSetIdProto other) : this() { + domain_ = other.domain_; + version_ = other.version_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OperatorSetIdProto Clone() { + return new OperatorSetIdProto(this); + } + + /// Field number for the "domain" field. + public const int DomainFieldNumber = 1; + private string domain_ = ""; + /// + /// The domain of the operator set being identified. + /// The empty string ("") or absence of this field implies the operator + /// set that is defined as part of the ONNX specification. + /// This field MUST be present in this version of the IR when referring to any other operator set. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Domain { + get { return domain_; } + set { + domain_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "version" field. + public const int VersionFieldNumber = 2; + private long version_; + /// + /// The version of the operator set being identified. + /// This field MUST be present in this version of the IR. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public long Version { + get { return version_; } + set { + version_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as OperatorSetIdProto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(OperatorSetIdProto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Domain != other.Domain) return false; + if (Version != other.Version) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Domain.Length != 0) hash ^= Domain.GetHashCode(); + if (Version != 0L) hash ^= Version.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Domain.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Domain); + } + if (Version != 0L) { + output.WriteRawTag(16); + output.WriteInt64(Version); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Domain.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Domain); + } + if (Version != 0L) { + output.WriteRawTag(16); + output.WriteInt64(Version); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Domain.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Domain); + } + if (Version != 0L) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(Version); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(OperatorSetIdProto other) { + if (other == null) { + return; + } + if (other.Domain.Length != 0) { + Domain = other.Domain; + } + if (other.Version != 0L) { + Version = other.Version; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Domain = input.ReadString(); + break; + } + case 16: { + Version = input.ReadInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Domain = input.ReadString(); + break; + } + case 16: { + Version = input.ReadInt64(); + break; + } + } + } + } + #endif + + } + + public sealed partial class FunctionProto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new FunctionProto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Onnx.OnnxReflection.Descriptor.MessageTypes[13]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FunctionProto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FunctionProto(FunctionProto other) : this() { + name_ = other.name_; + input_ = other.input_.Clone(); + output_ = other.output_.Clone(); + attribute_ = other.attribute_.Clone(); + attributeProto_ = other.attributeProto_.Clone(); + node_ = other.node_.Clone(); + docString_ = other.docString_; + opsetImport_ = other.opsetImport_.Clone(); + domain_ = other.domain_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FunctionProto Clone() { + return new FunctionProto(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + /// + /// The name of the function, similar usage of op_type in OperatorProto. + /// Combined with FunctionProto.domain, this forms the unique identity of + /// the FunctionProto. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "input" field. + public const int InputFieldNumber = 4; + private static readonly pb::FieldCodec _repeated_input_codec + = pb::FieldCodec.ForString(34); + private readonly pbc::RepeatedField input_ = new pbc::RepeatedField(); + /// + /// The inputs and outputs of the function. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Input { + get { return input_; } + } + + /// Field number for the "output" field. + public const int OutputFieldNumber = 5; + private static readonly pb::FieldCodec _repeated_output_codec + = pb::FieldCodec.ForString(42); + private readonly pbc::RepeatedField output_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Output { + get { return output_; } + } + + /// Field number for the "attribute" field. + public const int AttributeFieldNumber = 6; + private static readonly pb::FieldCodec _repeated_attribute_codec + = pb::FieldCodec.ForString(50); + private readonly pbc::RepeatedField attribute_ = new pbc::RepeatedField(); + /// + /// The attribute parameters of the function. + /// It is for function parameters without default values. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Attribute { + get { return attribute_; } + } + + /// Field number for the "attribute_proto" field. + public const int AttributeProtoFieldNumber = 11; + private static readonly pb::FieldCodec _repeated_attributeProto_codec + = pb::FieldCodec.ForMessage(90, global::Onnx.AttributeProto.Parser); + private readonly pbc::RepeatedField attributeProto_ = new pbc::RepeatedField(); + /// + /// The attribute protos of the function. + /// It is for function attributes with default values. + /// A function attribute shall be represented either as + /// a string attribute or an AttributeProto, not both. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField AttributeProto { + get { return attributeProto_; } + } + + /// Field number for the "node" field. + public const int NodeFieldNumber = 7; + private static readonly pb::FieldCodec _repeated_node_codec + = pb::FieldCodec.ForMessage(58, global::Onnx.NodeProto.Parser); + private readonly pbc::RepeatedField node_ = new pbc::RepeatedField(); + /// + /// The nodes in the function. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Node { + get { return node_; } + } + + /// Field number for the "doc_string" field. + public const int DocStringFieldNumber = 8; + private string docString_ = ""; + /// + /// A human-readable documentation for this function. Markdown is allowed. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DocString { + get { return docString_; } + set { + docString_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "opset_import" field. + public const int OpsetImportFieldNumber = 9; + private static readonly pb::FieldCodec _repeated_opsetImport_codec + = pb::FieldCodec.ForMessage(74, global::Onnx.OperatorSetIdProto.Parser); + private readonly pbc::RepeatedField opsetImport_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField OpsetImport { + get { return opsetImport_; } + } + + /// Field number for the "domain" field. + public const int DomainFieldNumber = 10; + private string domain_ = ""; + /// + /// The domain which this function belongs to. Combined with FunctionProto.name, this forms the unique identity of + /// the FunctionProto. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Domain { + get { return domain_; } + set { + domain_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as FunctionProto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(FunctionProto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if(!input_.Equals(other.input_)) return false; + if(!output_.Equals(other.output_)) return false; + if(!attribute_.Equals(other.attribute_)) return false; + if(!attributeProto_.Equals(other.attributeProto_)) return false; + if(!node_.Equals(other.node_)) return false; + if (DocString != other.DocString) return false; + if(!opsetImport_.Equals(other.opsetImport_)) return false; + if (Domain != other.Domain) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + hash ^= input_.GetHashCode(); + hash ^= output_.GetHashCode(); + hash ^= attribute_.GetHashCode(); + hash ^= attributeProto_.GetHashCode(); + hash ^= node_.GetHashCode(); + if (DocString.Length != 0) hash ^= DocString.GetHashCode(); + hash ^= opsetImport_.GetHashCode(); + if (Domain.Length != 0) hash ^= Domain.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + input_.WriteTo(output, _repeated_input_codec); + output_.WriteTo(output, _repeated_output_codec); + attribute_.WriteTo(output, _repeated_attribute_codec); + node_.WriteTo(output, _repeated_node_codec); + if (DocString.Length != 0) { + output.WriteRawTag(66); + output.WriteString(DocString); + } + opsetImport_.WriteTo(output, _repeated_opsetImport_codec); + if (Domain.Length != 0) { + output.WriteRawTag(82); + output.WriteString(Domain); + } + attributeProto_.WriteTo(output, _repeated_attributeProto_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + input_.WriteTo(ref output, _repeated_input_codec); + output_.WriteTo(ref output, _repeated_output_codec); + attribute_.WriteTo(ref output, _repeated_attribute_codec); + node_.WriteTo(ref output, _repeated_node_codec); + if (DocString.Length != 0) { + output.WriteRawTag(66); + output.WriteString(DocString); + } + opsetImport_.WriteTo(ref output, _repeated_opsetImport_codec); + if (Domain.Length != 0) { + output.WriteRawTag(82); + output.WriteString(Domain); + } + attributeProto_.WriteTo(ref output, _repeated_attributeProto_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + size += input_.CalculateSize(_repeated_input_codec); + size += output_.CalculateSize(_repeated_output_codec); + size += attribute_.CalculateSize(_repeated_attribute_codec); + size += attributeProto_.CalculateSize(_repeated_attributeProto_codec); + size += node_.CalculateSize(_repeated_node_codec); + if (DocString.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DocString); + } + size += opsetImport_.CalculateSize(_repeated_opsetImport_codec); + if (Domain.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Domain); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(FunctionProto other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + input_.Add(other.input_); + output_.Add(other.output_); + attribute_.Add(other.attribute_); + attributeProto_.Add(other.attributeProto_); + node_.Add(other.node_); + if (other.DocString.Length != 0) { + DocString = other.DocString; + } + opsetImport_.Add(other.opsetImport_); + if (other.Domain.Length != 0) { + Domain = other.Domain; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 34: { + input_.AddEntriesFrom(input, _repeated_input_codec); + break; + } + case 42: { + output_.AddEntriesFrom(input, _repeated_output_codec); + break; + } + case 50: { + attribute_.AddEntriesFrom(input, _repeated_attribute_codec); + break; + } + case 58: { + node_.AddEntriesFrom(input, _repeated_node_codec); + break; + } + case 66: { + DocString = input.ReadString(); + break; + } + case 74: { + opsetImport_.AddEntriesFrom(input, _repeated_opsetImport_codec); + break; + } + case 82: { + Domain = input.ReadString(); + break; + } + case 90: { + attributeProto_.AddEntriesFrom(input, _repeated_attributeProto_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 34: { + input_.AddEntriesFrom(ref input, _repeated_input_codec); + break; + } + case 42: { + output_.AddEntriesFrom(ref input, _repeated_output_codec); + break; + } + case 50: { + attribute_.AddEntriesFrom(ref input, _repeated_attribute_codec); + break; + } + case 58: { + node_.AddEntriesFrom(ref input, _repeated_node_codec); + break; + } + case 66: { + DocString = input.ReadString(); + break; + } + case 74: { + opsetImport_.AddEntriesFrom(ref input, _repeated_opsetImport_codec); + break; + } + case 82: { + Domain = input.ReadString(); + break; + } + case 90: { + attributeProto_.AddEntriesFrom(ref input, _repeated_attributeProto_codec); + break; + } + } + } + } + #endif + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/WpfApplicationSample_OnnxViewer.csproj b/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/WpfApplicationSample_OnnxViewer.csproj new file mode 100644 index 00000000..cd47ae03 --- /dev/null +++ b/GraphLayout/Samples/WpfApplicationSample_OnnxViewer/WpfApplicationSample_OnnxViewer.csproj @@ -0,0 +1,20 @@ + + + + WinExe + net6.0-windows + enable + true + + + + + + + + + + + + +