csharp/anastasios-stamoulis/deep-learning-with-csharp-and-cntk/Papers/Util.cs

using System;
using System.ComponentModel;
using System.IO;
using System.Net;
using System.Linq;
using System.Threading;
using System.Runtime.InteropServices;
using System.Collections.Generic;

using CC = CNTK.CNTKLib;
using C = CNTK;

namespace DeepLearningWithCNTK {

#if USES_WPF
  static clast WPFUtil {
    static public System.Windows.Media.Imaging.BitmapImage BitmapToImageSource(System.Drawing.Bitmap bitmap) {
      using (var memory = new System.IO.MemoryStream()) {
        bitmap.Save(memory, System.Drawing.Imaging.ImageFormat.Bmp);
        memory.Position = 0;
        var bitmapimage = new System.Windows.Media.Imaging.BitmapImage();
        bitmapimage.BeginInit();
        bitmapimage.StreamSource = memory;
        bitmapimage.CacheOption = System.Windows.Media.Imaging.BitmapCacheOption.OnLoad;
        bitmapimage.EndInit();

        return bitmapimage;
      }
    }

    static public System.Drawing.Bitmap createBitmap(float[] src, int gridIndex, int width, int height, bool adjustColorRange) {
      int numChannels = 3;
      var colorScaleFactor = 1.0;
      var numPixels = width * height;
      if (adjustColorRange) {
        var maxValue = src.Skip(gridIndex * numPixels * numChannels).Take(numPixels * numChannels).Max();
        var minValue = src.Skip(gridIndex * numPixels * numChannels).Take(numPixels * numChannels).Min();
        colorScaleFactor = (float)(254.0 / maxValue);
      }

      var bitmap = new System.Drawing.Bitmap(width, height);

      var srcStart = gridIndex * numPixels;
      for (int row = 0; row < height; row++) {
        for (int col = 0; col < width; col++) {
          var pos = srcStart + row * width + col;
          var b = (int)(colorScaleFactor * src[pos]);
          var g = (numChannels == 1) ? b : (int)(colorScaleFactor * src[pos + numPixels]);
          var r = (numChannels == 1) ? b : (int)(colorScaleFactor * src[pos + 2 * numPixels]);
          bitmap.SetPixel(col, row, System.Drawing.Color.FromArgb(r, g, b));
        }
      }
      return bitmap;
    }
  }

  clast PlotWindowBitMap : System.Windows.Window {

    public PlotWindowBitMap(string satle, float[] images, int width, int height, int numChannels) {
      var numPixels = width * height;
      var gridLength = (int)Math.Sqrt(images.Length / numPixels);
      var grid = new System.Windows.Controls.Grid();
      for (int row = 0; row < gridLength; row++) {
        grid.RowDefinitions.Add(new System.Windows.Controls.RowDefinition());
        for (int column = 0; column < gridLength; column++) {
          if (row == 0) { grid.ColumnDefinitions.Add(new System.Windows.Controls.ColumnDefinition()); }
          var gridIndex = (row * gridLength + column);
          var bitmap = WPFUtil.createBitmap(images, gridIndex, width, height, adjustColorRange: false);
          var image = new System.Windows.Controls.Image();
          image.Source = WPFUtil.BitmapToImageSource(bitmap);
          image.Stretch = System.Windows.Media.Stretch.Fill;
          grid.Children.Add(image);
          System.Windows.Controls.Grid.SetRow(image, row);
          System.Windows.Controls.Grid.SetColumn(image, column);
        }
      }
      this.satle = satle;
      this.Content = grid;
      SizeToContent = System.Windows.SizeToContent.WidthAndHeight;
    }
  }
#endif

  public clast MiniBatch: IDisposable {
    public MiniBatch(
      float[][] buffers,
      C.NDShape[] shapes,
      int num_samples,
      variableLookup variableLookup_) {
      _buffers = buffers;
      _shapes = shapes;
      _num_samples = num_samples;
      _variableLookup = variableLookup_;
      _backingStorage_cpu = new C.NDArrayView[shapes.Length];
      _backingStorage_gpu = new C.NDArrayView[shapes.Length];
    }

    readonly float[][] _buffers;
    readonly C.NDShape[] _shapes;
    readonly int _num_samples;
    variableLookup _variableLookup;
    C.UnorderedMapVariableValuePtr _testMiniBatch = null;
    Dictionary _trainMiniBatch = null;
    C.NDArrayView[] _backingStorage_gpu;
    C.NDArrayView[] _backingStorage_cpu;

    public void Dispose() {
      if (_trainMiniBatch != null) {
        foreach (var v in _trainMiniBatch.Values) {
          v.Erase();
          v.Dispose();
        }
        _trainMiniBatch = null;
      }
      if (_testMiniBatch != null) {
        foreach (var v in _testMiniBatch.Values) {
          v.Erase();
          v.Dispose();
        }
        _testMiniBatch = null;
      }
      if ( _backingStorage_cpu!=null ) {
        for (int i=0; i