/// <summary>
/// Creates an instance of the <see cref="ModelEvaluator"/> class.
/// </summary>
/// <param name="modelFilePath">The model file path</param>
/// <param name="numThreads">The number of concurrent threads for the model</param>
/// <param name="id">A unique id for the model</param>
/// <remarks>The id is used only for debugging purposes</remarks>
private ModelEvaluator(string modelFilePath, int numThreads, int id)
{
m_modelInstance = id;
m_model = new IEvaluateModelManagedF();
// Configure the model to run with a specific number of threads
m_model.Init(string.Format("numCPUThreads={0}", numThreads));
// Load model
m_model.CreateNetwork(string.Format("modelPath=\"{0}\"", modelFilePath), deviceId: -1);
// Generate random input values in the appropriate structure and size
var inDims = m_model.GetNodeDimensions(NodeGroup.Input);
m_inKey = inDims.First().Key;
m_inputs = new Dictionary <string, List <float> >()
{
{ m_inKey, null }
};
// We request the output layer names(s) and dimension, we'll use the first one.
var outDims = m_model.GetNodeDimensions(NodeGroup.Output);
m_outKey = outDims.First().Key;
}
public void EvalManagedEvaluateNoInputTest()
{
string modelDefinition = @"precision = ""float""
traceLevel = 1
run=NDLNetworkBuilder
NDLNetworkBuilder=[
v1 = Constant(1)
v2 = Constant(2)
o1 = Plus(v1, v2, tag=""output"")
FeatureNodes = (v1)
]";
using (var model = new IEvaluateModelManagedF())
{
model.CreateNetwork(modelDefinition);
var inDims = model.GetNodeDimensions(NodeGroup.Input);
Assert.AreEqual(inDims.Count(), 0);
var outDims = model.GetNodeDimensions(NodeGroup.Output);
Assert.AreEqual(outDims.Count(), 1);
Assert.AreEqual(outDims.First().Key, "o1");
Assert.AreEqual(outDims.First().Value, 1);
var outputVal = model.Evaluate(outDims.First().Key);
var expected = new List <float>()
{
3
};
CollectionAssert.AreEqual(expected, outputVal);
}
}
/// <summary>
/// Evaluates a network (without a model and without input) and obtains a single layer output
/// </summary>
private static void EvaluateNetworkSingleLayerNoInput()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
string workingDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Other\Simple2d\Config");
Environment.CurrentDirectory = initialDirectory;
List <float> outputs;
using (var model = new IEvaluateModelManagedF())
{
// Create the network
// This network (AddOperatorConstantNoInput.cntk) is a simple network consisting of a single binary operator (Plus)
// operating over a two constants, therefore no input is necessary.
string networkDescription = File.ReadAllText(Path.Combine(workingDirectory, @"AddOperatorConstantNoInput.cntk"));
model.CreateNetwork(networkDescription, deviceId: -1);
// We can call the evaluate method and get back the results (single layer)...
outputs = model.Evaluate("ol", 1);
}
OutputResults("ol", outputs);
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}\nCallStack: {1}\n Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
}
private void AssertArgumentException(IEvaluateModelManagedF model,
Bitmap image,
string outputKey,
string expectedParameterName,
string expectedMessageText,
string errorMessage)
{
bool exception = false;
try
{
model.EvaluateRgbImage(image, outputKey);
}
catch (ArgumentException ex)
{
if (ex.ParamName == expectedParameterName && ex.Message.Contains(expectedMessageText))
{
exception = true;
}
}
catch { }
if (!exception)
{
throw new Exception(errorMessage);
}
}
public async Task<string[]> EvaluateCustomDNN(string imageUrl)
{
string domainBaseDirectory = AppDomain.CurrentDomain.BaseDirectory;
string workingDirectory = Environment.CurrentDirectory;
try
{
// This example requires the RestNet_18 model.
// The model can be downloaded from <see cref="https://www.cntk.ai/resnet/ResNet_18.model"/>
int numThreads = 1;
List<float> outputs;
using (var model = new IEvaluateModelManagedF())
{
// initialize the evaluation engine
// TODO: initializing the evaluation engine should be one only once at the beginning
var initParams = string.Format("numCPUThreads={0}", numThreads);
model.Init(initParams);
// load the model
string modelFilePath = Path.Combine(domainBaseDirectory, @"CNTK\Models\ResNet_18.model");
var modelOption = string.Format("modelPath=\"{0}\"", modelFilePath);
model.CreateNetwork(modelOption, deviceId: -1);
// Prepare input value in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.Input);
if (inDims.First().Value != 224 * 224 * 3)
{
throw new CNTKRuntimeException(string.Format("The input dimension for {0} is {1} which is not the expected size of {2}.", inDims.First(), inDims.First().Value, 224 * 224 * 3), string.Empty);
}
// Transform the image
System.Net.Http.HttpClient httpClient = new HttpClient();
Stream imageStream = await httpClient.GetStreamAsync(imageUrl);
Bitmap bmp = new Bitmap(Bitmap.FromStream(imageStream));
var resized = bmp.Resize(224, 224, true);
var resizedCHW = resized.ParallelExtractCHW();
var inputs = new Dictionary<string, List<float>>() { { inDims.First().Key, resizedCHW } };
// We can call the evaluate method and get back the results (single layer output)...
var outDims = model.GetNodeDimensions(NodeGroup.Output);
outputs = model.Evaluate(inputs, outDims.First().Key);
}
List<string> o = new List<string>();
foreach (float f in outputs)
{
o.Add(f.ToString());
}
return o.ToArray<string>();
}
catch (Exception ex)
{
return new string[] { string.Format("domainBase directory {0}, workingDirectory {1}, exception details: {2}.", domainBaseDirectory, workingDirectory, ex.ToString()) };
}
}
public NetEvaluation(string modelpath, List <string> OutputNodesLists)
{
Model = new IEvaluateModelManagedF();
Model.CreateNetwork(string.Format("modelPath=\"{0}\"", modelpath), deviceId: -1, outputNodeNames: OutputNodesLists);
inDims = Model.GetNodeDimensions(NodeGroup.Input);
outDims = Model.GetNodeDimensions(NodeGroup.Output);
inputs = new Dictionary <string, List <float> >();
}
/// <summary>
/// Dispose the model
/// </summary>
public void Close()
{
if (model != null)
{
model.Dispose();
model = null;
}
}
/// <summary>
/// Evaluates a trained model and obtains multiple layers output (including hidden layer)
/// </summary>
/// <remarks>
/// This example requires the 01_OneHidden trained model
/// </remarks>
private static void EvaluateModelMultipleLayers()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
Environment.CurrentDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Image\MNIST\Data\");
Dictionary <string, List <float> > outputs;
using (var model = new IEvaluateModelManagedF())
{
// Desired output layers
const string hiddenLayerName = "h1.z";
const string outputLayerName = "ol.z";
// Load model
string modelFilePath = Path.Combine(Environment.CurrentDirectory, @"..\Output\Models\01_OneHidden");
if (!File.Exists(modelFilePath))
{
Console.WriteLine("Error: The model {0} does not exist. Please follow instructions in README.md in <CNTK>/Examples/Image/MNIST to create the model.", modelFilePath);
throw new FileNotFoundException(string.Format("File {0} not found.", modelFilePath));
}
var desiredOutputLayers = new List <string>()
{
hiddenLayerName, outputLayerName
};
model.CreateNetwork(string.Format("modelPath=\"{0}\"", modelFilePath), deviceId: -1, outputNodeNames: desiredOutputLayers);
// Generate random input values in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.Input);
var inputs = GetDictionary(inDims.First().Key, inDims.First().Value, 255);
// We request the output layer names(s) and dimension, we'll get both the hidden layer and the output layer
var outDims = model.GetNodeDimensions(NodeGroup.Output);
// We can preallocate the output structure and pass it in (multiple output layers)
outputs = new Dictionary <string, List <float> >()
{
{ hiddenLayerName, GetFloatArray(outDims[hiddenLayerName], 1) },
{ outputLayerName, GetFloatArray(outDims[outputLayerName], 1) }
};
model.Evaluate(inputs, outputs);
}
OutputResults(outputs);
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}\nCallStack: {1}\n Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
}
/// <summary>
/// This method shows how to evaluate a trained image classification model
/// </summary>
public static void EvaluateImageClassificationModel()
{
try
{
// This example requires the RestNet_18 model.
// The model can be downloaded from <see cref="https://www.cntk.ai/resnet/ResNet_18.model"/>
// The model is assumed to be located at: <CNTK>\Examples\Image\Miscellaneous\ImageNet\ResNet
// along with a sample image file named "zebra.jpg".
string workingDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Image\Miscellaneous\ImageNet\ResNet");
Environment.CurrentDirectory = initialDirectory;
List <float> outputs;
using (var model = new IEvaluateModelManagedF())
{
string modelFilePath = Path.Combine(workingDirectory, "ResNet_18.model");
model.CreateNetwork(string.Format("modelPath=\"{0}\"", modelFilePath), deviceId: -1);
// Prepare input value in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.Input);
if (inDims.First().Value != 224 * 224 * 3)
{
throw new CNTKRuntimeException(string.Format("The input dimension for {0} is {1} which is not the expected size of {2}.", inDims.First(), inDims.First().Value, 224 * 224 * 3), string.Empty);
}
// Transform the image
string imageFileName = Path.Combine(workingDirectory, "zebra.jpg");
Bitmap bmp = new Bitmap(Bitmap.FromFile(imageFileName));
var resized = bmp.Resize(224, 224, true);
var resizedCHW = resized.ParallelExtractCHW();
var inputs = new Dictionary <string, List <float> >()
{
{ inDims.First().Key, resizedCHW }
};
// We can call the evaluate method and get back the results (single layer output)...
var outDims = model.GetNodeDimensions(NodeGroup.Output);
outputs = model.Evaluate(inputs, outDims.First().Key);
}
// Retrieve the outcome index (so we can compare it with the expected index)
var max = outputs.Select((value, index) => new { Value = value, Index = index })
.Aggregate((a, b) => (a.Value > b.Value) ? a : b)
.Index;
Console.WriteLine("Outcome: {0}", max);
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}\nCallStack: {1}\n Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
}
/// <summary>
/// This method shows how to evaluate a trained image classification model, with
/// explicitly created feature vectors.
/// </summary>
public static List <float> EvaluateImageInputUsingFeatureVector()
{
List <float> outputs = null;
try
{
// This example requires the RestNet_18 model.
// The model can be downloaded from <see cref="https://www.cntk.ai/resnet/ResNet_18.model"/>
// The model is assumed to be located at: <CNTK>\Examples\Image\Classification\ResNet
// along with a sample image file named "zebra.jpg".
Environment.CurrentDirectory = initialDirectory;
using (var model = new IEvaluateModelManagedF())
{
model.CreateNetwork(string.Format("modelPath=\"{0}\"", resnetModelFilePath), deviceId: -1);
// Prepare input value in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.Input);
if (inDims.First().Value != resNetImageSize * resNetImageSize * 3)
{
throw new CNTKRuntimeException(string.Format("The input dimension for {0} is {1} which is not the expected size of {2}.", inDims.First(), inDims.First().Value, 224 * 224 * 3), string.Empty);
}
// Transform the image
Bitmap bmp = new Bitmap(Bitmap.FromFile(imageFileName));
var resized = bmp.Resize(resNetImageSize, resNetImageSize, true);
var resizedCHW = resized.ParallelExtractCHW();
var inputs = new Dictionary <string, List <float> >()
{
{ inDims.First().Key, resizedCHW }
};
// We can call the evaluate method and get back the results (single layer output)...
var outDims = model.GetNodeDimensions(NodeGroup.Output);
outputs = model.Evaluate(inputs, outDims.First().Key);
}
// Retrieve the outcome index (so we can compare it with the expected index)
var max = outputs.Select((value, index) => new { Value = value, Index = index })
.Aggregate((a, b) => (a.Value > b.Value) ? a : b)
.Index;
Console.WriteLine("EvaluateImageInputUsingFeatureVector: Outcome = {0}", max);
}
catch (CNTKException ex)
{
OnCNTKException(ex);
}
catch (Exception ex)
{
OnGeneralException(ex);
}
return(outputs);
}
/// <summary>
/// Evaluates a trained model and obtains multiple layers output (including hidden layer)
/// </summary>
/// <remarks>
/// This example requires the 01_OneHidden trained model
/// </remarks>
private static void EvaluateModelMultipleLayers()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
Environment.CurrentDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Image\GettingStarted");
Dictionary <string, List <float> > outputs;
using (var model = new IEvaluateModelManagedF())
{
// Desired output layers
const string hiddenLayerName = "out.h1";
const string outputLayerName = "out.z";
// Load model
string modelFilePath = Path.Combine(Environment.CurrentDirectory, @".\Output\Models\01_OneHidden");
ThrowIfFileNotExist(modelFilePath,
string.Format("Error: The model '{0}' does not exist. Please follow instructions in README.md in <CNTK>/Examples/Image/GettingStarted to create the model.", modelFilePath));
var desiredOutputLayers = new List <string>()
{
hiddenLayerName, outputLayerName
};
model.CreateNetwork(string.Format("modelPath=\"{0}\"", modelFilePath), deviceId: -1, outputNodeNames: desiredOutputLayers);
// Generate random input values in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.Input);
var inputs = GetDictionary(inDims.First().Key, inDims.First().Value, 255);
// We request the output layer names(s) and dimension, we'll get both the hidden layer and the output layer
var outDims = model.GetNodeDimensions(NodeGroup.Output);
// We can preallocate the output structure and pass it in (multiple output layers)
outputs = new Dictionary <string, List <float> >()
{
{ hiddenLayerName, GetFloatArray(outDims[hiddenLayerName], 1) },
{ outputLayerName, GetFloatArray(outDims[outputLayerName], 1) }
};
model.Evaluate(inputs, outputs);
}
OutputResults(outputs);
}
catch (CNTKException ex)
{
OnCNTKException(ex);
}
catch (Exception ex)
{
OnGeneralException(ex);
}
}
private static List <float> EvaluateGoModel(string dataDirectory, List <float> feature)
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
//Path.Combine(initialDirectory, @"..\..\Examples\Image\MNIST\Data\");
//Dictionary<string, List<float>> outputs;
//using (var model = new IEvaluateModelManagedF())
//{
if (model == null)
{
Environment.CurrentDirectory = dataDirectory; // @"D:\Aricie\Go\cntk\Data";
model = new IEvaluateModelManagedF();
// Initialize model evaluator
string config = GetFileContents(Path.Combine(Environment.CurrentDirectory, @"..\Config\02_Convolution.cntk"));
model.Init(config);
// Load model
string modelFilePath = Path.Combine(Environment.CurrentDirectory, @"..\Output\Models\02_Convolution");
//model.LoadModel(modelFilePath);
model.CreateNetwork(string.Format("deviceId=0\nmodelPath=\"{0}\"", modelFilePath));
// Generate random input values in the appropriate structure and size
//var inputs = GetDictionary("features", 28 * 28, 255);
// We can preallocate the output structure and pass it in (multiple output layers)
//outputs = GetDictionary("ol.z", 10, 1);
}
var inputs = new Dictionary <string, List <float> >();
inputs.Add("features", feature);
return(model.Evaluate(inputs, "ol.act", 361));
//}
//OutputResults(outputs);
}
//catch (CNTKException ex)
//{
// Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
//}
catch (Exception ex)
{
Console.WriteLine(@"Error: {0} CallStack: {1} Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException?.Message ?? "No Inner Exception");
}
return(null);
}
public void EvalManagedImageApiErrorHandling()
{
// The width and height of the image that will be fed into the network.
var expectedSize = 10;
// Images with correct size and pixel format.
var correctBmp1 = new Bitmap(expectedSize, expectedSize, PixelFormat.Format24bppRgb);
var correctBmp2 = new Bitmap(expectedSize, expectedSize, PixelFormat.Format32bppRgb);
// Image with correct size, but wrong pixel format
var wrongPixelFormat = new Bitmap(expectedSize, expectedSize, PixelFormat.Format16bppRgb565);
// Image with wrong size, correct pixel format
var wrongSize = new Bitmap(expectedSize * 2, expectedSize, PixelFormat.Format24bppRgb);
var inputVectorSize = expectedSize * expectedSize * 3;
var modelDefinition = String.Format(@"deviceId = -1
precision = ""float""
traceLevel = 1
run=NDLNetworkBuilder
NDLNetworkBuilder=[
i1 = Input({0}) # Network must have size expectedSize * expectedSize * 3, for 3 channels
o1 = Times(Constant(1, rows=2, cols={0}), i1, tag=""output"")
FeatureNodes = (i1)
]", inputVectorSize);
using (var model = new IEvaluateModelManagedF())
{
model.CreateNetwork(modelDefinition);
var output = model.EvaluateRgbImage(correctBmp1, "o1");
// Network computes 2 simple dot products.
Assert.AreEqual(2, output.Count, "Size of output vector");
// Input image is all zero, output should be too.
Assert.AreEqual(0.0f, output[0], "OutputVector[0]");
Assert.AreEqual(0.0f, output[1], "OutputVector[1]");
AssertArgumentException(model,
correctBmp1,
"No such output key",
"outputKey",
"not an output node",
"Providing a non-existing output node should fail with an ArgumentException.");
AssertArgumentException(model,
wrongPixelFormat,
"o1",
"image",
"must be one of { Format24bppRgb, Format32bppArgb}",
"Images with an unrecognized pixel format should fail with an ArgumentException.");
AssertArgumentException(model,
wrongSize,
"o1",
"image",
"invalid size",
"Calling with a wrongly sized image should fail with an ArgumentException.");
}
}
/// <summary>
/// Evaluates a network (without a model, but requiring input) and obtains a single layer output
/// </summary>
private static void EvaluateNetworkSingleLayer()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
string workingDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Other\Simple2d\Config");
Environment.CurrentDirectory = initialDirectory;
List <float> outputs;
string outputLayerName;
using (var model = new IEvaluateModelManagedF())
{
// Create the network
// This network (AddOperatorConstant_ndl_deprecated.cntk) is a simple network consisting of a single binary operator (Plus)
// operating over a single input and a constant
string networkFilePath = Path.Combine(workingDirectory, @"AddOperatorConstant_ndl_deprecated.cntk");
if (!File.Exists(networkFilePath))
{
Console.WriteLine("Error: The network configuration file {0} does not exist.", networkFilePath);
throw new FileNotFoundException(string.Format("File {0} not found.", networkFilePath));
}
string networkDescription = File.ReadAllText(networkFilePath);
model.CreateNetwork(networkDescription, deviceId: -1);
// Prepare input value in the appropriate structure and size
var inputs = new Dictionary <string, List <float> >()
{
{ "features", new List <float>()
{
1.0f
} }
};
// We can call the evaluate method and get back the results (single layer output)...
var outDims = model.GetNodeDimensions(NodeGroup.Output);
outputLayerName = outDims.First().Key;
outputs = model.Evaluate(inputs, outputLayerName);
}
OutputResults(outputLayerName, outputs);
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}\nCallStack: {1}\n Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
}
public void EvalManagedEvaluateSingleOutputTest()
{
string modelDefinition = @"precision = ""float""
traceLevel = 1
run=NDLNetworkBuilder
NDLNetworkBuilder=[
i1 = Input(1)
o1 = Times(Constant(3), i1, tag=""output"")
FeatureNodes = (i1)
]";
using (var model = new IEvaluateModelManagedF())
{
model.CreateNetwork(modelDefinition);
var inDims = model.GetNodeDimensions(NodeGroup.Input);
Assert.AreEqual(inDims.Count(), 1);
Assert.AreEqual(inDims.First().Key, "i1");
Assert.AreEqual(inDims.First().Value, 1);
var inputs = new Dictionary <string, List <float> >()
{
{ inDims.First().Key, new List <float>()
{
2
} }
};
var outDims = model.GetNodeDimensions(NodeGroup.Output);
Assert.AreEqual(outDims.Count(), 1);
Assert.AreEqual(outDims.First().Key, "o1");
Assert.AreEqual(outDims.First().Value, 1);
var outputs = new Dictionary <string, List <float> >()
{
{ outDims.First().Key, new List <float>()
{
0
} }
};
model.Evaluate(inputs, outputs);
var expected = new List <float>()
{
6
};
CollectionAssert.AreEqual(expected, outputs.First().Value);
}
}
/// <summary>
/// Program entry point
/// </summary>
/// <param name="args">Program arguments (ignored)</param>
private static void Main(string[] args)
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
Environment.CurrentDirectory = Path.Combine(Environment.CurrentDirectory, @"..\..\Examples\Image\MNIST\Data\");
Dictionary<string, List<float>> outputs;
using (var model = new IEvaluateModelManagedF())
{
// Initialize model evaluator
string config = GetConfig();
model.Init(config);
// Load model
string modelFilePath = Path.Combine(Environment.CurrentDirectory, @"..\Output\Models\01_OneHidden");
model.LoadModel(modelFilePath);
// Generate random input values in the appropriate structure and size
var inputs = GetDictionary("features", 28*28, 255);
// We can call the evaluate method and get back the results (single layer)...
// List<float> outputList = model.Evaluate(inputs, "ol.z", 10);
// ... or we can preallocate the structure and pass it in (multiple output layers)
outputs = GetDictionary("ol.z", 10, 1);
model.Evaluate(inputs, outputs);
}
Console.WriteLine("--- Output results ---");
foreach (var item in outputs)
{
Console.WriteLine("Output layer: {0}", item.Key);
foreach (var entry in item.Value)
{
Console.WriteLine(entry);
}
}
}
catch (Exception ex)
{
Console.WriteLine("Error: {0} \n {1}", ex, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
Console.WriteLine("Press <Enter> to terminate.");
Console.ReadLine();
}
/// <summary>
/// Program entry point
/// </summary>
/// <param name="args">Program arguments (ignored)</param>
private static void Main(string[] args)
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
Environment.CurrentDirectory = Path.Combine(Environment.CurrentDirectory, @"..\..\Examples\Image\MNIST\Data\");
Dictionary <string, List <float> > outputs;
using (var model = new IEvaluateModelManagedF())
{
// Initialize model evaluator
string config = GetConfig();
model.Init(config);
// Load model
string modelFilePath = Path.Combine(Environment.CurrentDirectory, @"..\Output\Models\01_OneHidden");
model.LoadModel(modelFilePath);
// Generate random input values in the appropriate structure and size
var inputs = GetDictionary("features", 28 * 28, 255);
// We can call the evaluate method and get back the results (single layer)...
// List<float> outputList = model.Evaluate(inputs, "ol.z", 10);
// ... or we can preallocate the structure and pass it in (multiple output layers)
outputs = GetDictionary("ol.z", 10, 1);
model.Evaluate(inputs, outputs);
}
Console.WriteLine("--- Output results ---");
foreach (var item in outputs)
{
Console.WriteLine("Output layer: {0}", item.Key);
foreach (var entry in item.Value)
{
Console.WriteLine(entry);
}
}
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
Console.WriteLine("Press <Enter> to terminate.");
Console.ReadLine();
}
/// <summary>
/// Init EvaluatorHelper and create network.
/// </summary>
/// <param name="ModelPath">Model Path,used full path.</param>
/// <param name="DeviceId">deviceId = -1 for CPU, >=0 for GPU devices.</param>
public EvaluatorHelper(string ModelPath, int DeviceId = -1)
{
if (!File.Exists(ModelPath))
{
MessageBox.Show(GlobalLanguage.FindText("Message_Notice_FileNotExist"), GlobalLanguage.FindText("Message_Notice"));
return;
}
this.modelPath = ModelPath;
this.deviceId = DeviceId;
this.model = new IEvaluateModelManagedF();
this.model.CreateNetwork(string.Format("modelPath=\"{0}\"", this.modelPath), this.deviceId);
this.inputDims = this.model.GetNodeDimensions(NodeGroup.Input);
this.outputDims = this.model.GetNodeDimensions(NodeGroup.Output);
}
private void Evaluate(string imagePath)
{
this.LoadImage(imagePath);
var configFilePath = this.ConfigFilePath;
var modelFilePath = this.ModelFilePath;
var labelMappingFilePath = this.LabelMappingFilePath;
// Important
Environment.CurrentDirectory = Path.GetDirectoryName(this.ConfigFilePath);
using (var model = new IEvaluateModelManagedF())
{
// Initialize model evaluator
var lines = File.ReadAllLines(configFilePath);
var config = string.Join("\n", lines);
model.Init(config);
// Load model
model.CreateNetwork(string.Format("deviceId=-1\nmodelPath=\"{0}\"", modelFilePath));
// Generate random input values in the appropriate structure and size
var feature = this.GetFeature().ToList();
var inputs = new Dictionary <string, List <float> >();
inputs.Add("features", feature);
var labels = System.IO.File.ReadAllLines(labelMappingFilePath);
var labelCount = labels.Length;
var outputNodeName = string.Format("{0}.z", this.OutputNodeName);
var outputs = model.Evaluate(inputs, outputNodeName, labelCount);
// convert to probability
var results = Softmax(outputs);
var output = labels.Select((label, index) => new CntkResult
{
Label = label,
Probability = results[index],
ProbabilityText = results[index].ToString("F32")
}).ToList();
this.Output = new ListCollectionView(output);
}
}
/// <summary>
/// Evaluates a trained model and obtains a single layer output
/// </summary>
/// <remarks>
/// This example requires the 01_OneHidden trained model
/// </remarks>
private static void EvaluateModelSingleLayer()
{
try
{
string outputLayerName;
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
Environment.CurrentDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Image\MNIST\Data\");
List <float> outputs;
using (var model = new IEvaluateModelManagedF())
{
// Load model
string modelFilePath = Path.Combine(Environment.CurrentDirectory, @"..\Output\Models\01_OneHidden");
if (!File.Exists(modelFilePath))
{
Console.WriteLine("Error: The model {0} does not exist. Please follow instructions in README.md in <CNTK>/Examples/Image/MNIST to create the model.", modelFilePath);
throw new FileNotFoundException(string.Format("File {0} not found.", modelFilePath));
}
model.CreateNetwork(string.Format("modelPath=\"{0}\"", modelFilePath), deviceId: -1);
// Generate random input values in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.Input);
var inputs = GetDictionary(inDims.First().Key, inDims.First().Value, 255);
// We request the output layer names(s) and dimension, we'll use the first one.
var outDims = model.GetNodeDimensions(NodeGroup.Output);
outputLayerName = outDims.First().Key;
// We can call the evaluate method and get back the results (single layer)...
outputs = model.Evaluate(inputs, outputLayerName);
}
OutputResults(outputLayerName, outputs);
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}\nCallStack: {1}\n Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
}
public static List <float> Evaluate(string modelFilePath, string configContent, Dictionary <string, List <float> > inputs, string outputKey, int outputSize)
{
//Dictionary<string, List<float>> outputs;
using (var model = new IEvaluateModelManagedF())
{
// Initialize model evaluator
model.Init(configContent);
// Load model
// model.LoadModel(modelFilePath);
model.CreateNetwork($"deviceId=0\nmodelPath=\"{modelFilePath}\"");
// We can call the evaluate method and get back the results (single layer)...
// List<float> outputList = model.Evaluate(inputs, "ol.z", 10);
return(model.Evaluate(inputs, outputKey, outputSize));
// ... or we can preallocate the structure and pass it in (multiple output layers)
//var toReturn = new List<float>(outputSize);
//for (int i = 0; i < outputSize; i++)
//{
// toReturn.Add(1);
//}
//outputs = new Dictionary<string, List<float>>();
//outputs.Add("ol.z", toReturn);
//model.Evaluate(inputs, outputs);
//Console.WriteLine("--- Output results ---");
//foreach (var item in outputs)
//{
// Console.WriteLine("Output layer: {0}", item.Key);
// foreach (var entry in item.Value)
// {
// Console.WriteLine(entry);
// }
//}
}
}
/// <summary>
/// Evaluates a network (without a model) and obtains a single layer output
/// </summary>
private static void EvaluateNetworkSingleLayer()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
string workingDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Other\Simple2d\Config");
Environment.CurrentDirectory = initialDirectory;
List <float> outputs;
using (var model = new IEvaluateModelManagedF())
{
// Initialize model evaluator
model.Init("deviceId=-1");
// Create the network
string networkDescription = GetFileContents(Path.Combine(workingDirectory, @"AddOperatorConstant.cntk"));
model.CreateNetwork(networkDescription);
// Generate random input values in the appropriate structure and size
var inputs = new Dictionary <string, List <float> >()
{
{ "features", new List <float>()
{
{ 1.0f }
} }
};
// We can call the evaluate method and get back the results (single layer)...
outputs = model.Evaluate(inputs, "ol", 1);
}
OutputResults("ol", outputs);
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}\nCallStack: {1}\n Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
}
/// <summary>
/// Evaluates a trained model and obtains a single layer output
/// </summary>
/// <remarks>
/// This example requires the 01_OneHidden trained model
/// </remarks>
private static void EvaluateModelSingleLayer()
{
try
{
string outputLayerName;
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
Environment.CurrentDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Image\GettingStarted");
List <float> outputs;
using (var model = new IEvaluateModelManagedF())
{
// Load model
string modelFilePath = Path.Combine(Environment.CurrentDirectory, @".\Output\Models\01_OneHidden");
ThrowIfFileNotExist(modelFilePath,
string.Format("Error: The model '{0}' does not exist. Please follow instructions in README.md in <CNTK>/Examples/Image/GettingStarted to create the model.", modelFilePath));
model.CreateNetwork(string.Format("modelPath=\"{0}\"", modelFilePath), deviceId: -1);
// Generate random input values in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.Input);
var inputs = GetDictionary(inDims.First().Key, inDims.First().Value, 255);
// We request the output layer names(s) and dimension, we'll use the first one.
var outDims = model.GetNodeDimensions(NodeGroup.Output);
outputLayerName = outDims.First().Key;
// We can call the evaluate method and get back the results (single layer)...
outputs = model.Evaluate(inputs, outputLayerName);
}
OutputResults(outputLayerName, outputs);
}
catch (CNTKException ex)
{
OnCNTKException(ex);
}
catch (Exception ex)
{
OnGeneralException(ex);
}
}
/// <summary>
/// Creates an instance of the <see cref="ModelEvaluator"/> class.
/// </summary>
/// <param name="modelFilePath">The model file path</param>
/// <param name="numThreads">The number of concurrent threads for the model</param>
/// <param name="id">A unique id for the model</param>
/// <remarks>The id is used only for debugging purposes</remarks>
private ModelEvaluator(string modelFilePath, int numThreads, int id)
{
m_modelInstance = id;
m_model = new IEvaluateModelManagedF();
// Configure the model to run with a specific number of threads
m_model.Init(string.Format("numCPUThreads={0}", numThreads));
// Load model
m_model.CreateNetwork(string.Format("modelPath=\"{0}\"", modelFilePath), deviceId: -1);
// Generate random input values in the appropriate structure and size
var inDims = m_model.GetNodeDimensions(NodeGroup.Input);
m_inKey = inDims.First().Key;
m_inputs = new Dictionary<string, List<float>>() { { m_inKey, null } };
// We request the output layer names(s) and dimension, we'll use the first one.
var outDims = m_model.GetNodeDimensions(NodeGroup.Output);
m_outKey = outDims.First().Key;
}
/// <summary>
/// Evaluates a trained model and obtains multiple layers output
/// </summary>
private static void EvaluateModelMultipleLayers()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
Environment.CurrentDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Image\MNIST\Data\");
Dictionary<string, List<float>> outputs;
using (var model = new IEvaluateModelManagedF())
{
// Load model
string modelFilePath = Path.Combine(Environment.CurrentDirectory, @"..\Output\Models\01_OneHidden");
model.CreateNetwork(string.Format("modelPath=\"{0}\"", modelFilePath), deviceId:-1);
// Generate random input values in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.nodeInput);
var inputs = GetDictionary(inDims.First().Key, inDims.First().Value, 255);
// We request the output layer names(s) and dimension, we'll use the first one.
var outDims = model.GetNodeDimensions(NodeGroup.nodeOutput);
string outputLayerName = outDims.First().Key;
// We can preallocate the output structure and pass it in (multiple output layers)
outputs = GetDictionary(outputLayerName, outDims[outputLayerName], 1);
model.Evaluate(inputs, outputs);
}
OutputResults(outputs);
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}\nCallStack: {1}\n Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
}
/// <summary>
/// Evaluates a trained model and obtains multiple layers output
/// </summary>
private static void EvaluateModelMultipleLayers()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
Environment.CurrentDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Image\MNIST\Data\");
Dictionary <string, List <float> > outputs;
using (var model = new IEvaluateModelManagedF())
{
// Initialize model evaluator
string config = GetFileContents(Path.Combine(Environment.CurrentDirectory, @"..\Config\01_OneHidden.cntk"));
model.Init(config);
// Load model
string modelFilePath = Path.Combine(Environment.CurrentDirectory, @"..\Output\Models\01_OneHidden");
model.CreateNetwork(string.Format("deviceId=-1\nmodelPath=\"{0}\"", modelFilePath));
// Generate random input values in the appropriate structure and size
var inputs = GetDictionary("features", 28 * 28, 255);
// We can preallocate the output structure and pass it in (multiple output layers)
outputs = GetDictionary("ol.z", 10, 1);
model.Evaluate(inputs, outputs);
}
OutputResults(outputs);
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}\nCallStack: {1}\n Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
}
/// <summary>
/// Evaluates a trained model and obtains multiple layers output
/// </summary>
private static void EvaluateModelMultipleLayers()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
Environment.CurrentDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Image\MNIST\Data\");
Dictionary <string, List <float> > outputs;
using (var model = new IEvaluateModelManagedF())
{
// Load model
string modelFilePath = Path.Combine(Environment.CurrentDirectory, @"..\Output\Models\01_OneHidden");
model.CreateNetwork(string.Format("modelPath=\"{0}\"", modelFilePath), deviceId: -1);
// Generate random input values in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.nodeInput);
var inputs = GetDictionary(inDims.First().Key, inDims.First().Value, 255);
// We request the output layer names(s) and dimension, we'll use the first one.
var outDims = model.GetNodeDimensions(NodeGroup.nodeOutput);
string outputLayerName = outDims.First().Key;
// We can preallocate the output structure and pass it in (multiple output layers)
outputs = GetDictionary(outputLayerName, outDims[outputLayerName], 1);
model.Evaluate(inputs, outputs);
}
OutputResults(outputs);
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}\nCallStack: {1}\n Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
}
/// <summary>
/// Init EvaluatorHelper and create network for image classification.
/// </summary>
/// <param name="ModelPath">Model Path,used full path.</param>
/// <param name="ImageWidth">The network input image width.</param>
/// <param name="ImageHeigh">The network input image heigh.</param>
/// <param name="ImageChannel">The network input image channel.</param>
/// <param name="DeviceId">deviceId = -1 for CPU, >=0 for GPU devices.</param>
public EvaluatorHelper(string ModelPath, int ImageWidth, int ImageHeigh, int ImageChannel, int DeviceId = -1)
{
if (!File.Exists(ModelPath))
{
MessageBox.Show(GlobalLanguage.FindText("EvaluatorHelper_ModelNotExist"), GlobalLanguage.FindText("Common_Notice"));
return;
}
if (ImageWidth <= 0 || ImageHeigh <= 0 || ImageChannel <= 0)
{
MessageBox.Show(GlobalLanguage.FindText("EvaluatorHelper_ImageSizeError"), GlobalLanguage.FindText("Common_Error"));
return;
}
this.modelPath = ModelPath;
this.deviceId = DeviceId;
this.model = new IEvaluateModelManagedF();
this.model.CreateNetwork(string.Format("modelPath=\"{0}\"", this.modelPath), this.deviceId);
this.image_Width = ImageWidth;
this.image_Heigh = ImageHeigh;
this.image_Channel = ImageChannel;
this.inputDims = this.model.GetNodeDimensions(NodeGroup.Input);
this.outputDims = this.model.GetNodeDimensions(NodeGroup.Output);
}
/// <summary>
/// Evaluates a trained model and obtains a single layer output
/// </summary>
private static void EvaluateModelSingleLayer()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
Environment.CurrentDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Image\MNIST\Data\");
List<float> outputs;
using (var model = new IEvaluateModelManagedF())
{
// Initialize model evaluator
string config = GetFileContents(Path.Combine(Environment.CurrentDirectory, @"..\Config\01_OneHidden.cntk"));
model.Init(config);
// Load model
string modelFilePath = Path.Combine(Environment.CurrentDirectory, @"..\Output\Models\01_OneHidden");
model.CreateNetwork(string.Format("deviceId=-1\nmodelPath=\"{0}\"", modelFilePath));
// Generate random input values in the appropriate structure and size
var inputs = GetDictionary("features", 28*28, 255);
// We can call the evaluate method and get back the results (single layer)...
outputs = model.Evaluate(inputs, "ol.z", 10);
}
OutputResults("ol.z", outputs);
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}\nCallStack: {1}\n Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
}
/// <summary>
/// Evaluates a network (without a model and without input) and obtains a single layer output
/// </summary>
private static void EvaluateNetworkSingleLayerNoInput()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
string workingDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Other\Simple2d\Config");
Environment.CurrentDirectory = initialDirectory;
List <float> outputs;
using (var model = new IEvaluateModelManagedF())
{
// Create the network
// This network (AddOperatorConstantNoInput_ndl_deprecated.cntk) is a simple network consisting of a single binary operator (Plus)
// operating over a two constants, therefore no input is necessary.
string networkFilePath = Path.Combine(workingDirectory, @"AddOperatorConstantNoInput_ndl_deprecated.cntk");
ThrowIfFileNotExist(networkFilePath, string.Format("Error: The network configuration file '{0}' does not exist.", networkFilePath));
string networkDescription = File.ReadAllText(networkFilePath);
model.CreateNetwork(networkDescription, deviceId: -1);
// We can call the evaluate method and get back the results (single layer)...
outputs = model.Evaluate("ol", 1);
}
OutputResults("ol", outputs);
}
catch (CNTKException ex)
{
OnCNTKException(ex);
}
catch (Exception ex)
{
OnGeneralException(ex);
}
}
/// <summary>
/// This method shows how to evaluate a trained image classification model, with
/// explicitly created feature vectors.
/// </summary>
public static List<float> EvaluateImageInputUsingFeatureVector()
{
List<float> outputs = null;
try
{
// This example requires the RestNet_18 model.
// The model can be downloaded from <see cref="https://www.cntk.ai/resnet/ResNet_18.model"/>
// The model is assumed to be located at: <CNTK>\Examples\Image\Classification\ResNet
// along with a sample image file named "zebra.jpg".
Environment.CurrentDirectory = initialDirectory;
using (var model = new IEvaluateModelManagedF())
{
model.CreateNetwork(string.Format("modelPath=\"{0}\"", resnetModelFilePath), deviceId: -1);
// Prepare input value in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.Input);
if (inDims.First().Value != resNetImageSize * resNetImageSize * 3)
{
throw new CNTKRuntimeException(string.Format("The input dimension for {0} is {1} which is not the expected size of {2}.", inDims.First(), inDims.First().Value, 224 * 224 * 3), string.Empty);
}
// Transform the image
Bitmap bmp = new Bitmap(Bitmap.FromFile(imageFileName));
var resized = bmp.Resize(resNetImageSize, resNetImageSize, true);
var resizedCHW = resized.ParallelExtractCHW();
var inputs = new Dictionary<string, List<float>>() { {inDims.First().Key, resizedCHW } };
// We can call the evaluate method and get back the results (single layer output)...
var outDims = model.GetNodeDimensions(NodeGroup.Output);
outputs = model.Evaluate(inputs, outDims.First().Key);
}
// Retrieve the outcome index (so we can compare it with the expected index)
var max = outputs.Select((value, index) => new { Value = value, Index = index })
.Aggregate((a, b) => (a.Value > b.Value) ? a : b)
.Index;
Console.WriteLine("EvaluateImageInputUsingFeatureVector: Outcome = {0}", max);
}
catch (CNTKException ex)
{
OnCNTKException(ex);
}
catch (Exception ex)
{
OnGeneralException(ex);
}
return outputs;
}
/// <summary>
/// This method shows how to evaluate a trained image classification model
/// </summary>
public static void EvaluateImageClassificationModel()
{
try
{
// This example requires the RestNet_18 model.
// The model can be downloaded from <see cref="https://www.cntk.ai/resnet/ResNet_18.model"/>
// The model is assumed to be located at: <CNTK>\Examples\Image\Miscellaneous\ImageNet\ResNet
// along with a sample image file named "zebra.jpg".
string workingDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Image\Miscellaneous\ImageNet\ResNet");
Environment.CurrentDirectory = initialDirectory;
List<float> outputs;
using (var model = new IEvaluateModelManagedF())
{
string modelFilePath = Path.Combine(workingDirectory, "ResNet_18.model");
model.CreateNetwork(string.Format("modelPath=\"{0}\"", modelFilePath), deviceId: -1);
// Prepare input value in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.Input);
if (inDims.First().Value != 224 * 224 * 3)
{
throw new CNTKRuntimeException(string.Format("The input dimension for {0} is {1} which is not the expected size of {2}.", inDims.First(), inDims.First().Value, 224 * 224 * 3), string.Empty);
}
// Transform the image
string imageFileName = Path.Combine(workingDirectory, "zebra.jpg");
Bitmap bmp = new Bitmap(Bitmap.FromFile(imageFileName));
var resized = bmp.Resize(224, 224, true);
var resizedCHW = resized.ParallelExtractCHW();
var inputs = new Dictionary<string, List<float>>() { {inDims.First().Key, resizedCHW } };
// We can call the evaluate method and get back the results (single layer output)...
var outDims = model.GetNodeDimensions(NodeGroup.Output);
outputs = model.Evaluate(inputs, outDims.First().Key);
}
// Retrieve the outcome index (so we can compare it with the expected index)
var max = outputs.Select((value, index) => new { Value = value, Index = index })
.Aggregate((a, b) => (a.Value > b.Value) ? a : b)
.Index;
Console.WriteLine("Outcome: {0}", max);
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}\nCallStack: {1}\n Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
}
/// <summary>
/// Evaluates a network (without a model and without input) and obtains a single layer output
/// </summary>
private static void EvaluateNetworkSingleLayerNoInput()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
string workingDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Other\Simple2d\Config");
Environment.CurrentDirectory = initialDirectory;
List<float> outputs;
using (var model = new IEvaluateModelManagedF())
{
// Create the network
// This network (AddOperatorConstantNoInput_ndl_deprecated.cntk) is a simple network consisting of a single binary operator (Plus)
// operating over a two constants, therefore no input is necessary.
string networkFilePath = Path.Combine(workingDirectory, @"AddOperatorConstantNoInput_ndl_deprecated.cntk");
ThrowIfFileNotExist(networkFilePath, string.Format("Error: The network configuration file '{0}' does not exist.", networkFilePath));
string networkDescription = File.ReadAllText(networkFilePath);
model.CreateNetwork(networkDescription, deviceId: -1);
// We can call the evaluate method and get back the results (single layer)...
outputs = model.Evaluate("ol", 1);
}
OutputResults("ol", outputs);
}
catch (CNTKException ex)
{
OnCNTKException(ex);
}
catch (Exception ex)
{
OnGeneralException(ex);
}
}
/// <summary>
/// Evaluates a trained model and obtains multiple layers output (including hidden layer)
/// </summary>
/// <remarks>
/// This example requires the 01_OneHidden trained model
/// </remarks>
private static void EvaluateModelMultipleLayers()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
Environment.CurrentDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Image\GettingStarted");
Dictionary<string, List<float>> outputs;
using (var model = new IEvaluateModelManagedF())
{
// Desired output layers
const string hiddenLayerName = "out.h1";
const string outputLayerName = "out.z";
// Load model
string modelFilePath = Path.Combine(Environment.CurrentDirectory, @".\Output\Models\01_OneHidden");
ThrowIfFileNotExist(modelFilePath,
string.Format("Error: The model '{0}' does not exist. Please follow instructions in README.md in <CNTK>/Examples/Image/GettingStarted to create the model.", modelFilePath));
var desiredOutputLayers = new List<string>() { hiddenLayerName, outputLayerName };
model.CreateNetwork(string.Format("modelPath=\"{0}\"", modelFilePath), deviceId: -1, outputNodeNames: desiredOutputLayers);
// Generate random input values in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.Input);
var inputs = GetDictionary(inDims.First().Key, inDims.First().Value, 255);
// We request the output layer names(s) and dimension, we'll get both the hidden layer and the output layer
var outDims = model.GetNodeDimensions(NodeGroup.Output);
// We can preallocate the output structure and pass it in (multiple output layers)
outputs = new Dictionary<string, List<float>>()
{
{ hiddenLayerName, GetFloatArray(outDims[hiddenLayerName], 1) },
{ outputLayerName, GetFloatArray(outDims[outputLayerName], 1) }
};
model.Evaluate(inputs, outputs);
}
OutputResults(outputs);
}
catch (CNTKException ex)
{
OnCNTKException(ex);
}
catch (Exception ex)
{
OnGeneralException(ex);
}
}
/// <summary>
/// Evaluates a trained model and obtains a single layer output
/// </summary>
/// <remarks>
/// This example requires the 01_OneHidden trained model
/// </remarks>
private static void EvaluateModelSingleLayer()
{
try
{
string outputLayerName;
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
Environment.CurrentDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Image\GettingStarted");
List<float> outputs;
using (var model = new IEvaluateModelManagedF())
{
// Load model
string modelFilePath = Path.Combine(Environment.CurrentDirectory, @".\Output\Models\01_OneHidden");
ThrowIfFileNotExist(modelFilePath,
string.Format("Error: The model '{0}' does not exist. Please follow instructions in README.md in <CNTK>/Examples/Image/GettingStarted to create the model.", modelFilePath));
model.CreateNetwork(string.Format("modelPath=\"{0}\"", modelFilePath), deviceId: -1);
// Generate random input values in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.Input);
var inputs = GetDictionary(inDims.First().Key, inDims.First().Value, 255);
// We request the output layer names(s) and dimension, we'll use the first one.
var outDims = model.GetNodeDimensions(NodeGroup.Output);
outputLayerName = outDims.First().Key;
// We can call the evaluate method and get back the results (single layer)...
outputs = model.Evaluate(inputs, outputLayerName);
}
OutputResults(outputLayerName, outputs);
}
catch (CNTKException ex)
{
OnCNTKException(ex);
}
catch (Exception ex)
{
OnGeneralException(ex);
}
}
/// <summary>
/// This method shows how to evaluate a trained FastR-CNN object detection model
/// </summary>
public static void EvaluateObjectDetectionModel()
{
initialDirectory = @"C:\local\cntk";
try
{
// This example requires the Fast-RCNN_grocery100 model.
// The model can be downloaded from <see cref="https://www.cntk.ai/Models/FRCN_Grocery/Fast-RCNN_grocery100.model"/>
// The model is assumed to be located at: <CNTK>\Examples\Image\PretrainedModels\
// It further requires the grocery image data set.
// Please run 'python install_fastrcnn.py' from <cntkroot>\Examples\Image\Detection\FastRCNN to get the data.
//string imageDirectory = Path.Combine(initialDirectory, @"\Examples\Image\DataSets\grocery\testImages");
//string modelDirectory = Path.Combine(initialDirectory, @"\Examples\Image\PretrainedModels");
string imageDirectory = (initialDirectory + @"\Examples\Image\DataSets\grocery\testImages");
string modelDirectory = (initialDirectory + @"\Examples\Image\PretrainedModels");
Environment.CurrentDirectory = initialDirectory;
List <float> outputs;
using (var model = new IEvaluateModelManagedF())
{
string modelFilePath = Path.Combine(modelDirectory, "Fast-RCNN_grocery100.model");
ThrowIfFileNotExist(modelFilePath,
string.Format("Error: The model '{0}' does not exist. Please download the model from https://www.cntk.ai/Models/FRCN_Grocery/Fast-RCNN_grocery100.model " +
"and save it under ..\\..\\Examples\\Image\\PretrainedModels.", modelFilePath));
model.CreateNetwork(string.Format("modelPath=\"{0}\"", modelFilePath), deviceId: -1);
// Prepare input value in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.Input);
if (inDims.First().Value != 1000 * 1000 * 3)
{
throw new CNTKRuntimeException(string.Format("The input dimension for {0} is {1} which is not the expected size of {2}.", inDims.First(), inDims.First().Value, 1000 * 1000 * 3), string.Empty);
}
// Transform the image
string imageFileName = Path.Combine(imageDirectory, "WIN_20160803_11_28_42_Pro.jpg");
ThrowIfFileNotExist(imageFileName, string.Format("Error: The test image file '{0}' does not exist.", imageFileName));
Bitmap bmp = new Bitmap(Bitmap.FromFile(imageFileName));
// TODO: preserve aspect ratio while scaling and pad the remaining pixels with (114, 114, 114)
var resized = bmp.Resize(1000, 1000, true);
var resizedCHW = resized.ParallelExtractCHW();
// TODO: generate ROI proposals using an external library, e.g. selective search,
// TODO: project them to the 1000 x 1000 image size and compute (x, y, w, h) relative to the image dimensions.
// TODO: Alternative workaround: run script 'A1_GenerateInputROIs.py' from <cntkroot>\Examples\Image\Detection\FastRCNN and read rois from file.
// parse rois: groups of 4 floats corresponding to (x, y, w, h) for an ROI
string roiCoordinates = "0.219 0.0 0.165 0.29 0.329 0.025 0.07 0.115 0.364 0.0 0.21 0.13 0.484 0.0 0.075 0.06 0.354 0.045 0.055 0.09 0.359 0.075 0.095 0.07 0.434 0.155 0.04 0.085 0.459 0.165 0.145 0.08 0.404 0.12 0.055 0.06 0.714 0.235 0.06 0.12 0.659 0.31 0.065 0.075 0.299 0.16 0.1 0.07 0.449 0.18 0.19 0.15 0.284 0.21 0.135 0.115 0.254 0.205 0.07 0.055 0.234 0.225 0.075 0.095 0.239 0.23 0.07 0.085 0.529 0.235 0.075 0.13 0.229 0.24 0.09 0.085 0.604 0.285 0.12 0.105 0.514 0.335 0.1 0.045 0.519 0.335 0.08 0.045 0.654 0.205 0.08 0.055 0.614 0.215 0.115 0.065 0.609 0.205 0.115 0.075 0.604 0.225 0.115 0.055 0.524 0.23 0.06 0.095 0.219 0.315 0.065 0.075 0.629 0.31 0.095 0.08 0.639 0.325 0.085 0.06 0.219 0.41 0.25 0.11 0.354 0.46 0.185 0.11 0.439 0.515 0.09 0.075 0.359 0.455 0.175 0.125 0.449 0.525 0.08 0.07 0.574 0.46 0.06 0.105 0.579 0.46 0.105 0.1 0.529 0.47 0.15 0.145 0.584 0.475 0.085 0.09 0.354 0.52 0.08 0.06 0.219 0.52 0.115 0.1 0.229 0.53 0.1 0.08 0.229 0.575 0.105 0.045 0.339 0.56 0.085 0.045 0.354 0.535 0.075 0.06 0.299 0.59 0.145 0.05 0.304 0.58 0.12 0.045 0.594 0.555 0.075 0.05 0.534 0.58 0.14 0.06 0.504 0.66 0.07 0.06 0.494 0.73 0.075 0.09 0.504 0.695 0.07 0.095 0.219 0.665 0.075 0.145 0.494 0.755 0.085 0.075 0.704 0.665 0.07 0.21 0.434 0.72 0.055 0.1 0.569 0.695 0.205 0.185 0.219 0.73 0.29 0.13 0.574 0.665 0.08 0.055 0.634 0.665 0.095 0.045 0.499 0.725 0.08 0.135 0.314 0.71 0.155 0.065 0.264 0.72 0.19 0.105 0.264 0.725 0.185 0.095 0.249 0.725 0.12 0.11 0.379 0.77 0.08 0.055 0.509 0.785 0.055 0.06 0.644 0.875 0.13 0.085 0.664 0.875 0.11 0.075 0.329 0.025 0.08 0.115 0.639 0.235 0.135 0.15 0.354 0.46 0.185 0.12 0.354 0.46 0.185 0.135 0.229 0.225 0.08 0.095 0.219 0.72 0.29 0.14 0.569 0.67 0.205 0.21 0.219 0.315 0.1 0.075 0.219 0.23 0.09 0.085 0.219 0.41 0.295 0.11 0.219 0.665 0.27 0.145 0.219 0.225 0.09 0.14 0.294 0.665 0.2 0.05 0.579 0.46 0.105 0.145 0.549 0.46 0.14 0.145 0.219 0.41 0.295 0.125 0.219 0.59 0.11 0.05 0.639 0.235 0.135 0.155 0.629 0.235 0.145 0.155 0.314 0.71 0.155 0.115 0.334 0.56 0.09 0.045 0.264 0.72 0.225 0.1 0.264 0.72 0.225 0.105 0.219 0.71 0.29 0.15 0.249 0.725 0.125 0.11 0.219 0.665 0.27 0.17 0.494 0.73 0.075 0.115 0.494 0.73 0.085 0.115 0.219 0.0 0.14 0.14 0.219 0.07 0.14 0.14 0.219 0.14 0.14 0.14";
var rois = roiCoordinates.Split(' ').Select(x => float.Parse(x)).ToList();
// inputs are the image itself and the ROI coordinates
var inputs = new Dictionary <string, List <float> >()
{
{ inDims.First().Key, resizedCHW }, { inDims.Last().Key, rois }
};
// We can call the evaluate method and get back the results (predictions per ROI and per class (no softmax applied yet!)...
var outDims = model.GetNodeDimensions(NodeGroup.Output);
outputs = model.Evaluate(inputs, outDims.First().Key);
}
// the object classes used in the grocery example
var labels = new[] { "__background__",
"avocado", "orange", "butter", "champagne", "eggBox", "gerkin", "joghurt", "ketchup",
"orangeJuice", "onion", "pepper", "tomato", "water", "milk", "tabasco", "mustard" };
int numLabels = labels.Length;
int numRois = outputs.Count / numLabels;
Console.WriteLine("Only showing predictions for non-background ROIs...");
int numBackgroundRois = 0;
for (int i = 0; i < numRois; i++)
{
var outputForRoi = outputs.Skip(i * numLabels).Take(numLabels).ToList();
// Retrieve the predicted label as the argmax over all predictions for the current ROI
var max = outputForRoi.Select((value, index) => new { Value = value, Index = index })
.Aggregate((a, b) => (a.Value > b.Value) ? a : b)
.Index;
if (max > 0)
{
Console.WriteLine("Outcome for ROI {0}: {1} \t({2})", i, max, labels[max]);
}
else
{
numBackgroundRois++;
}
}
Console.WriteLine("Number of background ROIs: {0}", numBackgroundRois);
}
catch (CNTKException ex)
{
OnCNTKException(ex);
}
catch (Exception ex)
{
OnGeneralException(ex);
}
}
public void EvalManagedEvaluateHiddenLayerTest()
{
string modelDefinition = @"deviceId = -1
precision = ""float""
traceLevel = 1
run=NDLNetworkBuilder
NDLNetworkBuilder=[
i1 = Input(1)
pool5 = Times(Constant(2), i1)
OutputNodes.z = Plus(pool5, Constant(7), tag=""output"")
FeatureNodes = (i1)
]";
using (var model = new IEvaluateModelManagedF())
{
var desiredOutputLayers = new List <string>()
{
"pool5", "OutputNodes.z"
};
model.CreateNetwork(modelDefinition, deviceId: -1, outputNodeNames: desiredOutputLayers);
var inDims = model.GetNodeDimensions(NodeGroup.Input);
Assert.AreEqual(inDims.Count(), 1);
Assert.AreEqual(inDims["i1"], 1);
var inputs = new Dictionary <string, List <float> >()
{
{ "i1", new List <float>()
{
5
} }
};
// We request the output layer names(s) and dimension, we'll use the first one.
var outDims = model.GetNodeDimensions(NodeGroup.Output);
Assert.AreEqual(outDims.Count(), 2);
Assert.AreEqual(outDims["pool5"], 1);
Assert.AreEqual(outDims["OutputNodes.z"], 1);
var outputs = new Dictionary <string, List <float> >()
{
// The order of node name below is different than that returned by outDims,
// in order to test whether the output values are correctly mapped to the name.
{ "pool5", new List <float>()
{
0
} },
{ "OutputNodes.z", new List <float>()
{
0
} }
};
// We can call the evaluate method and get back the results (single layer)...
model.Evaluate(inputs, outputs);
var expected1 = new List <float>()
{
10
};
var expected2 = new List <float>()
{
17
};
CollectionAssert.AreEqual(expected1, outputs["pool5"]);
CollectionAssert.AreEqual(expected2, outputs["OutputNodes.z"]);
}
}
/// <summary>
/// Evaluates a network (without a model) and obtains a single layer output
/// </summary>
private static void EvaluateNetworkSingleLayer()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
string workingDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Other\Simple2d\Config");
Environment.CurrentDirectory = initialDirectory;
List<float> outputs;
using (var model = new IEvaluateModelManagedF())
{
// Initialize model evaluator
model.Init("deviceId=-1");
// Create the network
string networkDescription = GetFileContents(Path.Combine(workingDirectory, @"AddOperatorConstant.cntk"));
model.CreateNetwork(networkDescription);
// Generate random input values in the appropriate structure and size
var inputs = new Dictionary<string, List<float>>() { { "features", new List<float>() { { 1.0f } } } };
// We can call the evaluate method and get back the results (single layer)...
outputs = model.Evaluate(inputs, "ol", 1);
}
OutputResults("ol", outputs);
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}\nCallStack: {1}\n Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
}
/// <summary>
/// Evaluates a network (without a model) and obtains a single layer output
/// </summary>
private static void EvaluateNetworkSingleLayer()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
string workingDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Other\Simple2d\Config");
Environment.CurrentDirectory = initialDirectory;
List<float> outputs;
string outputLayerName;
using (var model = new IEvaluateModelManagedF())
{
// Create the network
// This network (AddOperatorConstant.cntk) is a simple network consisting of a single binary operator (Plus)
// operating over a single input and a constant
string networkDescription = File.ReadAllText(Path.Combine(workingDirectory, @"AddOperatorConstant.cntk"));
model.CreateNetwork(networkDescription, deviceId:-1);
// Generate random input value in the appropriate structure and size
var inputs = new Dictionary<string, List<float>>() { { "features", new List<float>() { 1.0f } } };
// We can call the evaluate method and get back the results (single layer)...
var outDims = model.GetNodeDimensions(NodeGroup.nodeOutput);
outputLayerName = outDims.First().Key;
outputs = model.Evaluate(inputs, outputLayerName);
}
OutputResults(outputLayerName, outputs);
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}\nCallStack: {1}\n Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
}
/// <summary>
/// Evaluates a network (without a model and without input) and obtains a single layer output
/// </summary>
private static void EvaluateNetworkSingleLayerNoInput()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
string workingDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Other\Simple2d\Config");
Environment.CurrentDirectory = initialDirectory;
List<float> outputs;
using (var model = new IEvaluateModelManagedF())
{
// Create the network
// This network (AddOperatorConstantNoInput.cntk) is a simple network consisting of a single binary operator (Plus)
// operating over a two constants, therefore no input is necessary.
string networkDescription = File.ReadAllText(Path.Combine(workingDirectory, @"AddOperatorConstantNoInput.cntk"));
model.CreateNetwork(networkDescription, deviceId:-1);
// We can call the evaluate method and get back the results (single layer)...
outputs = model.Evaluate("ol", 1);
}
OutputResults("ol", outputs);
}
catch (CNTKException ex)
{
Console.WriteLine("Error: {0}\nNative CallStack: {1}\n Inner Exception: {2}", ex.Message, ex.NativeCallStack, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}\nCallStack: {1}\n Inner Exception: {2}", ex.Message, ex.StackTrace, ex.InnerException != null ? ex.InnerException.Message : "No Inner Exception");
}
}
public async Task <string[]> EvaluateCustomDNN(string imageUrl)
{
string domainBaseDirectory = AppDomain.CurrentDomain.BaseDirectory;
string workingDirectory = Environment.CurrentDirectory;
try
{
// This example requires the RestNet_18 model.
// The model can be downloaded from <see cref="https://www.cntk.ai/resnet/ResNet_18.model"/>
int numThreads = 1;
List <float> outputs;
using (var model = new IEvaluateModelManagedF())
{
// initialize the evaluation engine
// TODO: initializing the evaluation engine should be one only once at the beginning
var initParams = string.Format("numCPUThreads={0}", numThreads);
model.Init(initParams);
// load the model
string modelFilePath = Path.Combine(domainBaseDirectory, @"CNTK\Models\ResNet_18.model");
var modelOption = string.Format("modelPath=\"{0}\"", modelFilePath);
model.CreateNetwork(modelOption, deviceId: -1);
// Prepare input value in the appropriate structure and size
var inDims = model.GetNodeDimensions(NodeGroup.Input);
if (inDims.First().Value != 224 * 224 * 3)
{
throw new CNTKRuntimeException(string.Format("The input dimension for {0} is {1} which is not the expected size of {2}.", inDims.First(), inDims.First().Value, 224 * 224 * 3), string.Empty);
}
// Transform the image
System.Net.Http.HttpClient httpClient = new HttpClient();
Stream imageStream = await httpClient.GetStreamAsync(imageUrl);
Bitmap bmp = new Bitmap(Bitmap.FromStream(imageStream));
var resized = bmp.Resize(224, 224, true);
var resizedCHW = resized.ParallelExtractCHW();
var inputs = new Dictionary <string, List <float> >()
{
{ inDims.First().Key, resizedCHW }
};
// We can call the evaluate method and get back the results (single layer output)...
var outDims = model.GetNodeDimensions(NodeGroup.Output);
outputs = model.Evaluate(inputs, outDims.First().Key);
}
List <string> o = new List <string>();
foreach (float f in outputs)
{
o.Add(f.ToString());
}
return(o.ToArray <string>());
}
catch (Exception ex)
{
return(new string[] { string.Format("domainBase directory {0}, workingDirectory {1}, exception details: {2}.", domainBaseDirectory, workingDirectory, ex.ToString()) });
}
}
/// <summary>
/// Evaluates a network (without a model, but requiring input) and obtains a single layer output
/// </summary>
private static void EvaluateNetworkSingleLayer()
{
try
{
// The examples assume the executable is running from the data folder
// We switch the current directory to the data folder (assuming the executable is in the <CNTK>/x64/Debug|Release folder
string workingDirectory = Path.Combine(initialDirectory, @"..\..\Examples\Other\Simple2d\Config");
Environment.CurrentDirectory = initialDirectory;
List<float> outputs;
string outputLayerName;
using (var model = new IEvaluateModelManagedF())
{
// Create the network
// This network (AddOperatorConstant_ndl_deprecated.cntk) is a simple network consisting of a single binary operator (Plus)
// operating over a single input and a constant
string networkFilePath = Path.Combine(workingDirectory, @"AddOperatorConstant_ndl_deprecated.cntk");
ThrowIfFileNotExist(networkFilePath, string.Format("Error: The network configuration file '{0}' does not exist.", networkFilePath));
string networkDescription = File.ReadAllText(networkFilePath);
model.CreateNetwork(networkDescription, deviceId: -1);
// Prepare input value in the appropriate structure and size
var inputs = new Dictionary<string, List<float>>() { { "features", new List<float>() { 1.0f } } };
// We can call the evaluate method and get back the results (single layer output)...
var outDims = model.GetNodeDimensions(NodeGroup.Output);
outputLayerName = outDims.First().Key;
outputs = model.Evaluate(inputs, outputLayerName);
}
OutputResults(outputLayerName, outputs);
}
catch (CNTKException ex)
{
OnCNTKException(ex);
}
catch (Exception ex)
{
OnGeneralException(ex);
}
}
