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 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 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> /// 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 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> /// 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 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"); } }
/// <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> /// 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> /// 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 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 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 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); } }
public void EvalManagedEvaluateDualOutputsTest() { string modelDefinition = @"deviceId = -1 precision = ""float"" traceLevel = 1 run=NDLNetworkBuilder NDLNetworkBuilder=[ i1 = Input(1) o1 = Times(Constant(3), i1, tag=""output"") o2 = Times(Constant(5), 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> >() { { "i1", new List <float>() { 2 } } }; var outDims = model.GetNodeDimensions(NodeGroup.Output); Assert.AreEqual(outDims.Count(), 2); Assert.AreEqual(outDims["o1"], 1); Assert.AreEqual(outDims["o2"], 1); var outputs = new Dictionary <string, List <float> >() { { "o1", new List <float>() { 0 } }, { "o2", new List <float>() { 0 } } }; model.Evaluate(inputs, outputs); var expected1 = new List <float>() { 6 }; var expected2 = new List <float>() { 10 }; CollectionAssert.AreEqual(expected1, outputs["o1"]); CollectionAssert.AreEqual(expected2, outputs["o2"]); } }
/// <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"); ThrowIfFileNotExist(modelFilePath, string.Format("Error: The model '{0}' does not exist. Please download the model from https://www.cntk.ai/resnet/ResNet_18.model and save it under ..\\..\\Examples\\Image\\Miscellaneous\\ImageNet\\ResNet.", 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 != 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"); ThrowIfFileNotExist(imageFileName, string.Format("Error: The test image file '{0}' does not exist.", imageFileName)); 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"); } }
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"]); } }