TermStaticExtensions.ToKey TermStaticExtensions.ToKey Method

Definition

Overloads

ToKey(Scalar<Boolean>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<Boolean>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

ToKey(VarVector<String>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<String>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because the empty string is never entered into the dictionary, it will always map to the missing key.

ToKey(VarVector<UInt16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<UInt16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(VarVector<UInt32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<UInt32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(VarVector<UInt64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<UInt64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(Vector<Boolean>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<Boolean>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

ToKey(Vector<Byte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<Byte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(Vector<Double>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<Double>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(Vector<Int16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<Int16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(Vector<Int32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<Int32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(Vector<Int64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<Int64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(Vector<SByte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<SByte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(Vector<Single>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<Single>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(Vector<String>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<String>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because the empty string is never entered into the dictionary, it will always map to the missing key.

ToKey(Vector<UInt16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<UInt16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(Vector<UInt32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<UInt32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(VarVector<Single>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<Single>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(VarVector<SByte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<SByte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(Vector<UInt64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<UInt64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(VarVector<Int32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<Int32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(VarVector<Int64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<Int64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(Scalar<Byte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<Byte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

ToKey(Scalar<Double>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<Double>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key.

ToKey(Scalar<Int16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<Int16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

ToKey(Scalar<Int32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<Int32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

ToKey(Scalar<SByte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<SByte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

ToKey(Scalar<Single>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<Single>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key.

ToKey(Scalar<Int64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<Int64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

ToKey(Scalar<UInt16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<UInt16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

ToKey(Scalar<UInt32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<UInt32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

ToKey(Scalar<UInt64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<UInt64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

ToKey(VarVector<Boolean>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<Boolean>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

ToKey(VarVector<Byte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<Byte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(VarVector<Double>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<Double>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(VarVector<Int16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<Int16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

ToKey(Scalar<String>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<String>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because the empty string is never entered into the dictionary, it will always map to the missing key.

ToKey<T>(Vector<Key<T,Boolean>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,Boolean>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(VarVector<Key<T,Single>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,Single>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(VarVector<Key<T,String>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,String>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because the empty string is never entered into the dictionary, it will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(VarVector<Key<T,UInt16>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,UInt16>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(VarVector<Key<T,UInt32>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,UInt32>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(VarVector<Key<T,UInt64>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,UInt64>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Vector<Key<T,Byte>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,Byte>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Vector<Key<T,UInt16>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,UInt16>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Vector<Key<T,Int16>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,Int16>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Vector<Key<T,Int32>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,Int32>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Vector<Key<T,Int64>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,Int64>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Vector<Key<T,SByte>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,SByte>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Vector<Key<T,Single>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,Single>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Vector<Key<T,String>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,String>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because the empty string is never entered into the dictionary, it will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(VarVector<Key<T,SByte>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,SByte>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Vector<Key<T,Double>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,Double>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(VarVector<Key<T,Int64>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,Int64>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Key<T,UInt16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,UInt16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(VarVector<Key<T,Int16>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,Int16>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Vector<Key<T,UInt32>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,UInt32>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Key<T,Boolean>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,Boolean>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Key<T,Byte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,Byte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Key<T,Double>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,Double>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Key<T,Int16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,Int16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Key<T,Int32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,Int32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Key<T,Int64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,Int64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Key<T,SByte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,SByte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Key<T,Single>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,Single>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Key<T,String>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,String>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because the empty string is never entered into the dictionary, it will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Key<T,UInt32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,UInt32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Key<T,UInt64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,UInt64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(VarVector<Key<T,Boolean>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,Boolean>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(VarVector<Key<T,Byte>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,Byte>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(VarVector<Key<T,Double>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,Double>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(VarVector<Key<T,Int32>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,Int32>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey<T>(Vector<Key<T,UInt64>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,UInt64>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

ToKey(Scalar<Boolean>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<Boolean>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

public static Microsoft.ML.StaticPipe.Key<uint,bool> ToKey (this Microsoft.ML.StaticPipe.Scalar<bool> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<bool>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Scalar<bool> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<bool>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, bool>

Parameters

input
Scalar<Boolean>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Boolean>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(VarVector<String>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<String>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because the empty string is never entered into the dictionary, it will always map to the missing key.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,string>> ToKey (this Microsoft.ML.StaticPipe.VarVector<string> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<char>>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<string> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<char>>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, string>>

Parameters

input
VarVector<String>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<Char>>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(VarVector<UInt16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<UInt16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,ushort>> ToKey (this Microsoft.ML.StaticPipe.VarVector<ushort> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ushort>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<uint16> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint16>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, uint16>>

Parameters

input
VarVector<UInt16>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt16>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(VarVector<UInt32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<UInt32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,uint>> ToKey (this Microsoft.ML.StaticPipe.VarVector<uint> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<uint32> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint32>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, uint32>>

Parameters

input
VarVector<UInt32>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt32>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(VarVector<UInt64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<UInt64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,ulong>> ToKey (this Microsoft.ML.StaticPipe.VarVector<ulong> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ulong>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<uint64> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint64>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, uint64>>

Parameters

input
VarVector<UInt64>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt64>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Vector<Boolean>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<Boolean>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,bool>> ToKey (this Microsoft.ML.StaticPipe.Vector<bool> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<bool>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<bool> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<bool>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, bool>>

Parameters

input
Vector<Boolean>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Boolean>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Vector<Byte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<Byte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,byte>> ToKey (this Microsoft.ML.StaticPipe.Vector<byte> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<byte>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<byte> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<byte>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, byte>>

Parameters

input
Vector<Byte>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Byte>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Vector<Double>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<Double>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,double>> ToKey (this Microsoft.ML.StaticPipe.Vector<double> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<double>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<double> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<double>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, double>>

Parameters

input
Vector<Double>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Double>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Vector<Int16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<Int16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,short>> ToKey (this Microsoft.ML.StaticPipe.Vector<short> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<short>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<int16> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int16>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, int16>>

Parameters

input
Vector<Int16>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int16>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Vector<Int32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<Int32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,int>> ToKey (this Microsoft.ML.StaticPipe.Vector<int> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<int> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, int>>

Parameters

input
Vector<Int32>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int32>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Vector<Int64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<Int64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,long>> ToKey (this Microsoft.ML.StaticPipe.Vector<long> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<long>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<int64> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int64>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, int64>>

Parameters

input
Vector<Int64>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int64>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Vector<SByte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<SByte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,sbyte>> ToKey (this Microsoft.ML.StaticPipe.Vector<sbyte> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<sbyte>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<sbyte> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<sbyte>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, sbyte>>

Parameters

input
Vector<SByte>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<SByte>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Vector<Single>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<Single>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,float>> ToKey (this Microsoft.ML.StaticPipe.Vector<float> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<float>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<single> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<single>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, single>>

Parameters

input
Vector<Single>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Single>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Vector<String>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<String>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because the empty string is never entered into the dictionary, it will always map to the missing key.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,string>> ToKey (this Microsoft.ML.StaticPipe.Vector<string> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<char>>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<string> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<char>>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, string>>

Parameters

input
Vector<String>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<Char>>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Vector<UInt16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<UInt16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,ushort>> ToKey (this Microsoft.ML.StaticPipe.Vector<ushort> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ushort>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<uint16> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint16>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, uint16>>

Parameters

input
Vector<UInt16>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt16>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Vector<UInt32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<UInt32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,uint>> ToKey (this Microsoft.ML.StaticPipe.Vector<uint> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<uint32> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint32>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, uint32>>

Parameters

input
Vector<UInt32>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt32>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(VarVector<Single>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<Single>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,float>> ToKey (this Microsoft.ML.StaticPipe.VarVector<float> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<float>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<single> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<single>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, single>>

Parameters

input
VarVector<Single>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Single>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(VarVector<SByte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<SByte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,sbyte>> ToKey (this Microsoft.ML.StaticPipe.VarVector<sbyte> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<sbyte>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<sbyte> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<sbyte>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, sbyte>>

Parameters

input
VarVector<SByte>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<SByte>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Vector<UInt64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Vector<UInt64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,ulong>> ToKey (this Microsoft.ML.StaticPipe.Vector<ulong> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ulong>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<uint64> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint64>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, uint64>>

Parameters

input
Vector<UInt64>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt64>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(VarVector<Int32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<Int32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,int>> ToKey (this Microsoft.ML.StaticPipe.VarVector<int> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<int> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, int>>

Parameters

input
VarVector<Int32>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int32>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(VarVector<Int64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<Int64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,long>> ToKey (this Microsoft.ML.StaticPipe.VarVector<long> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<long>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<int64> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int64>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, int64>>

Parameters

input
VarVector<Int64>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int64>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Scalar<Byte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<Byte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

public static Microsoft.ML.StaticPipe.Key<uint,byte> ToKey (this Microsoft.ML.StaticPipe.Scalar<byte> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<byte>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Scalar<byte> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<byte>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, byte>

Parameters

input
Scalar<Byte>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Byte>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Scalar<Double>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<Double>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key.

public static Microsoft.ML.StaticPipe.Key<uint,double> ToKey (this Microsoft.ML.StaticPipe.Scalar<double> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<double>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Scalar<double> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<double>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, double>

Parameters

input
Scalar<Double>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Double>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Scalar<Int16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<Int16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

public static Microsoft.ML.StaticPipe.Key<uint,short> ToKey (this Microsoft.ML.StaticPipe.Scalar<short> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<short>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Scalar<int16> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int16>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, int16>

Parameters

input
Scalar<Int16>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int16>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Scalar<Int32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<Int32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

public static Microsoft.ML.StaticPipe.Key<uint,int> ToKey (this Microsoft.ML.StaticPipe.Scalar<int> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Scalar<int> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, int>

Parameters

input
Scalar<Int32>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int32>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Scalar<SByte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<SByte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

public static Microsoft.ML.StaticPipe.Key<uint,sbyte> ToKey (this Microsoft.ML.StaticPipe.Scalar<sbyte> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<sbyte>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Scalar<sbyte> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<sbyte>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, sbyte>

Parameters

input
Scalar<SByte>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<SByte>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Scalar<Single>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<Single>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key.

public static Microsoft.ML.StaticPipe.Key<uint,float> ToKey (this Microsoft.ML.StaticPipe.Scalar<float> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<float>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Scalar<single> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<single>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, single>

Parameters

input
Scalar<Single>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Single>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Scalar<Int64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<Int64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

public static Microsoft.ML.StaticPipe.Key<uint,long> ToKey (this Microsoft.ML.StaticPipe.Scalar<long> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<long>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Scalar<int64> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int64>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, int64>

Parameters

input
Scalar<Int64>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int64>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Scalar<UInt16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<UInt16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

public static Microsoft.ML.StaticPipe.Key<uint,ushort> ToKey (this Microsoft.ML.StaticPipe.Scalar<ushort> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ushort>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Scalar<uint16> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint16>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, uint16>

Parameters

input
Scalar<UInt16>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt16>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Scalar<UInt32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<UInt32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

public static Microsoft.ML.StaticPipe.Key<uint,uint> ToKey (this Microsoft.ML.StaticPipe.Scalar<uint> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Scalar<uint32> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint32>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, uint32>

Parameters

input
Scalar<UInt32>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt32>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Scalar<UInt64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<UInt64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

public static Microsoft.ML.StaticPipe.Key<uint,ulong> ToKey (this Microsoft.ML.StaticPipe.Scalar<ulong> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ulong>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Scalar<uint64> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint64>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, uint64>

Parameters

input
Scalar<UInt64>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt64>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(VarVector<Boolean>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<Boolean>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,bool>> ToKey (this Microsoft.ML.StaticPipe.VarVector<bool> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<bool>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<bool> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<bool>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, bool>>

Parameters

input
VarVector<Boolean>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Boolean>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(VarVector<Byte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<Byte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,byte>> ToKey (this Microsoft.ML.StaticPipe.VarVector<byte> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<byte>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<byte> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<byte>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, byte>>

Parameters

input
VarVector<Byte>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Byte>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(VarVector<Double>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<Double>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,double>> ToKey (this Microsoft.ML.StaticPipe.VarVector<double> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<double>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<double> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<double>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, double>>

Parameters

input
VarVector<Double>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Double>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(VarVector<Int16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(VarVector<Int16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Zero is considered a valid value and so will be entered into the dictionary if observed. The potential perf implication in that case is that sparse input numeric vectors will map to dense output key vectors.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,short>> ToKey (this Microsoft.ML.StaticPipe.VarVector<short> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<short>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<int16> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int16>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, int16>>

Parameters

input
VarVector<Int16>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int16>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey(Scalar<String>, KeyOrdinality, Int32, TermStaticExtensions) ToKey(Scalar<String>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because the empty string is never entered into the dictionary, it will always map to the missing key.

public static Microsoft.ML.StaticPipe.Key<uint,string> ToKey (this Microsoft.ML.StaticPipe.Scalar<string> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<char>>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Scalar<string> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<char>>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, string>

Parameters

input
Scalar<String>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<Char>>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Vector<Key<T,Boolean>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,Boolean>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,bool>> ToKey<T> (this Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<T,bool>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<bool>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<'T, bool>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<bool>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, bool>>

Type Parameters

T

Parameters

input
Vector<Key<T,Boolean>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Boolean>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(VarVector<Key<T,Single>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,Single>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,float>> ToKey<T> (this Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<T,float>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<float>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<'T, single>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<single>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, single>>

Type Parameters

T

Parameters

input
VarVector<Key<T,Single>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Single>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(VarVector<Key<T,String>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,String>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because the empty string is never entered into the dictionary, it will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,string>> ToKey<T> (this Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<T,string>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<char>>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<'T, string>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<char>>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, string>>

Type Parameters

T

Parameters

input
VarVector<Key<T,String>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<Char>>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(VarVector<Key<T,UInt16>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,UInt16>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,ushort>> ToKey<T> (this Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<T,ushort>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ushort>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<'T, uint16>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint16>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, uint16>>

Type Parameters

T

Parameters

input
VarVector<Key<T,UInt16>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt16>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(VarVector<Key<T,UInt32>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,UInt32>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,uint>> ToKey<T> (this Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<T,uint>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<'T, uint32>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint32>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, uint32>>

Type Parameters

T

Parameters

input
VarVector<Key<T,UInt32>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt32>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(VarVector<Key<T,UInt64>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,UInt64>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,ulong>> ToKey<T> (this Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<T,ulong>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ulong>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<'T, uint64>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint64>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, uint64>>

Type Parameters

T

Parameters

input
VarVector<Key<T,UInt64>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt64>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Vector<Key<T,Byte>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,Byte>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,byte>> ToKey<T> (this Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<T,byte>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<byte>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<'T, byte>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<byte>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, byte>>

Type Parameters

T

Parameters

input
Vector<Key<T,Byte>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Byte>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Vector<Key<T,UInt16>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,UInt16>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,ushort>> ToKey<T> (this Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<T,ushort>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ushort>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<'T, uint16>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint16>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, uint16>>

Type Parameters

T

Parameters

input
Vector<Key<T,UInt16>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt16>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Vector<Key<T,Int16>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,Int16>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,short>> ToKey<T> (this Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<T,short>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<short>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<'T, int16>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int16>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, int16>>

Type Parameters

T

Parameters

input
Vector<Key<T,Int16>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int16>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Vector<Key<T,Int32>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,Int32>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,int>> ToKey<T> (this Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<T,int>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<'T, int>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, int>>

Type Parameters

T

Parameters

input
Vector<Key<T,Int32>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int32>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Vector<Key<T,Int64>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,Int64>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,long>> ToKey<T> (this Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<T,long>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<long>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<'T, int64>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int64>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, int64>>

Type Parameters

T

Parameters

input
Vector<Key<T,Int64>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int64>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Vector<Key<T,SByte>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,SByte>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,sbyte>> ToKey<T> (this Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<T,sbyte>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<sbyte>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<'T, sbyte>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<sbyte>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, sbyte>>

Type Parameters

T

Parameters

input
Vector<Key<T,SByte>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<SByte>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Vector<Key<T,Single>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,Single>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,float>> ToKey<T> (this Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<T,float>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<float>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<'T, single>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<single>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, single>>

Type Parameters

T

Parameters

input
Vector<Key<T,Single>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Single>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Vector<Key<T,String>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,String>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because the empty string is never entered into the dictionary, it will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,string>> ToKey<T> (this Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<T,string>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<char>>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<'T, string>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<char>>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, string>>

Type Parameters

T

Parameters

input
Vector<Key<T,String>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<Char>>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(VarVector<Key<T,SByte>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,SByte>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,sbyte>> ToKey<T> (this Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<T,sbyte>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<sbyte>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<'T, sbyte>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<sbyte>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, sbyte>>

Type Parameters

T

Parameters

input
VarVector<Key<T,SByte>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<SByte>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Vector<Key<T,Double>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,Double>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,double>> ToKey<T> (this Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<T,double>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<double>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<'T, double>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<double>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, double>>

Type Parameters

T

Parameters

input
Vector<Key<T,Double>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Double>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(VarVector<Key<T,Int64>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,Int64>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,long>> ToKey<T> (this Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<T,long>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<long>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<'T, int64>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int64>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, int64>>

Type Parameters

T

Parameters

input
VarVector<Key<T,Int64>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int64>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Key<T,UInt16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,UInt16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Key<uint,ushort> ToKey<T> (this Microsoft.ML.StaticPipe.Key<T,ushort> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ushort>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Key<'T, uint16> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint16>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, uint16>

Type Parameters

T

Parameters

input
Key<T,UInt16>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt16>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(VarVector<Key<T,Int16>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,Int16>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,short>> ToKey<T> (this Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<T,short>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<short>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<'T, int16>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int16>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, int16>>

Type Parameters

T

Parameters

input
VarVector<Key<T,Int16>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int16>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Vector<Key<T,UInt32>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,UInt32>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,uint>> ToKey<T> (this Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<T,uint>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<'T, uint32>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint32>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, uint32>>

Type Parameters

T

Parameters

input
Vector<Key<T,UInt32>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt32>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Key<T,Boolean>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,Boolean>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Key<uint,bool> ToKey<T> (this Microsoft.ML.StaticPipe.Key<T,bool> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<bool>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Key<'T, bool> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<bool>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, bool>

Type Parameters

T

Parameters

input
Key<T,Boolean>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Boolean>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Key<T,Byte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,Byte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Key<uint,byte> ToKey<T> (this Microsoft.ML.StaticPipe.Key<T,byte> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<byte>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Key<'T, byte> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<byte>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, byte>

Type Parameters

T

Parameters

input
Key<T,Byte>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Byte>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Key<T,Double>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,Double>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Key<uint,double> ToKey<T> (this Microsoft.ML.StaticPipe.Key<T,double> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<double>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Key<'T, double> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<double>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, double>

Type Parameters

T

Parameters

input
Key<T,Double>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Double>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Key<T,Int16>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,Int16>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Key<uint,short> ToKey<T> (this Microsoft.ML.StaticPipe.Key<T,short> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<short>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Key<'T, int16> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int16>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, int16>

Type Parameters

T

Parameters

input
Key<T,Int16>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int16>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Key<T,Int32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,Int32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Key<uint,int> ToKey<T> (this Microsoft.ML.StaticPipe.Key<T,int> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Key<'T, int> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, int>

Type Parameters

T

Parameters

input
Key<T,Int32>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int32>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Key<T,Int64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,Int64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Key<uint,long> ToKey<T> (this Microsoft.ML.StaticPipe.Key<T,long> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<long>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Key<'T, int64> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int64>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, int64>

Type Parameters

T

Parameters

input
Key<T,Int64>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int64>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Key<T,SByte>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,SByte>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Key<uint,sbyte> ToKey<T> (this Microsoft.ML.StaticPipe.Key<T,sbyte> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<sbyte>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Key<'T, sbyte> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<sbyte>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, sbyte>

Type Parameters

T

Parameters

input
Key<T,SByte>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<SByte>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Key<T,Single>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,Single>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Key<uint,float> ToKey<T> (this Microsoft.ML.StaticPipe.Key<T,float> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<float>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Key<'T, single> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<single>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, single>

Type Parameters

T

Parameters

input
Key<T,Single>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Single>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Key<T,String>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,String>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because the empty string is never entered into the dictionary, it will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Key<uint,string> ToKey<T> (this Microsoft.ML.StaticPipe.Key<T,string> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<char>>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Key<'T, string> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<char>>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, string>

Type Parameters

T

Parameters

input
Key<T,String>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<ReadOnlyMemory<Char>>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Key<T,UInt32>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,UInt32>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Key<uint,uint> ToKey<T> (this Microsoft.ML.StaticPipe.Key<T,uint> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Key<'T, uint32> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint32>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, uint32>

Type Parameters

T

Parameters

input
Key<T,UInt32>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt32>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Key<T,UInt64>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Key<T,UInt64>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Key<uint,ulong> ToKey<T> (this Microsoft.ML.StaticPipe.Key<T,ulong> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ulong>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Key<'T, uint64> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint64>.OnFit -> Microsoft.ML.StaticPipe.Key<uint32, uint64>

Type Parameters

T

Parameters

input
Key<T,UInt64>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt64>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(VarVector<Key<T,Boolean>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,Boolean>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,bool>> ToKey<T> (this Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<T,bool>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<bool>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<'T, bool>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<bool>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, bool>>

Type Parameters

T

Parameters

input
VarVector<Key<T,Boolean>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Boolean>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(VarVector<Key<T,Byte>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,Byte>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,byte>> ToKey<T> (this Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<T,byte>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<byte>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<'T, byte>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<byte>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, byte>>

Type Parameters

T

Parameters

input
VarVector<Key<T,Byte>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Byte>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(VarVector<Key<T,Double>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,Double>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. Because NaN floating point values are never entered into the dictionary, and they will always map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,double>> ToKey<T> (this Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<T,double>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<double>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<'T, double>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<double>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, double>>

Type Parameters

T

Parameters

input
VarVector<Key<T,Double>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Double>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(VarVector<Key<T,Int32>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(VarVector<Key<T,Int32>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint,int>> ToKey<T> (this Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<T,int>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<'T, int>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<int>.OnFit -> Microsoft.ML.StaticPipe.VarVector<Microsoft.ML.StaticPipe.Key<uint32, int>>

Type Parameters

T

Parameters

input
VarVector<Key<T,Int32>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<Int32>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

ToKey<T>(Vector<Key<T,UInt64>>, KeyOrdinality, Int32, TermStaticExtensions) ToKey<T>(Vector<Key<T,UInt64>>, KeyOrdinality, Int32, TermStaticExtensions)

Map values to a key-value representation, where the key type's values are those values observed in the input during fitting. During transformation, any values unobserved during fitting will map to the missing key. We are inputting a key type with values, and in that case the dictionary is considered to be built over the values of the keys, rather than the keys themselves. This also mean the key-values learned for the output will be a subset of the key-values in the input.

public static Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint,ulong>> ToKey<T> (this Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<T,ulong>> input, Microsoft.ML.StaticPipe.KeyOrdinality keyOrdinality = Microsoft.ML.StaticPipe.KeyOrdinality.Occurence, int maxItems = 1000000, Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<ulong>.OnFit onFit = null);
static member ToKey : Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<'T, uint64>> * Microsoft.ML.StaticPipe.KeyOrdinality * int * Microsoft.ML.StaticPipe.TermStaticExtensions.ToKeyFitResult<uint64>.OnFit -> Microsoft.ML.StaticPipe.Vector<Microsoft.ML.StaticPipe.Key<uint32, uint64>>

Type Parameters

T

Parameters

input
Vector<Key<T,UInt64>>

The input column.

keyOrdinality
KeyOrdinality KeyOrdinality

The ordering policy for what order values will appear in the enumerated set.

maxItems
Int32 Int32

The maximum number of items.

onFit
TermStaticExtensions.ToKeyFitResult<UInt64>.OnFit

Called upon fitting with the learnt enumeration on the dataset.

Returns

The key-valued column.

Applies to