public static ConvertContext Convert(Graph graph, QuantizationContext quantizationContext, int weightsBits)
{
var context = new ConvertContext {
Quantization = quantizationContext, WeightsBits = weightsBits
};
var converters = (from t in typeof(Converter).Assembly.ExportedTypes
let attrs = t.GetCustomAttributes <LayerConverterAttribute>()
where attrs.Any()
from attr in attrs
select new
{
Key = attr.Type,
Value = new { Type = t, Method = t.GetMethod("Convert") }
}).ToDictionary(x => x.Key, x => x.Value);
void ConvertLayer(Layer layer)
{
if (!context.ProcessMap.GetValueOrDefault(layer))
{
context.ProcessMap[layer] = true;
var type = layer.GetType();
if (converters.TryGetValue(type, out var info))
{
if (info.Method != null)
{
var converter = Activator.CreateInstance(info.Type);
var layerArg = info.Method.Invoke(converter, new object[] { layer, context });
if (layerArg != null)
{
context.LayerArguments.Add(layer, layerArg);
}
}
}
else
{
throw new LayerNotSupportedException(type.Name);
}
foreach (var conn in layer.InputConnectors)
{
var nextLayer = conn.Connection?.From.Owner;
if (nextLayer != null)
{
ConvertLayer(nextLayer);
}
}
}
}
foreach (var layer in graph.Outputs)
{
ConvertLayer(layer);
}
return(context);
}
public void FixupQuantization(QuantizedExclusiveConcatenation layer, QuantizationContext context)
{
var outRange = context.Distributions[layer.Output];
foreach (var input in layer.Inputs.Select(x => x.Connection.From))
{
context.Distributions[input] = outRange;
}
}
public void FixupQuantization(InputLayer layer, QuantizationContext context)
{
var min = (0 - context.Mean) / context.Std;
var max = (1 - context.Mean) / context.Std;
context.Distributions[layer.Output] = new ChannelwiseRange(new QuantizationRange {
Min = min, Max = max
}, layer.Output.Dimensions[1]);
}
public void FixupQuantization(InputLayer layer, QuantizationContext context)
{
if (context.DatasetProcess == Data.PostprocessMethods.Normalize0To1)
{
context.Distributions[layer.Output] = new ChannelwiseRange(new QuantizationRange {
Min = 0, Max = 1
}, layer.Output.Dimensions[1]);
}
else if (context.DatasetProcess == Data.PostprocessMethods.NormalizeMinus1To1)
{
context.Distributions[layer.Output] = new ChannelwiseRange(new QuantizationRange {
Min = -1, Max = 1
}, layer.Output.Dimensions[1]);
}
}
