public UnorderedMapVariableValuePtr(UnorderedMapVariableValuePtr other) : this(CNTKLibPINVOKE.new_UnorderedMapVariableValuePtr__SWIG_1(UnorderedMapVariableValuePtr.getCPtr(other)), true)
{
if (CNTKLibPINVOKE.SWIGPendingException.Pending)
{
throw CNTKLibPINVOKE.SWIGPendingException.Retrieve();
}
}
public void Evaluate(DataSet ds, out double lossValue, out double accValue)
{
// Extend graph
Variable yt = Variable.InputVariable(new int[] { DataSet.OutputSize }, DataType.Float);
Function loss = CNTKLib.CrossEntropyWithSoftmax(y, yt);
Function err = CNTKLib.ClassificationError(y, yt);
Evaluator evaluator_loss = CNTKLib.CreateEvaluator(loss);
Evaluator evaluator_err = CNTKLib.CreateEvaluator(err);
double sumEval = 0;
double sumLoss = 0;
for (int batchI = 0; batchI < ds.Count / batchSize; batchI++)
{
Value x_value = Value.CreateBatch(x.Shape, ds.Input.GetRange(batchI * batchSize * DataSet.InputSize, batchSize * DataSet.InputSize), DeviceDescriptor.CPUDevice);
Value yt_value = Value.CreateBatch(yt.Shape, ds.Output.GetRange(batchI * batchSize * DataSet.OutputSize, batchSize * DataSet.OutputSize), DeviceDescriptor.CPUDevice);
var inputDataMap = new UnorderedMapVariableValuePtr()
{
{ x, x_value },
{ yt, yt_value }
};
sumLoss += evaluator_loss.TestMinibatch(inputDataMap) * batchSize;
sumEval += evaluator_err.TestMinibatch(inputDataMap) * batchSize;
}
lossValue = sumLoss / ds.Count;
accValue = 1 - sumEval / ds.Count;
}
public UnorderedMapVariableValuePtrEnumerator(UnorderedMapVariableValuePtr collection)
{
collectionRef = collection;
keyCollection = new global::System.Collections.Generic.List <Variable>(collection.Keys);
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
private void _Evaluate(UnorderedMapVariableValuePtr arguments, UnorderedMapVariableValuePtr outputs)
{
CNTKLibPINVOKE.Function__Evaluate__SWIG_1(swigCPtr, UnorderedMapVariableValuePtr.getCPtr(arguments), UnorderedMapVariableValuePtr.getCPtr(outputs));
if (CNTKLibPINVOKE.SWIGPendingException.Pending)
{
throw CNTKLibPINVOKE.SWIGPendingException.Retrieve();
}
}
public double TestMinibatch(UnorderedMapVariableMinibatchData arguments, UnorderedMapVariableValuePtr outputsToFetch, DeviceDescriptor computeDevice, bool distributed)
{
double ret = CNTKLibPINVOKE.Evaluator_TestMinibatch__SWIG_6(swigCPtr, UnorderedMapVariableMinibatchData.getCPtr(arguments), UnorderedMapVariableValuePtr.getCPtr(outputsToFetch), DeviceDescriptor.getCPtr(computeDevice), distributed);
if (CNTKLibPINVOKE.SWIGPendingException.Pending)
{
throw CNTKLibPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
private bool _TrainMinibatch(UnorderedMapVariableValuePtr arguments, bool isSweepEndInArguments)
{
bool ret = CNTKLibPINVOKE.Trainer__TrainMinibatch__SWIG_3(swigCPtr, UnorderedMapVariableValuePtr.getCPtr(arguments), isSweepEndInArguments);
if (CNTKLibPINVOKE.SWIGPendingException.Pending)
{
throw CNTKLibPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public double TestMinibatch(UnorderedMapVariableValuePtr arguments, UnorderedMapVariableValuePtr outputsToFetch)
{
double ret = CNTKLibPINVOKE.Evaluator_TestMinibatch__SWIG_11(swigCPtr, UnorderedMapVariableValuePtr.getCPtr(arguments), UnorderedMapVariableValuePtr.getCPtr(outputsToFetch));
if (CNTKLibPINVOKE.SWIGPendingException.Pending)
{
throw CNTKLibPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public double TestMinibatch(UnorderedMapVariableValuePtr arguments, DeviceDescriptor computeDevice)
{
double ret = CNTKLibPINVOKE.Evaluator_TestMinibatch__SWIG_4(swigCPtr, UnorderedMapVariableValuePtr.getCPtr(arguments), DeviceDescriptor.getCPtr(computeDevice));
if (CNTKLibPINVOKE.SWIGPendingException.Pending)
{
throw CNTKLibPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
private bool _TrainMinibatch(UnorderedMapVariableMinibatchData arguments, UnorderedMapVariableValuePtr outputsToFetch, DeviceDescriptor computeDevice)
{
bool ret = CNTKLibPINVOKE.Trainer__TrainMinibatch__SWIG_4(swigCPtr, UnorderedMapVariableMinibatchData.getCPtr(arguments), UnorderedMapVariableValuePtr.getCPtr(outputsToFetch), DeviceDescriptor.getCPtr(computeDevice));
if (CNTKLibPINVOKE.SWIGPendingException.Pending)
{
throw CNTKLibPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public UnorderedMapVariableValuePtr GetVariableValueMapAsCNTKUnorderedMap(Minibatch batch)
{
var arguments = GetVariableValueMap(batch);
var map = new UnorderedMapVariableValuePtr();
foreach (var entry in arguments)
{
map.Add(entry.Key, entry.Value);
}
return(map);
}
public static void Evaluate(this Function func, Dictionary<Variable, Value> arguments, Dictionary<Variable, Value> outputs, DeviceDescriptor computeDevice)
{
// Evaluate the rootFunction.
var argMap = new UnorderedMapVariableValuePtr();
foreach (var p in arguments)
{
argMap.Add(p.Key, p.Value);
}
var outMap = new UnorderedMapVariableValuePtr();
foreach (var p in outputs)
{
outMap.Add(p.Key, p.Value);
}
func.Evaluate(argMap, outMap, computeDevice);
foreach (var p in outMap)
{
outputs[p.Key] = p.Value;
}
}
public String VisibleTest(DataSet ds, int count)
{
Value x_value = Value.CreateBatch(x.Shape, ds.Input.GetRange(0, count * DataSet.InputSize), DeviceDescriptor.CPUDevice);
var inputDataMap = new UnorderedMapVariableValuePtr()
{
{ x, x_value }
};
var outputDataMap = new UnorderedMapVariableValuePtr()
{
{ y, null }
};
y.Evaluate(inputDataMap, outputDataMap, DeviceDescriptor.CPUDevice);
IList <IList <float> > resultValue = outputDataMap[y].GetDenseData <float>(y);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < count; i++)
{
sb.Append(ds.DataToString(i));
sb.Append("Result:[");
int max = 0;
for (int d = 0; d <= 5; d++)
{
if (resultValue[i][d] > resultValue[i][max])
{
max = d;
}
if (d != 0)
{
sb.Append(", ");
}
sb.Append(String.Format("{0:0.00}", resultValue[i][d]));
}
sb.Append("]\nPrediction:").Append(max).Append("\n\n");
}
return(sb.ToString());
}
private static double Evaluate(int inputSize, int outputSize, int batchSize, List <float> training_inputs, List <float> training_outputs, int trainingCount, Variable x, Function y)
{
Variable yt = Variable.InputVariable(new int[] { outputSize }, DataType.Float);
Function y_rounded = CNTKLib.Round(y);
Function y_yt_equal = CNTKLib.Equal(y_rounded, yt);
Evaluator evaluator = CNTKLib.CreateEvaluator(y_yt_equal);
double sumEval = 0;
for (int batchI = 0; batchI < trainingCount / batchSize; batchI++)
{
Value x_value = Value.CreateBatch(x.Shape, training_inputs.GetRange(batchI * batchSize * inputSize, batchSize * inputSize), DeviceDescriptor.CPUDevice);
Value yt_value = Value.CreateBatch(yt.Shape, training_outputs.GetRange(batchI * batchSize * outputSize, batchSize * outputSize), DeviceDescriptor.CPUDevice);
var inputDataMap = new UnorderedMapVariableValuePtr()
{
{ x, x_value },
{ yt, yt_value }
};
sumEval += evaluator.TestMinibatch(inputDataMap, DeviceDescriptor.CPUDevice) * batchSize;
}
return(sumEval / trainingCount);
}
public double Evaluate(DataSet ds)
{
Variable yt = Variable.InputVariable(new int[] { DataSet.OutputSize }, DataType.Float);
Function y_rounded = CNTKLib.Round(y);
Function y_yt_equal = CNTKLib.Equal(y_rounded, yt);
Evaluator evaluator = CNTKLib.CreateEvaluator(y_yt_equal);
double sumEval = 0;
for (int batchI = 0; batchI < ds.Count / batchSize; batchI++)
{
Value x_value = Value.CreateBatch(x.Shape, ds.Input.GetRange(batchI * batchSize * DataSet.InputSize, batchSize * DataSet.InputSize), DeviceDescriptor.CPUDevice);
Value yt_value = Value.CreateBatch(yt.Shape, ds.Output.GetRange(batchI * batchSize * DataSet.OutputSize, batchSize * DataSet.OutputSize), DeviceDescriptor.CPUDevice);
var inputDataMap = new UnorderedMapVariableValuePtr()
{
{ x, x_value },
{ yt, yt_value }
};
sumEval += evaluator.TestMinibatch(inputDataMap, DeviceDescriptor.CPUDevice) * batchSize;
}
return(sumEval / ds.Count);
}
public static void EvaluateV2ModelUsingNDView()
{
// Load the model
var myFunc = Function.LoadModel("z.model");
// Ouput funciton info.
OutputFunctionInfo(myFunc);
// prepare input for evaluation
uint numOfSamples = 1;
// The z.model has only one input
var inputVar = myFunc.Arguments.Single();
// Todo: get size directly from inputVar.
uint numOfInputData = inputVar.Shape.TotalSize * numOfSamples;
float[] inputData = new float[numOfInputData];
for (uint i = 0; i < numOfInputData; ++i)
{
inputData[i] = (float)(i % 255);
}
// Todo: create value directly from data.
var dynamicAxisShape = new SizeTVector()
{
1, numOfSamples
};
var inputShape = inputVar.Shape.AppendShape(new NDShape(dynamicAxisShape));
var inputNDArrayView = new NDArrayView(inputShape, inputData, numOfInputData, DeviceDescriptor.CPUDevice);
var inputValue = new Value(inputNDArrayView);
// Create input map
// Todo: create a Dictionary wrapper?
var inputMap = new UnorderedMapVariableValuePtr();
inputMap.Add(inputVar, inputValue);
// The z.model has only one output.
var outputVar = myFunc.Output;
var outputShape = outputVar.Shape.AppendShape(new NDShape(dynamicAxisShape));
// Create output buffer
// Todo: use the system created buffer?
uint numOfOutputData = outputVar.Shape.TotalSize * numOfSamples;
float[] outputData = new float[numOfOutputData];
for (uint i = 0; i < numOfOutputData; ++i)
{
outputData[i] = (float)0.0;
}
var outputNDArrayView = new NDArrayView(outputShape, outputData, numOfOutputData, DeviceDescriptor.CPUDevice);
var outputValue = new Value(outputNDArrayView);
// Create ouput map
var outputMap = new UnorderedMapVariableValuePtr();
outputMap.Add(outputVar, outputValue);
// Evalaute
// Todo: test on GPUDevice()?
myFunc.Evaluate(inputMap, outputMap, DeviceDescriptor.CPUDevice);
// Output results
Console.WriteLine("Evaluation results:");
for (uint i = 0; i < numOfOutputData; ++i)
{
Console.WriteLine(outputData[i]);
}
}
public static void EvaluateUsingCreateValue()
{
// Load the model
var myFunc = Function.LoadModel("01_OneHidden");
// Ouput funciton info.
OutputFunctionInfo(myFunc);
// prepare input for evaluation
uint numOfSamples = 1;
const string inputNodeName = "features";
var inputVar = myFunc.Arguments.Where(variable => string.Equals(variable.Name, inputNodeName)).Single();
// Todo: get size directly from inputVar.
uint numOfInputData = inputVar.Shape.TotalSize;
var inputData = new List <float>();
for (uint i = 0; i < numOfInputData; ++i)
{
inputData.Add(i % 255);
}
var inputVector = new FloatVector(inputData);
var data = new FloatVectorVector()
{
inputVector
};
// Create value directly from data.
var inputValue = Value.CreateDenseFloat(inputVar.Shape, data, DeviceDescriptor.CPUDevice);
// Create input map
// Todo: create a Dictionary wrapper?
var inputMap = new UnorderedMapVariableValuePtr();
inputMap.Add(inputVar, inputValue);
// Prepare output
const string outputNodeName = "out.z_output";
var outputVar = myFunc.Outputs.Where(variable => string.Equals(variable.Name, outputNodeName)).Single();
// Create ouput map. Using null as Value to indicate using system allocated memory.
var outputMap = new UnorderedMapVariableValuePtr();
outputMap.Add(outputVar, null);
// Evalaute
// Todo: test on GPUDevice()?
myFunc.Evaluate(inputMap, outputMap, DeviceDescriptor.CPUDevice);
// Get output value after evaluation
var outputValue = outputMap[outputVar];
var outputNDArrayView = outputValue.Data();
var dynamicAxisShape = new SizeTVector()
{
1, numOfSamples
};
var outputShape = outputVar.Shape.AppendShape(new NDShape(dynamicAxisShape));
// Copy the data from the output buffer.
// Todo: directly access the data in output buffer if it is on CPU?
uint numOfOutputData = outputNDArrayView.Shape().TotalSize;
float[] outputData = new float[numOfOutputData];
var cpuOutputNDArrayView = new NDArrayView(outputShape, outputData, numOfOutputData, DeviceDescriptor.CPUDevice);
cpuOutputNDArrayView.CopyFrom(outputNDArrayView);
// Output results
Console.WriteLine("Evaluation results:");
for (uint i = 0; i < numOfOutputData; ++i)
{
Console.WriteLine(outputData[i]);
}
}
public static void EvaluateUsingSystemAllocatedMemory()
{
// Load the model
var myFunc = Function.LoadModel("z.model");
// Ouput funciton info.
OutputFunctionInfo(myFunc);
// prepare input for evaluation
uint numOfSamples = 1;
// Only one input for the model.
var inputVar = myFunc.Arguments.First();
// Todo: get size directly from inputVar.
uint numOfInputData = inputVar.Shape.TotalSize * numOfSamples;
float[] inputData = new float[numOfInputData];
for (uint i = 0; i < numOfInputData; ++i)
{
inputData[i] = (float)(i % 255);
}
// Todo: create value directly from data.
var dynamicAxisShape = new SizeTVector()
{
1, numOfSamples
};
var inputShape = inputVar.Shape.AppendShape(new NDShape(dynamicAxisShape));
var inputNDArrayView = new NDArrayView(inputShape, inputData, numOfInputData, DeviceDescriptor.CPUDevice);
var inputValue = new Value(inputNDArrayView);
// Create input map
// Todo: create a Dictionary wrapper?
var inputMap = new UnorderedMapVariableValuePtr();
inputMap.Add(inputVar, inputValue);
// Prepare output. The model has only one output.
var outputVar = myFunc.Output;
// Create ouput map. Using null as Value to indicate using system allocated memory.
var outputMap = new UnorderedMapVariableValuePtr();
outputMap.Add(outputVar, null);
// Evalaute
// Todo: test on GPUDevice()?
myFunc.Evaluate(inputMap, outputMap, DeviceDescriptor.CPUDevice);
// Get output value after evaluation
var outputValue = outputMap[outputVar];
var outputNDArrayView = outputValue.Data();
var outputShape = outputVar.Shape.AppendShape(new NDShape(dynamicAxisShape));
// Copy the data from the output buffer.
// Todo: directly access the data in output buffer if it is on CPU?
uint numOfOutputData = outputNDArrayView.Shape().TotalSize;
float[] outputData = new float[numOfOutputData];
var cpuOutputNDArrayView = new NDArrayView(outputShape, outputData, numOfOutputData, DeviceDescriptor.CPUDevice);
cpuOutputNDArrayView.CopyFrom(outputNDArrayView);
// Output results
Console.WriteLine("Evaluation results:");
for (uint i = 0; i < numOfOutputData; ++i)
{
Console.WriteLine(outputData[i]);
}
}
public CNTKFunction(CNTKBackend c, List <Variable> inputs, CNTK.Function[] outputs, List <List <Tensor> > updates, string name)
{
this.c = c;
this.placeholders = inputs;
this.trainer = null;
this.unrelated_updates = null;
this.updates = updates;
if (updates.Count > 0)
{
if (len(outputs) <= 0)
{
throw new Exception();
}
this.loss = outputs[0];
// need group update by gradient place holder
var u_ops = new List <CNTK.Function>();
var unrelated_updates = new List <CNTK.Function>();
foreach (List <Tensor> update in updates)
{
CNTK.Function u;
if (update.Count == 1)
{
u = c.In(update[0]);
}
else if (update.Count == 2)
{
u = C.Assign(c.In(update[0]), c.In(update[1]));
}
else
{
throw new NotImplementedException();
}
if (u.Inputs.Count == 0)
{
u_ops.Add(u);
}
else
{
unrelated_updates.Add(u);
}
}
var update_func = C.Combine(new VariableVector(u_ops.Select(u => u.Output).ToArray()));
CNTK.Function[] grads = update_func.FindAllWithName("keras_grad_placeholder").ToArray();
var u_list = new List <CNTK.Function>();
var p_list = new List <CNTK.Parameter>();
foreach (CNTK.Function g in grads)
{
if (c.grad_parameter_dict.ContainsKey(g))
{
p_list.Add(c.grad_parameter_dict[g]);
u_list.Add(g);
}
else
{
throw new Exception($"CNTK backend: when constructing trainer, found gradient node {g} which is not related to any parameters in the model. Please double check how the gradient node is constructed.");
}
}
if (len(u_list) > 0)
{
Learner learner = Learner.SGDLearner(p_list, new TrainingParameterScheduleDouble(0));
var criterion = (len(outputs) > 1) ?
C.Combine(new VariableVector(new[] { outputs[0], outputs[1] })) :
outputs[0];
this.trainer = Trainer.CreateTrainer(model: outputs[0], lossFunction: criterion, evaluationFunction: null, parameterLearners: new[] { learner });
this.trainer_output = new UnorderedMapVariableValuePtr();
foreach (CNTK.Function f in outputs)
{
this.trainer_output.Add(f, null);
}
}
else if (len(u_ops) > 0)
{
unrelated_updates.AddRange(u_ops);
}
if (len(unrelated_updates) > 0)
{
this.unrelated_updates = C.Combine(new VariableVector(unrelated_updates.Select(_ => _.Output).ToArray()));
}
}
if (this.trainer == null)
{
this.metrics_outputs = outputs.Select(f => f.Output).ToArray();
this.metrics_func = C.Combine(new VariableVector(this.metrics_outputs));
// cntk only could handle loss and 1 metric in trainer, for metrics more
// than 2, need manual eval
}
else if (len(outputs) > 2)
{
this.metrics_outputs = Matrix.Get(outputs, 2, 0).Select(f => f.Output).ToArray();
this.metrics_func = C.Combine(new VariableVector(this.metrics_outputs));
}
else
{
this.metrics_func = null;
}
}
public override List <Tensor> Call(List <Array> inputs)
{
var feed_dict = new Dictionary <Variable, Array>();
foreach (var(tensor, value) in Enumerable.Zip(this.placeholders, inputs, (a, b) => (a, b)))
{
Type t = value.GetInnerMostType();
Array v = value;
// cntk only support calculate on float, do auto cast here
if (t != typeof(float) && t != typeof(double))
{
v = MatrixEx.Convert <double>(value);
}
feed_dict[tensor] = v;
}
var updated = new List <Tensor>();
if (this.trainer != null)
{
var input_dict = new UnorderedMapVariableValuePtr();
foreach (Variable argument in this.loss.Arguments)
{
if (feed_dict.ContainsKey(argument))
{
input_dict[argument] = new Value(CNTKBackend.In(feed_dict[argument]));
}
else
{
throw new Exception($"CNTK backend: argument {argument.Name} is not found in inputs. Please double check the model and inputs in 'train_function'.");
}
}
var result = this.trainer.TrainMinibatch(input_dict, this.trainer_output);
foreach (Variable o in this.trainer_output.Keys)
{
updated.Add(c.Out(this.trainer_output[o]));
}
}
if (this.metrics_func != null)
{
var input_dict = new Dictionary <Variable, Value>();
foreach (Variable argument in this.metrics_func.Arguments)
{
if (feed_dict.ContainsKey(argument))
{
input_dict[argument] = new Value(CNTKBackend.In(feed_dict[argument]));
}
else
{
throw new Exception($"CNTK backend: metrics argument {argument.Name} is not found in inputs. Please double check the model and inputs.");
}
}
var output_values = new Dictionary <Variable, Value>();
foreach (Variable variable in this.metrics_outputs)
{
output_values[variable] = null;
}
this.metrics_func.Evaluate(input_dict, output_values, DeviceDescriptor.CPUDevice);
foreach (Variable o in this.metrics_outputs)
{
Value value = output_values[o];
var v = c.Out(value);
updated.Add(v);
}
}
if (this.unrelated_updates != null)
{
var input_dict = new Dictionary <Variable, Value>();
foreach (Variable argument in this.unrelated_updates.Arguments)
{
if (feed_dict.ContainsKey(argument))
{
input_dict[argument] = new Value(CNTKBackend.In(feed_dict[argument]));
}
else
{
throw new Exception($"CNTK backend: assign ops argument {argument.Name} is not found in inputs. Please double check the model and inputs.");
}
}
var output_values = new Dictionary <Variable, Value>();
this.unrelated_updates.Evaluate(input_dict, output_values, DeviceDescriptor.CPUDevice);
}
return(updated);
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(UnorderedMapVariableValuePtr obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
