EntryPoints.md

Latest commit

History

History
230 lines (199 loc) · 10.5 KB

EntryPoints.md

File metadata and controls

230 lines (199 loc) · 10.5 KB
Raw

Entry Points And Helper Classes

Overview

Entry points are a way to interface with ML.NET components, by specifying an execution graph of connected inputs and outputs of those components. Both the manifest describing available components and their inputs/outputs, and an "experiment" graph description, are expressed in JSON. The recommended way of interacting with ML.NET through other, non-.NET programming languages, is by composing, and exchanging pipelines or experiment graphs.

Through the documentation, we also refer to entry points as 'entry points nodes', and that is because they are the nodes of the graph representing the experiment. The graph 'variables', the various values of the experiment graph JSON properties, serve to describe the relationship between the entry point nodes. The 'variables' are therefore the edges of the DAG (Directed Acyclic Graph).

All of ML.NET entry points are described by their manifest. The manifest is another JSON object that documents and describes the structure of an entry points. Manifests are referenced to understand what an entry point does, and how it should be constructed, in a graph.

This document briefly describes the structure of the entry points, the structure of an entry point manifest, and mentions the ML.NET classes that help construct an entry point graph.

EntryPoint manifest - the definition of an entry point

The components manifest is build by scanning the ML.NET assemblies through reflection and searching for types having the: SignatureEntryPointModule signature in their LoadableClass assembly attribute definition. An example of an entry point manifest object, specifically for the ColumnTypeConverter transform, is:

