public void GetLeafIds(ref VBuffer <float> dst)
{
EnsureCachedPosition();
_ectx.Assert(_input.Position >= 0);
_ectx.Assert(_cachedPosition == _input.Position);
if (_cachedLeafBuilderPosition != _input.Position)
{
if (_leafIdBuilder == null)
{
_leafIdBuilder = BufferBuilder <float> .CreateDefault();
}
_leafIdBuilder.Reset(_numLeaves, false);
var offset = 0;
var trees = ((ITreeEnsemble)_ensemble).GetTrees();
for (int i = 0; i < trees.Length; i++)
{
_leafIdBuilder.AddFeature(offset + _leafIds[i], 1);
offset += trees[i].NumLeaves;
}
_cachedLeafBuilderPosition = _input.Position;
}
_ectx.AssertValue(_leafIdBuilder);
_leafIdBuilder.GetResult(ref dst);
}
public void GetPathIds(ref VBuffer <float> dst)
{
EnsureCachedPosition();
_ectx.Assert(_input.Position >= 0);
_ectx.Assert(_cachedPosition == _input.Position);
if (_cachedPathBuilderPosition != _input.Position)
{
if (_pathIdBuilder == null)
{
_pathIdBuilder = BufferBuilder <float> .CreateDefault();
}
var trees = ((ITreeEnsemble)_ensemble).GetTrees();
_pathIdBuilder.Reset(_numLeaves - _numTrees, dense: false);
var offset = 0;
for (int i = 0; i < _numTrees; i++)
{
var numNodes = trees[i].NumLeaves - 1;
var nodes = _pathIds[i];
_ectx.AssertValue(nodes);
for (int j = 0; j < nodes.Count; j++)
{
var node = nodes[j];
_ectx.Assert(0 <= node && node < numNodes);
_pathIdBuilder.AddFeature(offset + node, 1);
}
offset += numNodes;
}
_cachedPathBuilderPosition = _input.Position;
}
_ectx.AssertValue(_pathIdBuilder);
_pathIdBuilder.GetResult(ref dst);
}
/// <summary>
/// This is for the indicator case - vector input and outputs should be concatenated.
/// </summary>
private ValueGetter <VBuffer <float> > MakeGetterInd(IRow input, int iinfo)
{
Host.AssertValue(input);
Host.Assert(Infos[iinfo].TypeSrc.IsVector);
Host.Assert(Infos[iinfo].TypeSrc.ItemType.IsKey);
int cv = Infos[iinfo].TypeSrc.VectorSize;
Host.Assert(cv >= 0);
var getSrc = RowCursorUtils.GetVecGetterAs <uint>(NumberType.U4, input, Infos[iinfo].Source);
var src = default(VBuffer <uint>);
var bldr = new BufferBuilder <float>(R4Adder.Instance);
int bitsPerKey = _bitsPerKey[iinfo];
return
((ref VBuffer <float> dst) =>
{
getSrc(ref src);
Host.Check(src.Length == cv || cv == 0);
bldr.Reset(src.Length * bitsPerKey, false);
int index = 0;
foreach (uint value in src.DenseValues())
{
EncodeValueToBinary(bldr, value, bitsPerKey, index * bitsPerKey);
index++;
}
bldr.GetResult(ref dst);
Contracts.Assert(dst.Length == src.Length * bitsPerKey);
});
}
/// <summary>
/// This is for the scalar case.
/// </summary>
private ValueGetter <VBuffer <float> > MakeGetterOne(IRow input, int iinfo)
{
Host.AssertValue(input);
Host.Assert(Infos[iinfo].TypeSrc.IsKey);
int bitsPerKey = _bitsPerKey[iinfo];
Host.Assert(bitsPerKey == _types[iinfo].VectorSize);
int dstLength = _types[iinfo].VectorSize;
Host.Assert(dstLength > 0);
var getSrc = RowCursorUtils.GetGetterAs <uint>(NumberType.U4, input, Infos[iinfo].Source);
var src = default(uint);
var bldr = new BufferBuilder <float>(R4Adder.Instance);
return
((ref VBuffer <float> dst) =>
{
getSrc(ref src);
bldr.Reset(bitsPerKey, false);
EncodeValueToBinary(bldr, src, bitsPerKey, 0);
bldr.GetResult(ref dst);
Contracts.Assert(dst.Length == bitsPerKey);
});
}
protected override void CopyOut(ref T[] src, ref VBuffer <T> dst)
{
var length = Utils.Size(src);
_bldr.Reset(length, false);
for (int i = 0; i < length; i++)
{
_bldr.AddFeature(i, src[i]);
}
_bldr.GetResult(ref dst);
}
private void GenerateBitSlotName(int iinfo, ref VBuffer <DvText> dst)
{
const string slotNamePrefix = "Bit";
var bldr = new BufferBuilder <DvText>(TextCombiner.Instance);
bldr.Reset(_bitsPerKey[iinfo], true);
for (int i = 0; i < _bitsPerKey[iinfo]; i++)
{
bldr.AddFeature(i, new DvText(slotNamePrefix + (_bitsPerKey[iinfo] - i - 1)));
}
bldr.GetResult(ref dst);
}
public void Reset()
{
_bldr.Reset(_slotLim, false);
_queue.Clear();
}
