public ColumnType GetMetadataTypeOrNull(string kind, int col)
 {
     _ectx.CheckNonEmpty(kind, nameof(kind));
     _ectx.CheckParam(col == 0, nameof(col));
     if (_hasSlotNames)
     {
         return(MetadataUtils.GetNamesType(_featureVectorSize));
     }
     return(null);
 }
                public IEnumerable <KeyValuePair <string, ColumnType> > GetMetadataTypes(int col)
                {
                    _ectx.CheckParam(0 <= col && col < ColumnCount, nameof(col));
                    yield return
                        (MetadataUtils.GetNamesType(_types[col].VectorSize).GetPair(MetadataUtils.Kinds.SlotNames));

                    if (col == PathIdx || col == LeafIdx)
                    {
                        yield return(BoolType.Instance.GetPair(MetadataUtils.Kinds.IsNormalized));
                    }
                }
            public override ColumnType GetMetadataTypeOrNull(string kind, int col)
            {
                Contracts.CheckParam(0 <= col && col < ColumnCount, nameof(col));
                Contracts.CheckNonEmpty(kind, nameof(kind));
                Contracts.Assert(Utils.Size(_slotNames) > 0);
                Contracts.Assert(col == 0);

                if (kind == MetadataUtils.Kinds.SlotNames)
                {
                    return(MetadataUtils.GetNamesType(_slotNames.Length));
                }
                return(base.GetMetadataTypeOrNull(kind, col));
            }
                public ColumnType GetMetadataTypeOrNull(string kind, int col)
                {
                    _ectx.CheckParam(0 <= col && col < ColumnCount, nameof(col));

                    if ((col == PathIdx || col == LeafIdx) && kind == MetadataUtils.Kinds.IsNormalized)
                    {
                        return(BoolType.Instance);
                    }
                    if (kind == MetadataUtils.Kinds.SlotNames)
                    {
                        return(MetadataUtils.GetNamesType(_types[col].VectorSize));
                    }
                    return(null);
                }
Пример #5
0
 public ColumnType GetMetadataTypeOrNull(string kind, int col)
 {
     _ectx.CheckNonEmpty(kind, nameof(kind));
     _ectx.CheckParam(0 <= col && col < ColumnCount, nameof(col));
     if (kind == MetadataUtils.Kinds.SlotNames && _getSlotNamesDict.ContainsKey(_names[col]))
     {
         return(MetadataUtils.GetNamesType(_columnTypes[col].VectorSize));
     }
     if (kind == MetadataUtils.Kinds.KeyValues && _getKeyValuesDict.ContainsKey(_names[col]))
     {
         return(MetadataUtils.GetNamesType(_columnTypes[col].KeyCount));
     }
     return(null);
 }
        private VectorType[] GetTypesAndMetadata()
        {
            var md    = Metadata;
            var types = new VectorType[Infos.Length];

            for (int iinfo = 0; iinfo < Infos.Length; iinfo++)
            {
                var type = Infos[iinfo].TypeSrc;

                // This ensures that our feature count doesn't overflow.
                Host.Check(type.ValueCount < int.MaxValue / 2);

                if (!type.IsVector)
                {
                    types[iinfo] = new VectorType(NumberType.Float, 2);
                }
                else
                {
                    types[iinfo] = new VectorType(NumberType.Float, type.AsVector, 2);

                    // Produce slot names metadata iff the source has (valid) slot names.
                    ColumnType typeNames;
                    if (!type.IsKnownSizeVector ||
                        (typeNames = Source.Schema.GetMetadataTypeOrNull(MetadataUtils.Kinds.SlotNames,
                                                                         Infos[iinfo].Source)) == null ||
                        typeNames.VectorSize != type.VectorSize ||
                        !typeNames.ItemType.IsText)
                    {
                        continue;
                    }
                }

                // Add slot names metadata.
                using (var bldr = md.BuildMetadata(iinfo))
                {
                    bldr.AddGetter <VBuffer <ReadOnlyMemory <char> > >(MetadataUtils.Kinds.SlotNames,
                                                                       MetadataUtils.GetNamesType(types[iinfo].VectorSize), GetSlotNames);
                }
            }
            md.Seal();
            return(types);
        }