{"Name": "Transforms.ColumnTypeConverter","Desc": "Converts a column to a different type, using standard conversions.","FriendlyName": "Convert Transform","ShortName": "Convert","Inputs": [{"Name": "Column","Type": {"Kind": "Array","ItemType": {"Kind": "Struct","Fields": [{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 150,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Name","Type": "String","Desc": "Name of the new column","Aliases": ["name"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Source","Type": "String","Desc": "Name of the source column","Aliases": ["src"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}]}},"Desc": "New column definition(s) (optional form: name:type:src)","Aliases": ["col"],"Required": true,"SortOrder": 1,"IsNullable": false},{"Name": "Data","Type": "DataView","Desc": "Input dataset","Required": true,"SortOrder": 2,"IsNullable": false},{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 2,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}],"Outputs": [{"Name": "OutputData","Type": "DataView","Desc": "Transformed dataset"},{"Name": "Model","Type": "TransformModel","Desc": "Transform model"}],"InputKind": ["ITransformInput"],"OutputKind": ["ITransformOutput"]}

The respective entry point, constructed based on this manifest would be:

{"Name": "Transforms.ColumnTypeConverter","Inputs": {"Column": [{"Name": "Features","Source": "Features"}],"Data": "$data0","ResultType": "R4"},"Outputs": {"OutputData": "$Convert_Output","Model": "$Convert_TransformModel"}}

EntryPointGraph

This class encapsulates the list of nodes (EntryPointNode) and edges (EntryPointVariable inside a RunContext) of the graph.

EntryPointNode

This class represents a node in the graph, and wraps an entry point call. It has methods for creating and running entry points. It also has a reference to the RunContext to allow it to get and set values from EntryPointVariables.

To express the inputs that are set through variables, a set of dictionaries are used. The InputBindingMap maps an input parameter name to a list of ParameterBindings. The InputMap maps a ParameterBinding to a VariableBinding. For example, if the JSON looks like this:

'foo': '$bar'

the InputBindingMap will have one entry that maps the string "foo" to a list that has only one element, a SimpleParameterBinding with the name "foo" and the InputMap will map the SimpleParameterBinding to a SimpleVariableBinding with the name "bar". For a more complicated example, let's say we have this JSON:

'foo': ['$bar[3]','$baz']

the InputBindingMap will have one entry that maps the string "foo" to a list that has two elements, an ArrayIndexParameterBinding with the name "foo" and index 0 and another one with index 1. The InputMap will map the first ArrayIndexParameterBinding to an ArrayIndexVariableBinding with name "bar" and index 3 and the second ArrayIndexParameterBinding to a SimpleVariableBinding with the name "baz".

For outputs, a node assumes that an output is mapped to a variable, so the OutputMap is a simple dictionary from string to string.

EntryPointVariable

This class represents an edge in the entry point graph. It has a name, a type and a value. Variables can be simple, arrays and/or dictionaries. Currently, only data views, file handles, predictor models and transform models are allowed as element types for a variable.

RunContext

This class is just a container for all the variables in a graph.

VariableBinding and Derived Classes

The abstract base class represents a "pointer to a (part of a) variable". It is used in conjunction with ParameterBindings to specify inputs to an entry point node. The SimpleVariableBinding is a pointer to an entire variable, the ArrayIndexVariableBinding is a pointer to a specific index in an array variable, and the DictionaryKeyVariableBinding is a pointer to a specific key in a dictionary variable.

ParameterBinding and Derived Classes

The abstract base class represents a "pointer to a (part of a) parameter". It parallels the VariableBinding hierarchy and it is used to specify the inputs to an entry point node. The SimpleParameterBinding is a pointer to a non-array, non-dictionary parameter, the ArrayIndexParameterBinding is a pointer to a specific index of an array parameter and the DictionaryKeyParameterBinding is a pointer to a specific key of a dictionary parameter.

How to create an entry point for an existing ML.NET component

  1. Add a LoadableClass assembly attribute with the SignatureEntryPointModule signature as shown here.
  2. Create a public static method, that:
    1. Takes an object representing the arguments of the component you want to expose as shown here
    2. Initializes and runs the component, returning one of the nested classes of Microsoft.ML.EntryPoints.CommonOutputs
    3. Is annotated with the TlcModule.EntryPoint attribute

For an example of a transformer as an entrypoint, see OneHotVectorizer. For a trainer-estimator, see LogisticRegression.

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
EntryPoints.md
Latest commit
History
History
230 lines (199 loc) · 10.5 KB
EntryPoints.md
File metadata and controls
230 lines (199 loc) · 10.5 KB
Raw
Entry Points And Helper Classes
Overview
Entry points are a way to interface with ML.NET components, by specifying an execution graph of connected inputs and outputs of those components.
Both the manifest describing available components and their inputs/outputs, and an "experiment" graph description, are expressed in JSON.
The recommended way of interacting with ML.NET through other, non-.NET programming languages, is by composing, and exchanging pipelines or experiment graphs.
Through the documentation, we also refer to entry points as 'entry points nodes', and that is because they are the nodes of the graph representing the experiment.
The graph 'variables', the various values of the experiment graph JSON properties, serve to describe the relationship between the entry point nodes.
The 'variables' are therefore the edges of the DAG (Directed Acyclic Graph).
All of ML.NET entry points are described by their manifest. The manifest is another JSON object that documents and describes the structure of an entry points.
Manifests are referenced to understand what an entry point does, and how it should be constructed, in a graph.
This document briefly describes the structure of the entry points, the structure of an entry point manifest, and mentions the ML.NET classes that help construct an entry point graph.
EntryPoint manifest - the definition of an entry point
The components manifest is build by scanning the ML.NET assemblies through reflection and searching for types having the: SignatureEntryPointModule signature in their LoadableClass assembly attribute definition.
An example of an entry point manifest object, specifically for the ColumnTypeConverter transform, is:
{"Name": "Transforms.ColumnTypeConverter","Desc": "Converts a column to a different type, using standard conversions.","FriendlyName": "Convert Transform","ShortName": "Convert","Inputs": [{"Name": "Column","Type": {"Kind": "Array","ItemType": {"Kind": "Struct","Fields": [{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 150,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Name","Type": "String","Desc": "Name of the new column","Aliases": ["name"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Source","Type": "String","Desc": "Name of the source column","Aliases": ["src"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}]}},"Desc": "New column definition(s) (optional form: name:type:src)","Aliases": ["col"],"Required": true,"SortOrder": 1,"IsNullable": false},{"Name": "Data","Type": "DataView","Desc": "Input dataset","Required": true,"SortOrder": 2,"IsNullable": false},{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 2,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}],"Outputs": [{"Name": "OutputData","Type": "DataView","Desc": "Transformed dataset"},{"Name": "Model","Type": "TransformModel","Desc": "Transform model"}],"InputKind": ["ITransformInput"],"OutputKind": ["ITransformOutput"]}
The respective entry point, constructed based on this manifest would be:
{"Name": "Transforms.ColumnTypeConverter","Inputs": {"Column": [{"Name": "Features","Source": "Features"}],"Data": "$data0","ResultType": "R4"},"Outputs": {"OutputData": "$Convert_Output","Model": "$Convert_TransformModel"}}
EntryPointGraph
This class encapsulates the list of nodes (EntryPointNode) and edges
(EntryPointVariable inside a RunContext) of the graph.
EntryPointNode
This class represents a node in the graph, and wraps an entry point call. It
has methods for creating and running entry points. It also has a reference to
the RunContext to allow it to get and set values from EntryPointVariables.
To express the inputs that are set through variables, a set of dictionaries
are used. The InputBindingMap maps an input parameter name to a list of
ParameterBindings. The InputMap maps a ParameterBinding to a
VariableBinding. For example, if the JSON looks like this:
'foo': '$bar'
the InputBindingMap will have one entry that maps the string "foo" to a list
that has only one element, a SimpleParameterBinding with the name "foo" and
the InputMap will map the SimpleParameterBinding to a
SimpleVariableBinding with the name "bar". For a more complicated example,
let's say we have this JSON:
'foo': ['$bar[3]','$baz']
the InputBindingMap will have one entry that maps the string "foo" to a list
that has two elements, an ArrayIndexParameterBinding with the name "foo" and
index 0 and another one with index 1. The InputMap will map the first
ArrayIndexParameterBinding to an ArrayIndexVariableBinding with name "bar"
and index 3 and the second ArrayIndexParameterBinding to a
SimpleVariableBinding with the name "baz".
For outputs, a node assumes that an output is mapped to a variable, so the
OutputMap is a simple dictionary from string to string.
EntryPointVariable
This class represents an edge in the entry point graph. It has a name, a type
and a value. Variables can be simple, arrays and/or dictionaries. Currently,
only data views, file handles, predictor models and transform models are
allowed as element types for a variable.
RunContext
This class is just a container for all the variables in a graph.
VariableBinding and Derived Classes
The abstract base class represents a "pointer to a (part of a) variable". It
is used in conjunction with ParameterBindings to specify inputs to an entry
point node. The SimpleVariableBinding is a pointer to an entire variable,
the ArrayIndexVariableBinding is a pointer to a specific index in an array
variable, and the DictionaryKeyVariableBinding is a pointer to a specific
key in a dictionary variable.
ParameterBinding and Derived Classes
The abstract base class represents a "pointer to a (part of a) parameter". It
parallels the VariableBinding hierarchy and it is used to specify the inputs
to an entry point node. The SimpleParameterBinding is a pointer to a
non-array, non-dictionary parameter, the ArrayIndexParameterBinding is a
pointer to a specific index of an array parameter and the
DictionaryKeyParameterBinding is a pointer to a specific key of a dictionary
parameter.
How to create an entry point for an existing ML.NET component
  1. Add a LoadableClass assembly attribute with the SignatureEntryPointModule signature as shown here.
  2. Create a public static method, that:

    1. Takes an object representing the arguments of the component you want to expose as shown here
    2. Initializes and runs the component, returning one of the nested classes of Microsoft.ML.EntryPoints.CommonOutputs
    3. Is annotated with the TlcModule.EntryPoint attribute
For an example of a transformer as an entrypoint, see OneHotVectorizer.
For a trainer-estimator, see LogisticRegression.

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
EntryPoints.md
Latest commit
History
History
230 lines (199 loc) · 10.5 KB
EntryPoints.md
File metadata and controls
230 lines (199 loc) · 10.5 KB
Raw
Entry Points And Helper Classes
Overview
Entry points are a way to interface with ML.NET components, by specifying an execution graph of connected inputs and outputs of those components.
Both the manifest describing available components and their inputs/outputs, and an "experiment" graph description, are expressed in JSON.
The recommended way of interacting with ML.NET through other, non-.NET programming languages, is by composing, and exchanging pipelines or experiment graphs.
Through the documentation, we also refer to entry points as 'entry points nodes', and that is because they are the nodes of the graph representing the experiment.
The graph 'variables', the various values of the experiment graph JSON properties, serve to describe the relationship between the entry point nodes.
The 'variables' are therefore the edges of the DAG (Directed Acyclic Graph).
All of ML.NET entry points are described by their manifest. The manifest is another JSON object that documents and describes the structure of an entry points.
Manifests are referenced to understand what an entry point does, and how it should be constructed, in a graph.
This document briefly describes the structure of the entry points, the structure of an entry point manifest, and mentions the ML.NET classes that help construct an entry point graph.
EntryPoint manifest - the definition of an entry point
The components manifest is build by scanning the ML.NET assemblies through reflection and searching for types having the: SignatureEntryPointModule signature in their LoadableClass assembly attribute definition.
An example of an entry point manifest object, specifically for the ColumnTypeConverter transform, is:
{"Name": "Transforms.ColumnTypeConverter","Desc": "Converts a column to a different type, using standard conversions.","FriendlyName": "Convert Transform","ShortName": "Convert","Inputs": [{"Name": "Column","Type": {"Kind": "Array","ItemType": {"Kind": "Struct","Fields": [{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 150,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Name","Type": "String","Desc": "Name of the new column","Aliases": ["name"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Source","Type": "String","Desc": "Name of the source column","Aliases": ["src"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}]}},"Desc": "New column definition(s) (optional form: name:type:src)","Aliases": ["col"],"Required": true,"SortOrder": 1,"IsNullable": false},{"Name": "Data","Type": "DataView","Desc": "Input dataset","Required": true,"SortOrder": 2,"IsNullable": false},{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 2,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}],"Outputs": [{"Name": "OutputData","Type": "DataView","Desc": "Transformed dataset"},{"Name": "Model","Type": "TransformModel","Desc": "Transform model"}],"InputKind": ["ITransformInput"],"OutputKind": ["ITransformOutput"]}
The respective entry point, constructed based on this manifest would be:
{"Name": "Transforms.ColumnTypeConverter","Inputs": {"Column": [{"Name": "Features","Source": "Features"}],"Data": "$data0","ResultType": "R4"},"Outputs": {"OutputData": "$Convert_Output","Model": "$Convert_TransformModel"}}
EntryPointGraph
This class encapsulates the list of nodes (EntryPointNode) and edges
(EntryPointVariable inside a RunContext) of the graph.
EntryPointNode
This class represents a node in the graph, and wraps an entry point call. It
has methods for creating and running entry points. It also has a reference to
the RunContext to allow it to get and set values from EntryPointVariables.
To express the inputs that are set through variables, a set of dictionaries
are used. The InputBindingMap maps an input parameter name to a list of
ParameterBindings. The InputMap maps a ParameterBinding to a
VariableBinding. For example, if the JSON looks like this:
'foo': '$bar'
the InputBindingMap will have one entry that maps the string "foo" to a list
that has only one element, a SimpleParameterBinding with the name "foo" and
the InputMap will map the SimpleParameterBinding to a
SimpleVariableBinding with the name "bar". For a more complicated example,
let's say we have this JSON:
'foo': ['$bar[3]','$baz']
the InputBindingMap will have one entry that maps the string "foo" to a list
that has two elements, an ArrayIndexParameterBinding with the name "foo" and
index 0 and another one with index 1. The InputMap will map the first
ArrayIndexParameterBinding to an ArrayIndexVariableBinding with name "bar"
and index 3 and the second ArrayIndexParameterBinding to a
SimpleVariableBinding with the name "baz".
For outputs, a node assumes that an output is mapped to a variable, so the
OutputMap is a simple dictionary from string to string.
EntryPointVariable
This class represents an edge in the entry point graph. It has a name, a type
and a value. Variables can be simple, arrays and/or dictionaries. Currently,
only data views, file handles, predictor models and transform models are
allowed as element types for a variable.
RunContext
This class is just a container for all the variables in a graph.
VariableBinding and Derived Classes
The abstract base class represents a "pointer to a (part of a) variable". It
is used in conjunction with ParameterBindings to specify inputs to an entry
point node. The SimpleVariableBinding is a pointer to an entire variable,
the ArrayIndexVariableBinding is a pointer to a specific index in an array
variable, and the DictionaryKeyVariableBinding is a pointer to a specific
key in a dictionary variable.
ParameterBinding and Derived Classes
The abstract base class represents a "pointer to a (part of a) parameter". It
parallels the VariableBinding hierarchy and it is used to specify the inputs
to an entry point node. The SimpleParameterBinding is a pointer to a
non-array, non-dictionary parameter, the ArrayIndexParameterBinding is a
pointer to a specific index of an array parameter and the
DictionaryKeyParameterBinding is a pointer to a specific key of a dictionary
parameter.
How to create an entry point for an existing ML.NET component
  1. Add a LoadableClass assembly attribute with the SignatureEntryPointModule signature as shown here.
  2. Create a public static method, that:

    1. Takes an object representing the arguments of the component you want to expose as shown here
    2. Initializes and runs the component, returning one of the nested classes of Microsoft.ML.EntryPoints.CommonOutputs
    3. Is annotated with the TlcModule.EntryPoint attribute
For an example of a transformer as an entrypoint, see OneHotVectorizer.
For a trainer-estimator, see LogisticRegression.

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
EntryPoints.md
Latest commit
History
History
230 lines (199 loc) · 10.5 KB
EntryPoints.md
File metadata and controls
230 lines (199 loc) · 10.5 KB
Raw
Entry Points And Helper Classes
Overview
Entry points are a way to interface with ML.NET components, by specifying an execution graph of connected inputs and outputs of those components.
Both the manifest describing available components and their inputs/outputs, and an "experiment" graph description, are expressed in JSON.
The recommended way of interacting with ML.NET through other, non-.NET programming languages, is by composing, and exchanging pipelines or experiment graphs.
Through the documentation, we also refer to entry points as 'entry points nodes', and that is because they are the nodes of the graph representing the experiment.
The graph 'variables', the various values of the experiment graph JSON properties, serve to describe the relationship between the entry point nodes.
The 'variables' are therefore the edges of the DAG (Directed Acyclic Graph).
All of ML.NET entry points are described by their manifest. The manifest is another JSON object that documents and describes the structure of an entry points.
Manifests are referenced to understand what an entry point does, and how it should be constructed, in a graph.
This document briefly describes the structure of the entry points, the structure of an entry point manifest, and mentions the ML.NET classes that help construct an entry point graph.
EntryPoint manifest - the definition of an entry point
The components manifest is build by scanning the ML.NET assemblies through reflection and searching for types having the: SignatureEntryPointModule signature in their LoadableClass assembly attribute definition.
An example of an entry point manifest object, specifically for the ColumnTypeConverter transform, is:
{"Name": "Transforms.ColumnTypeConverter","Desc": "Converts a column to a different type, using standard conversions.","FriendlyName": "Convert Transform","ShortName": "Convert","Inputs": [{"Name": "Column","Type": {"Kind": "Array","ItemType": {"Kind": "Struct","Fields": [{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 150,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Name","Type": "String","Desc": "Name of the new column","Aliases": ["name"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Source","Type": "String","Desc": "Name of the source column","Aliases": ["src"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}]}},"Desc": "New column definition(s) (optional form: name:type:src)","Aliases": ["col"],"Required": true,"SortOrder": 1,"IsNullable": false},{"Name": "Data","Type": "DataView","Desc": "Input dataset","Required": true,"SortOrder": 2,"IsNullable": false},{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 2,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}],"Outputs": [{"Name": "OutputData","Type": "DataView","Desc": "Transformed dataset"},{"Name": "Model","Type": "TransformModel","Desc": "Transform model"}],"InputKind": ["ITransformInput"],"OutputKind": ["ITransformOutput"]}
The respective entry point, constructed based on this manifest would be:
{"Name": "Transforms.ColumnTypeConverter","Inputs": {"Column": [{"Name": "Features","Source": "Features"}],"Data": "$data0","ResultType": "R4"},"Outputs": {"OutputData": "$Convert_Output","Model": "$Convert_TransformModel"}}
EntryPointGraph
This class encapsulates the list of nodes (EntryPointNode) and edges
(EntryPointVariable inside a RunContext) of the graph.
EntryPointNode
This class represents a node in the graph, and wraps an entry point call. It
has methods for creating and running entry points. It also has a reference to
the RunContext to allow it to get and set values from EntryPointVariables.
To express the inputs that are set through variables, a set of dictionaries
are used. The InputBindingMap maps an input parameter name to a list of
ParameterBindings. The InputMap maps a ParameterBinding to a
VariableBinding. For example, if the JSON looks like this:
'foo': '$bar'
the InputBindingMap will have one entry that maps the string "foo" to a list
that has only one element, a SimpleParameterBinding with the name "foo" and
the InputMap will map the SimpleParameterBinding to a
SimpleVariableBinding with the name "bar". For a more complicated example,
let's say we have this JSON:
'foo': ['$bar[3]','$baz']
the InputBindingMap will have one entry that maps the string "foo" to a list
that has two elements, an ArrayIndexParameterBinding with the name "foo" and
index 0 and another one with index 1. The InputMap will map the first
ArrayIndexParameterBinding to an ArrayIndexVariableBinding with name "bar"
and index 3 and the second ArrayIndexParameterBinding to a
SimpleVariableBinding with the name "baz".
For outputs, a node assumes that an output is mapped to a variable, so the
OutputMap is a simple dictionary from string to string.
EntryPointVariable
This class represents an edge in the entry point graph. It has a name, a type
and a value. Variables can be simple, arrays and/or dictionaries. Currently,
only data views, file handles, predictor models and transform models are
allowed as element types for a variable.
RunContext
This class is just a container for all the variables in a graph.
VariableBinding and Derived Classes
The abstract base class represents a "pointer to a (part of a) variable". It
is used in conjunction with ParameterBindings to specify inputs to an entry
point node. The SimpleVariableBinding is a pointer to an entire variable,
the ArrayIndexVariableBinding is a pointer to a specific index in an array
variable, and the DictionaryKeyVariableBinding is a pointer to a specific
key in a dictionary variable.
ParameterBinding and Derived Classes
The abstract base class represents a "pointer to a (part of a) parameter". It
parallels the VariableBinding hierarchy and it is used to specify the inputs
to an entry point node. The SimpleParameterBinding is a pointer to a
non-array, non-dictionary parameter, the ArrayIndexParameterBinding is a
pointer to a specific index of an array parameter and the
DictionaryKeyParameterBinding is a pointer to a specific key of a dictionary
parameter.
How to create an entry point for an existing ML.NET component
  1. Add a LoadableClass assembly attribute with the SignatureEntryPointModule signature as shown here.
  2. Create a public static method, that:

    1. Takes an object representing the arguments of the component you want to expose as shown here
    2. Initializes and runs the component, returning one of the nested classes of Microsoft.ML.EntryPoints.CommonOutputs
    3. Is annotated with the TlcModule.EntryPoint attribute
For an example of a transformer as an entrypoint, see OneHotVectorizer.
For a trainer-estimator, see LogisticRegression.

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
EntryPoints.md
Latest commit
History
History
230 lines (199 loc) · 10.5 KB
EntryPoints.md
File metadata and controls
230 lines (199 loc) · 10.5 KB
Raw
Entry Points And Helper Classes
Overview
Entry points are a way to interface with ML.NET components, by specifying an execution graph of connected inputs and outputs of those components.
Both the manifest describing available components and their inputs/outputs, and an "experiment" graph description, are expressed in JSON.
The recommended way of interacting with ML.NET through other, non-.NET programming languages, is by composing, and exchanging pipelines or experiment graphs.
Through the documentation, we also refer to entry points as 'entry points nodes', and that is because they are the nodes of the graph representing the experiment.
The graph 'variables', the various values of the experiment graph JSON properties, serve to describe the relationship between the entry point nodes.
The 'variables' are therefore the edges of the DAG (Directed Acyclic Graph).
All of ML.NET entry points are described by their manifest. The manifest is another JSON object that documents and describes the structure of an entry points.
Manifests are referenced to understand what an entry point does, and how it should be constructed, in a graph.
This document briefly describes the structure of the entry points, the structure of an entry point manifest, and mentions the ML.NET classes that help construct an entry point graph.
EntryPoint manifest - the definition of an entry point
The components manifest is build by scanning the ML.NET assemblies through reflection and searching for types having the: SignatureEntryPointModule signature in their LoadableClass assembly attribute definition.
An example of an entry point manifest object, specifically for the ColumnTypeConverter transform, is:
{"Name": "Transforms.ColumnTypeConverter","Desc": "Converts a column to a different type, using standard conversions.","FriendlyName": "Convert Transform","ShortName": "Convert","Inputs": [{"Name": "Column","Type": {"Kind": "Array","ItemType": {"Kind": "Struct","Fields": [{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 150,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Name","Type": "String","Desc": "Name of the new column","Aliases": ["name"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Source","Type": "String","Desc": "Name of the source column","Aliases": ["src"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}]}},"Desc": "New column definition(s) (optional form: name:type:src)","Aliases": ["col"],"Required": true,"SortOrder": 1,"IsNullable": false},{"Name": "Data","Type": "DataView","Desc": "Input dataset","Required": true,"SortOrder": 2,"IsNullable": false},{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 2,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}],"Outputs": [{"Name": "OutputData","Type": "DataView","Desc": "Transformed dataset"},{"Name": "Model","Type": "TransformModel","Desc": "Transform model"}],"InputKind": ["ITransformInput"],"OutputKind": ["ITransformOutput"]}
The respective entry point, constructed based on this manifest would be:
{"Name": "Transforms.ColumnTypeConverter","Inputs": {"Column": [{"Name": "Features","Source": "Features"}],"Data": "$data0","ResultType": "R4"},"Outputs": {"OutputData": "$Convert_Output","Model": "$Convert_TransformModel"}}
EntryPointGraph
This class encapsulates the list of nodes (EntryPointNode) and edges
(EntryPointVariable inside a RunContext) of the graph.
EntryPointNode
This class represents a node in the graph, and wraps an entry point call. It
has methods for creating and running entry points. It also has a reference to
the RunContext to allow it to get and set values from EntryPointVariables.
To express the inputs that are set through variables, a set of dictionaries
are used. The InputBindingMap maps an input parameter name to a list of
ParameterBindings. The InputMap maps a ParameterBinding to a
VariableBinding. For example, if the JSON looks like this:
'foo': '$bar'
the InputBindingMap will have one entry that maps the string "foo" to a list
that has only one element, a SimpleParameterBinding with the name "foo" and
the InputMap will map the SimpleParameterBinding to a
SimpleVariableBinding with the name "bar". For a more complicated example,
let's say we have this JSON:
'foo': ['$bar[3]','$baz']
the InputBindingMap will have one entry that maps the string "foo" to a list
that has two elements, an ArrayIndexParameterBinding with the name "foo" and
index 0 and another one with index 1. The InputMap will map the first
ArrayIndexParameterBinding to an ArrayIndexVariableBinding with name "bar"
and index 3 and the second ArrayIndexParameterBinding to a
SimpleVariableBinding with the name "baz".
For outputs, a node assumes that an output is mapped to a variable, so the
OutputMap is a simple dictionary from string to string.
EntryPointVariable
This class represents an edge in the entry point graph. It has a name, a type
and a value. Variables can be simple, arrays and/or dictionaries. Currently,
only data views, file handles, predictor models and transform models are
allowed as element types for a variable.
RunContext
This class is just a container for all the variables in a graph.
VariableBinding and Derived Classes
The abstract base class represents a "pointer to a (part of a) variable". It
is used in conjunction with ParameterBindings to specify inputs to an entry
point node. The SimpleVariableBinding is a pointer to an entire variable,
the ArrayIndexVariableBinding is a pointer to a specific index in an array
variable, and the DictionaryKeyVariableBinding is a pointer to a specific
key in a dictionary variable.
ParameterBinding and Derived Classes
The abstract base class represents a "pointer to a (part of a) parameter". It
parallels the VariableBinding hierarchy and it is used to specify the inputs
to an entry point node. The SimpleParameterBinding is a pointer to a
non-array, non-dictionary parameter, the ArrayIndexParameterBinding is a
pointer to a specific index of an array parameter and the
DictionaryKeyParameterBinding is a pointer to a specific key of a dictionary
parameter.
How to create an entry point for an existing ML.NET component
  1. Add a LoadableClass assembly attribute with the SignatureEntryPointModule signature as shown here.
  2. Create a public static method, that:

    1. Takes an object representing the arguments of the component you want to expose as shown here
    2. Initializes and runs the component, returning one of the nested classes of Microsoft.ML.EntryPoints.CommonOutputs
    3. Is annotated with the TlcModule.EntryPoint attribute
For an example of a transformer as an entrypoint, see OneHotVectorizer.
For a trainer-estimator, see LogisticRegression.

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
EntryPoints.md
Latest commit
History
History
230 lines (199 loc) · 10.5 KB
EntryPoints.md
File metadata and controls
230 lines (199 loc) · 10.5 KB
Raw
Entry Points And Helper Classes
Overview
Entry points are a way to interface with ML.NET components, by specifying an execution graph of connected inputs and outputs of those components.
Both the manifest describing available components and their inputs/outputs, and an "experiment" graph description, are expressed in JSON.
The recommended way of interacting with ML.NET through other, non-.NET programming languages, is by composing, and exchanging pipelines or experiment graphs.
Through the documentation, we also refer to entry points as 'entry points nodes', and that is because they are the nodes of the graph representing the experiment.
The graph 'variables', the various values of the experiment graph JSON properties, serve to describe the relationship between the entry point nodes.
The 'variables' are therefore the edges of the DAG (Directed Acyclic Graph).
All of ML.NET entry points are described by their manifest. The manifest is another JSON object that documents and describes the structure of an entry points.
Manifests are referenced to understand what an entry point does, and how it should be constructed, in a graph.
This document briefly describes the structure of the entry points, the structure of an entry point manifest, and mentions the ML.NET classes that help construct an entry point graph.
EntryPoint manifest - the definition of an entry point
The components manifest is build by scanning the ML.NET assemblies through reflection and searching for types having the: SignatureEntryPointModule signature in their LoadableClass assembly attribute definition.
An example of an entry point manifest object, specifically for the ColumnTypeConverter transform, is:
{"Name": "Transforms.ColumnTypeConverter","Desc": "Converts a column to a different type, using standard conversions.","FriendlyName": "Convert Transform","ShortName": "Convert","Inputs": [{"Name": "Column","Type": {"Kind": "Array","ItemType": {"Kind": "Struct","Fields": [{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 150,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Name","Type": "String","Desc": "Name of the new column","Aliases": ["name"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Source","Type": "String","Desc": "Name of the source column","Aliases": ["src"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}]}},"Desc": "New column definition(s) (optional form: name:type:src)","Aliases": ["col"],"Required": true,"SortOrder": 1,"IsNullable": false},{"Name": "Data","Type": "DataView","Desc": "Input dataset","Required": true,"SortOrder": 2,"IsNullable": false},{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 2,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}],"Outputs": [{"Name": "OutputData","Type": "DataView","Desc": "Transformed dataset"},{"Name": "Model","Type": "TransformModel","Desc": "Transform model"}],"InputKind": ["ITransformInput"],"OutputKind": ["ITransformOutput"]}
The respective entry point, constructed based on this manifest would be:
{"Name": "Transforms.ColumnTypeConverter","Inputs": {"Column": [{"Name": "Features","Source": "Features"}],"Data": "$data0","ResultType": "R4"},"Outputs": {"OutputData": "$Convert_Output","Model": "$Convert_TransformModel"}}
EntryPointGraph
This class encapsulates the list of nodes (EntryPointNode) and edges
(EntryPointVariable inside a RunContext) of the graph.
EntryPointNode
This class represents a node in the graph, and wraps an entry point call. It
has methods for creating and running entry points. It also has a reference to
the RunContext to allow it to get and set values from EntryPointVariables.
To express the inputs that are set through variables, a set of dictionaries
are used. The InputBindingMap maps an input parameter name to a list of
ParameterBindings. The InputMap maps a ParameterBinding to a
VariableBinding. For example, if the JSON looks like this:
'foo': '$bar'
the InputBindingMap will have one entry that maps the string "foo" to a list
that has only one element, a SimpleParameterBinding with the name "foo" and
the InputMap will map the SimpleParameterBinding to a
SimpleVariableBinding with the name "bar". For a more complicated example,
let's say we have this JSON:
'foo': ['$bar[3]','$baz']
the InputBindingMap will have one entry that maps the string "foo" to a list
that has two elements, an ArrayIndexParameterBinding with the name "foo" and
index 0 and another one with index 1. The InputMap will map the first
ArrayIndexParameterBinding to an ArrayIndexVariableBinding with name "bar"
and index 3 and the second ArrayIndexParameterBinding to a
SimpleVariableBinding with the name "baz".
For outputs, a node assumes that an output is mapped to a variable, so the
OutputMap is a simple dictionary from string to string.
EntryPointVariable
This class represents an edge in the entry point graph. It has a name, a type
and a value. Variables can be simple, arrays and/or dictionaries. Currently,
only data views, file handles, predictor models and transform models are
allowed as element types for a variable.
RunContext
This class is just a container for all the variables in a graph.
VariableBinding and Derived Classes
The abstract base class represents a "pointer to a (part of a) variable". It
is used in conjunction with ParameterBindings to specify inputs to an entry
point node. The SimpleVariableBinding is a pointer to an entire variable,
the ArrayIndexVariableBinding is a pointer to a specific index in an array
variable, and the DictionaryKeyVariableBinding is a pointer to a specific
key in a dictionary variable.
ParameterBinding and Derived Classes
The abstract base class represents a "pointer to a (part of a) parameter". It
parallels the VariableBinding hierarchy and it is used to specify the inputs
to an entry point node. The SimpleParameterBinding is a pointer to a
non-array, non-dictionary parameter, the ArrayIndexParameterBinding is a
pointer to a specific index of an array parameter and the
DictionaryKeyParameterBinding is a pointer to a specific key of a dictionary
parameter.
How to create an entry point for an existing ML.NET component
  1. Add a LoadableClass assembly attribute with the SignatureEntryPointModule signature as shown here.
  2. Create a public static method, that:

    1. Takes an object representing the arguments of the component you want to expose as shown here
    2. Initializes and runs the component, returning one of the nested classes of Microsoft.ML.EntryPoints.CommonOutputs
    3. Is annotated with the TlcModule.EntryPoint attribute
For an example of a transformer as an entrypoint, see OneHotVectorizer.
For a trainer-estimator, see LogisticRegression.

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
EntryPoints.md
Latest commit
History
History
230 lines (199 loc) · 10.5 KB
EntryPoints.md
File metadata and controls
230 lines (199 loc) · 10.5 KB
Raw
Entry Points And Helper Classes
Overview
Entry points are a way to interface with ML.NET components, by specifying an execution graph of connected inputs and outputs of those components.
Both the manifest describing available components and their inputs/outputs, and an "experiment" graph description, are expressed in JSON.
The recommended way of interacting with ML.NET through other, non-.NET programming languages, is by composing, and exchanging pipelines or experiment graphs.
Through the documentation, we also refer to entry points as 'entry points nodes', and that is because they are the nodes of the graph representing the experiment.
The graph 'variables', the various values of the experiment graph JSON properties, serve to describe the relationship between the entry point nodes.
The 'variables' are therefore the edges of the DAG (Directed Acyclic Graph).
All of ML.NET entry points are described by their manifest. The manifest is another JSON object that documents and describes the structure of an entry points.
Manifests are referenced to understand what an entry point does, and how it should be constructed, in a graph.
This document briefly describes the structure of the entry points, the structure of an entry point manifest, and mentions the ML.NET classes that help construct an entry point graph.
EntryPoint manifest - the definition of an entry point
The components manifest is build by scanning the ML.NET assemblies through reflection and searching for types having the: SignatureEntryPointModule signature in their LoadableClass assembly attribute definition.
An example of an entry point manifest object, specifically for the ColumnTypeConverter transform, is:
{"Name": "Transforms.ColumnTypeConverter","Desc": "Converts a column to a different type, using standard conversions.","FriendlyName": "Convert Transform","ShortName": "Convert","Inputs": [{"Name": "Column","Type": {"Kind": "Array","ItemType": {"Kind": "Struct","Fields": [{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 150,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Name","Type": "String","Desc": "Name of the new column","Aliases": ["name"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Source","Type": "String","Desc": "Name of the source column","Aliases": ["src"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}]}},"Desc": "New column definition(s) (optional form: name:type:src)","Aliases": ["col"],"Required": true,"SortOrder": 1,"IsNullable": false},{"Name": "Data","Type": "DataView","Desc": "Input dataset","Required": true,"SortOrder": 2,"IsNullable": false},{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 2,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}],"Outputs": [{"Name": "OutputData","Type": "DataView","Desc": "Transformed dataset"},{"Name": "Model","Type": "TransformModel","Desc": "Transform model"}],"InputKind": ["ITransformInput"],"OutputKind": ["ITransformOutput"]}
The respective entry point, constructed based on this manifest would be:
{"Name": "Transforms.ColumnTypeConverter","Inputs": {"Column": [{"Name": "Features","Source": "Features"}],"Data": "$data0","ResultType": "R4"},"Outputs": {"OutputData": "$Convert_Output","Model": "$Convert_TransformModel"}}
EntryPointGraph
This class encapsulates the list of nodes (EntryPointNode) and edges
(EntryPointVariable inside a RunContext) of the graph.
EntryPointNode
This class represents a node in the graph, and wraps an entry point call. It
has methods for creating and running entry points. It also has a reference to
the RunContext to allow it to get and set values from EntryPointVariables.
To express the inputs that are set through variables, a set of dictionaries
are used. The InputBindingMap maps an input parameter name to a list of
ParameterBindings. The InputMap maps a ParameterBinding to a
VariableBinding. For example, if the JSON looks like this:
'foo': '$bar'
the InputBindingMap will have one entry that maps the string "foo" to a list
that has only one element, a SimpleParameterBinding with the name "foo" and
the InputMap will map the SimpleParameterBinding to a
SimpleVariableBinding with the name "bar". For a more complicated example,
let's say we have this JSON:
'foo': ['$bar[3]','$baz']
the InputBindingMap will have one entry that maps the string "foo" to a list
that has two elements, an ArrayIndexParameterBinding with the name "foo" and
index 0 and another one with index 1. The InputMap will map the first
ArrayIndexParameterBinding to an ArrayIndexVariableBinding with name "bar"
and index 3 and the second ArrayIndexParameterBinding to a
SimpleVariableBinding with the name "baz".
For outputs, a node assumes that an output is mapped to a variable, so the
OutputMap is a simple dictionary from string to string.
EntryPointVariable
This class represents an edge in the entry point graph. It has a name, a type
and a value. Variables can be simple, arrays and/or dictionaries. Currently,
only data views, file handles, predictor models and transform models are
allowed as element types for a variable.
RunContext
This class is just a container for all the variables in a graph.
VariableBinding and Derived Classes
The abstract base class represents a "pointer to a (part of a) variable". It
is used in conjunction with ParameterBindings to specify inputs to an entry
point node. The SimpleVariableBinding is a pointer to an entire variable,
the ArrayIndexVariableBinding is a pointer to a specific index in an array
variable, and the DictionaryKeyVariableBinding is a pointer to a specific
key in a dictionary variable.
ParameterBinding and Derived Classes
The abstract base class represents a "pointer to a (part of a) parameter". It
parallels the VariableBinding hierarchy and it is used to specify the inputs
to an entry point node. The SimpleParameterBinding is a pointer to a
non-array, non-dictionary parameter, the ArrayIndexParameterBinding is a
pointer to a specific index of an array parameter and the
DictionaryKeyParameterBinding is a pointer to a specific key of a dictionary
parameter.
How to create an entry point for an existing ML.NET component
  1. Add a LoadableClass assembly attribute with the SignatureEntryPointModule signature as shown here.
  2. Create a public static method, that:

    1. Takes an object representing the arguments of the component you want to expose as shown here
    2. Initializes and runs the component, returning one of the nested classes of Microsoft.ML.EntryPoints.CommonOutputs
    3. Is annotated with the TlcModule.EntryPoint attribute
For an example of a transformer as an entrypoint, see OneHotVectorizer.
For a trainer-estimator, see LogisticRegression.

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
EntryPoints.md
Latest commit
History
History
230 lines (199 loc) · 10.5 KB
EntryPoints.md
File metadata and controls
230 lines (199 loc) · 10.5 KB
Raw
Entry Points And Helper Classes
Overview
Entry points are a way to interface with ML.NET components, by specifying an execution graph of connected inputs and outputs of those components.
Both the manifest describing available components and their inputs/outputs, and an "experiment" graph description, are expressed in JSON.
The recommended way of interacting with ML.NET through other, non-.NET programming languages, is by composing, and exchanging pipelines or experiment graphs.
Through the documentation, we also refer to entry points as 'entry points nodes', and that is because they are the nodes of the graph representing the experiment.
The graph 'variables', the various values of the experiment graph JSON properties, serve to describe the relationship between the entry point nodes.
The 'variables' are therefore the edges of the DAG (Directed Acyclic Graph).
All of ML.NET entry points are described by their manifest. The manifest is another JSON object that documents and describes the structure of an entry points.
Manifests are referenced to understand what an entry point does, and how it should be constructed, in a graph.
This document briefly describes the structure of the entry points, the structure of an entry point manifest, and mentions the ML.NET classes that help construct an entry point graph.
EntryPoint manifest - the definition of an entry point
The components manifest is build by scanning the ML.NET assemblies through reflection and searching for types having the: SignatureEntryPointModule signature in their LoadableClass assembly attribute definition.
An example of an entry point manifest object, specifically for the ColumnTypeConverter transform, is:
{"Name": "Transforms.ColumnTypeConverter","Desc": "Converts a column to a different type, using standard conversions.","FriendlyName": "Convert Transform","ShortName": "Convert","Inputs": [{"Name": "Column","Type": {"Kind": "Array","ItemType": {"Kind": "Struct","Fields": [{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 150,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Name","Type": "String","Desc": "Name of the new column","Aliases": ["name"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null},{"Name": "Source","Type": "String","Desc": "Name of the source column","Aliases": ["src"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}]}},"Desc": "New column definition(s) (optional form: name:type:src)","Aliases": ["col"],"Required": true,"SortOrder": 1,"IsNullable": false},{"Name": "Data","Type": "DataView","Desc": "Input dataset","Required": true,"SortOrder": 2,"IsNullable": false},{"Name": "ResultType","Type": {"Kind": "Enum","Values": ["I1","I2","U2","I4","U4","I8","U8","R4","Num","R8","TX","Text","TXT","BL","Bool","TimeSpan","TS","DT","DateTime","DZ","DateTimeZone","UG","U16"]},"Desc": "The result type","Aliases": ["type"],"Required": false,"SortOrder": 2,"IsNullable": true,"Default": null},{"Name": "Range","Type": "String","Desc": "For a key column, this defines the range of values","Aliases": ["key"],"Required": false,"SortOrder": 150,"IsNullable": false,"Default": null}],"Outputs": [{"Name": "OutputData","Type": "DataView","Desc": "Transformed dataset"},{"Name": "Model","Type": "TransformModel","Desc": "Transform model"}],"InputKind": ["ITransformInput"],"OutputKind": ["ITransformOutput"]}
The respective entry point, constructed based on this manifest would be:
{"Name": "Transforms.ColumnTypeConverter","Inputs": {"Column": [{"Name": "Features","Source": "Features"}],"Data": "$data0","ResultType": "R4"},"Outputs": {"OutputData": "$Convert_Output","Model": "$Convert_TransformModel"}}
EntryPointGraph
This class encapsulates the list of nodes (EntryPointNode) and edges
(EntryPointVariable inside a RunContext) of the graph.
EntryPointNode
This class represents a node in the graph, and wraps an entry point call. It
has methods for creating and running entry points. It also has a reference to
the RunContext to allow it to get and set values from EntryPointVariables.
To express the inputs that are set through variables, a set of dictionaries
are used. The InputBindingMap maps an input parameter name to a list of
ParameterBindings. The InputMap maps a ParameterBinding to a
VariableBinding. For example, if the JSON looks like this:
'foo': '$bar'
the InputBindingMap will have one entry that maps the string "foo" to a list
that has only one element, a SimpleParameterBinding with the name "foo" and
the InputMap will map the SimpleParameterBinding to a
SimpleVariableBinding with the name "bar". For a more complicated example,
let's say we have this JSON:
'foo': ['$bar[3]','$baz']
the InputBindingMap will have one entry that maps the string "foo" to a list
that has two elements, an ArrayIndexParameterBinding with the name "foo" and
index 0 and another one with index 1. The InputMap will map the first
ArrayIndexParameterBinding to an ArrayIndexVariableBinding with name "bar"
and index 3 and the second ArrayIndexParameterBinding to a
SimpleVariableBinding with the name "baz".
For outputs, a node assumes that an output is mapped to a variable, so the
OutputMap is a simple dictionary from string to string.
EntryPointVariable
This class represents an edge in the entry point graph. It has a name, a type
and a value. Variables can be simple, arrays and/or dictionaries. Currently,
only data views, file handles, predictor models and transform models are
allowed as element types for a variable.
RunContext
This class is just a container for all the variables in a graph.
VariableBinding and Derived Classes
The abstract base class represents a "pointer to a (part of a) variable". It
is used in conjunction with ParameterBindings to specify inputs to an entry
point node. The SimpleVariableBinding is a pointer to an entire variable,
the ArrayIndexVariableBinding is a pointer to a specific index in an array
variable, and the DictionaryKeyVariableBinding is a pointer to a specific
key in a dictionary variable.
ParameterBinding and Derived Classes
The abstract base class represents a "pointer to a (part of a) parameter". It
parallels the VariableBinding hierarchy and it is used to specify the inputs
to an entry point node. The SimpleParameterBinding is a pointer to a
non-array, non-dictionary parameter, the ArrayIndexParameterBinding is a
pointer to a specific index of an array parameter and the
DictionaryKeyParameterBinding is a pointer to a specific key of a dictionary
parameter.
How to create an entry point for an existing ML.NET component
  1. Add a LoadableClass assembly attribute with the SignatureEntryPointModule signature as shown here.
  2. Create a public static method, that:

    1. Takes an object representing the arguments of the component you want to expose as shown here
    2. Initializes and runs the component, returning one of the nested classes of Microsoft.ML.EntryPoints.CommonOutputs
    3. Is annotated with the TlcModule.EntryPoint attribute
For an example of a transformer as an entrypoint, see OneHotVectorizer.
For a trainer-estimator, see LogisticRegression.