// NB: Mirror not really implemented ...
// Nullable<bool> mirror_ = null;
public DataLayer(int index, int inputDimension, ImageCoordinates inputCoordinates)
{
scale_ = 1.0;
meanImage_ = null;
meanChannel_ = null;
InitLayer(index, LayerType.DATA_LAYER, inputDimension, inputDimension, inputCoordinates, inputCoordinates);
}
public static NeuralNet ReadNeuralNet(Func <int> readInt32, Func <double> readSingle, int inputDimension, ImageCoordinates inputCoordinates)
{
NeuralNet nn = new NeuralNet();
int layerCount = readInt32();
int curDimension = inputDimension;
ImageCoordinates curCoordinates = inputCoordinates;
CropTransform cropT = null;
for (int i = 0; i < layerCount; i++)
{
Layer layer = ReadLayer(i, readInt32, readSingle, curCoordinates, curDimension, out cropT);
if (layer != null)
{
nn.AddLayer(layer);
curDimension = layer.OutputDimension;
curCoordinates = layer.OutputCoordinates;
if (layer.LayerType == LayerType.DATA_LAYER && cropT != null)
{
nn.AddCropTransform(cropT);
}
}
}
// Currently disabled because perf gains are not enough, in fact things seem somewhat slower ...
// Console.Write("Linearizing sequences of linear layers ...");
// Coalesce affine layers for running the network more optimally
// nn.CoalesceToVirtual();
// GC.Collect(2);
// Console.WriteLine("Done.");
return(nn);
}
public AugmentContrast(ImageCoordinates coords, int how_many, double min_contrast_factor, double max_contrast_factor)
{
_coords = coords;
_how_many = how_many;
_max_contrast_factor = max_contrast_factor;
_min_contrast_factor = min_contrast_factor;
_random = new Random(System.DateTime.Now.Millisecond);
}
public AugmentRotation(ImageCoordinates coords, int how_many, float degrees)
{
_coords = coords;
_how_many = how_many;
_degrees = degrees;
Trace.Assert(degrees >= -180.0 && degrees <= 180.0);
_random = new Random(System.DateTime.Now.Millisecond);
}
public AugmentBrightness(ImageCoordinates coords, RANDTYPE typ, int how_many, double max_eps)
{
_typ = typ;
_coords = coords;
_how_many = how_many;
_max_eps = max_eps;
_random = new Random(System.DateTime.Now.Millisecond);
}
public CropTransform(ImageCoordinates inputCoordinates, int inputDimension, int cropSize, bool fromCenter = true)
{
cropSize_ = cropSize;
inputDimension_ = inputDimension;
inputCoordinates_ = inputCoordinates;
outputDimension_ = cropSize * cropSize * inputCoordinates.ChannelCount;
outputCoordinates_ = new ImageCoordinates(inputCoordinates.ChannelCount, cropSize, cropSize);
}
public AugmentGeometric(ImageCoordinates coords, RANDTYPE typ, int how_many, int xoffest, int yoffset)
{
_typ = typ;
_coords = coords;
_how_many = how_many;
_xoffset = xoffest;
_yoffset = yoffset;
_random = new Random(System.DateTime.Now.Millisecond);
}
/// <summary>
/// Reading from our own text format. These are the networks we we get as output from our Torch/LUA experiments.
/// </summary>
/// <param name="file"></param>
/// <param name="inputDimension"></param>
/// <param name="inputCoordinates"></param>
/// <returns></returns>
public static NeuralNet ReadTxtNeuralNet(string file, int inputDimension, ImageCoordinates inputCoordinates)
{
Console.WriteLine("Reading neural net from file: " + file);
using (FileStream fs = File.Open(file, FileMode.Open))
{
TextReader br = new StreamReader(fs);
return(ReadNeuralNet(() => ReadInt32_TextNewLine(br),
() => ReadSingle_TextNewLine(br), inputDimension, inputCoordinates));
}
}
public AugmentLossyJpeg(ImageCoordinates coords, int how_many, int loss)
{
_coords = coords;
_how_many = how_many;
_loss = loss;
Trace.Assert(loss >= 0 && loss <= 100);
_random = new Random(System.DateTime.Now.Millisecond);
}
public InnerProductLayer(int index, Matrix <double> weights, Vector <double> intercepts, ImageCoordinates inputCoordinates)
{
weightMatrix_ = weights;
weightMatrixRows_ = new Vector <double> [weightMatrix_.RowCount];
for (int i = 0; i < weightMatrix_.RowCount; i++)
{
weightMatrixRows_[i] = weightMatrix_.Row(i);
}
interceptVector_ = intercepts;
inputCoordinates_ = inputCoordinates;
InitLayer(index, LayerType.INNER_PRODUCT, weights.ColumnCount, weights.RowCount, inputCoordinates, null);
}
ImageCoordinates outputCoordinates_; // NB: null means there is no particular structure in the output
public void InitLayer(
int index,
LayerType layerType,
int inputDimension,
int outputDimension,
ImageCoordinates inputCoordinates,
ImageCoordinates outputCoordinates)
{
index_ = index;
layerType_ = layerType;
inputDimension_ = inputDimension;
outputDimension_ = outputDimension;
inputCoordinates_ = inputCoordinates;
outputCoordinates_ = outputCoordinates;
}
public static Layer ReadLayer(int index, Func <int> readInt32, Func <double> readSingle,
ImageCoordinates inputCoordinates,
int inputDim,
out CropTransform cropT
)
{
int typeID = readInt32();
cropT = null;
Console.Write("Reading layer with index {0,2}, of type {1}, input dimension {2}:", index, typeID, inputDim);
switch (typeID)
{
case 0: // "Data"
Console.WriteLine("Data");
var res = ReadDataLayer(index, readInt32, readSingle, inputCoordinates, inputDim);
cropT = res.Item1;
return(res.Item2);
case 1: // "InnerProduct"
Console.Write("InnerProduct");
return(ReadInnerProductLayer(index, readInt32, readSingle, inputCoordinates, inputDim));
case 2: // "ReLU"
Console.WriteLine("ReLU");
return(ReadRectifiedLinearLayer(index, readInt32, readSingle, inputCoordinates, inputDim));
case 3: // "SoftmaxWithLoss"
Console.WriteLine("SoftMax");
return(ReadSoftmaxLayer(readInt32, readSingle));
case 4: // "Convolution"
Console.WriteLine("Convolution");
return(ReadConvolutional(index, readInt32, readSingle, inputCoordinates, inputDim));
case 5: // "Pooling"
Console.Write("Pooling, ");
return(ReadPooling(index, readInt32, readSingle, inputCoordinates));
case 6: // "Dropout"
Console.Write("Dropout, ");
return(null);
default:
throw new Exception("Layer type ID not recognized: " + typeID);
}
}
public PoolingLayer(int index, ImageCoordinates inputCoordinates, int kernelDimension, int padding, int stride) : base()
{
inputCoordinates_ = inputCoordinates;
kernelDimension_ = kernelDimension;
padding_ = padding;
stride_ = stride;
int inputDimension = inputCoordinates_.ChannelCount * inputCoordinates_.RowCount * inputCoordinates_.ColumnCount;
int rowCount = Utils.UImageCoordinate.ComputeOutputCounts(kernelDimension, inputCoordinates.RowCount, stride, padding, true);
int columnCount = Utils.UImageCoordinate.ComputeOutputCounts(kernelDimension, inputCoordinates.ColumnCount, stride, padding, true);
int outputDimension = inputCoordinates.ChannelCount * rowCount * columnCount;
ImageCoordinates ouputCoordinates = new ImageCoordinates(inputCoordinates.ChannelCount, rowCount, columnCount);
InitLayer(index, LayerType.POOLING_LAYER, inputDimension, outputDimension, inputCoordinates, ouputCoordinates);
}
public ConvolutionLayer(int index, ImageCoordinates inputCoordinates, double[][] kernels, double[] intercepts, int kernelDimension, int padding)
{
kernelMatrix_ = DenseMatrix.OfRowArrays(kernels);
interceptVector_ = DenseVector.OfArray(intercepts);
kernelDimension_ = kernelDimension;
padding_ = padding;
int inputDimension = inputCoordinates.ChannelCount * inputCoordinates.RowCount * inputCoordinates.ColumnCount;
kernelCoordinates_ = new ImageCoordinates(kernels.Length, kernelDimension_, kernelDimension_);
outputRowCount_ = Utils.UImageCoordinate.ComputeOutputCounts(kernelDimension, inputCoordinates.RowCount, 1, padding, false);
outputColumnCount_ = Utils.UImageCoordinate.ComputeOutputCounts(kernelDimension, inputCoordinates.ColumnCount, 1, padding, false);
outputChannelCount_ = kernels.Length;
ImageCoordinates outputCoordinates = new ImageCoordinates(outputChannelCount_, outputRowCount_, outputColumnCount_);
int outputDimension = outputChannelCount_ * outputRowCount_ * outputColumnCount_;
InitLayer(index, LayerType.CONVOLUTION_LAYER, inputDimension, outputDimension, inputCoordinates, outputCoordinates);
symbolic_output_storage = new ThreadLocal <LPSTerm[]>();
// Fast convolution stuff:
var jBound = Utils.UImageCoordinate.ComputeOutputCounts(KernelDimension, InputCoordinates.RowCount, 1, Padding, false);
var kBound = Utils.UImageCoordinate.ComputeOutputCounts(KernelDimension, InputCoordinates.ColumnCount, 1, Padding, false);
int kernelpositions = jBound * kBound;
CheckInitThreadLocalScratch(kernelpositions);
_intercept_scratch = DenseMatrix.Create(kernelMatrix_.RowCount, kernelpositions, 0.0);
for (int k = 0; k < kernelMatrix_.RowCount; k++)
{
for (int x = 0; x < kernelpositions; x++)
{
_intercept_scratch[k, x] = interceptVector_[k];
}
}
}
public DataLayer(int index, int inputDimension,
ImageCoordinates inputCoordinates,
double scale,
double[] meanImage,
List <double> meanChannel
)
{
scale_ = scale;
meanImage_ = meanImage;
if (meanChannel != null && meanChannel.Count > 0)
{
int channel_count = inputCoordinates.ChannelCount;
meanChannel_ = new double[channel_count];
for (int i = 0; i < channel_count; i++)
{
meanChannel_[i] = meanChannel[i % meanChannel.Count()];
}
}
InitLayer(index, LayerType.DATA_LAYER, inputDimension, inputDimension, inputCoordinates, inputCoordinates);
}
static Layer ReadConvolutional(int index, Func <int> readInt32, Func <double> readSingle, ImageCoordinates inputCoordinates, int inputDim)
{
int kernelCount = readInt32();
int kernelDimension = readInt32();
int padding = readInt32();
// read kernels
int kernelTotalDataCount = readInt32();
int kernelDataCount = kernelTotalDataCount / kernelCount;
double[][] kernels = new double[kernelCount][];
for (int i = 0; i < kernelCount; i++)
{
kernels[i] = new double[kernelDataCount];
for (int j = 0; j < kernelDataCount; j++)
{
kernels[i][j] = readSingle();
}
}
// read intercepts
int interceptTotalDataCount = readInt32();
if (interceptTotalDataCount != kernelCount)
{
throw new Exception("Invalid parameters!");
}
double[] intercepts = new double[kernelCount];
for (int i = 0; i < kernelCount; i++)
{
intercepts[i] = readSingle();
}
int channelCount = (kernelDataCount / (kernelCount * kernelDimension * kernelDimension));
ImageCoordinates kernelCoordinates = new ImageCoordinates(channelCount, kernelDimension, kernelDimension);
return(new ConvolutionLayer(index, inputCoordinates, kernels, intercepts, kernelDimension, padding));
}
public InnerProductLayer(int index, double[][] weights, double[] intercepts, ImageCoordinates inputCoordinates)
: this(index, SparseMatrix.OfRowArrays(weights), DenseVector.OfArray(intercepts), inputCoordinates)
{
}
static Layer ReadRectifiedLinearLayer(int index, Func <int> readInt32, Func <double> readSingle, ImageCoordinates inputCoordinates, int inputDim)
{
return(new ReLULayer(index, inputDim, inputCoordinates));
}
static Layer ReadPooling(int index, Func <int> readInt32, Func <double> readSingle, ImageCoordinates inputCoordinates)
{
int kernelDimension = readInt32();
int stride = readInt32();
int padding = readInt32();
int poolMeth = readInt32();
if (kernelDimension == 0)
{
Console.WriteLine("Kernel dimension = 0, treating this as global pooling!");
Debug.Assert(inputCoordinates.ColumnCount == inputCoordinates.RowCount);
Debug.Assert(padding == 0);
kernelDimension = inputCoordinates.ColumnCount;
}
if (poolMeth == 0)
{ // MAX
Console.WriteLine("Pool method = MAX");
return(new MaxPoolingLayer(index, inputCoordinates, kernelDimension, padding, stride));
}
else
{ // AVG
Console.WriteLine("Pool method = AVG");
return(new AvgPoolingLayer(index, inputCoordinates, kernelDimension, padding, stride));
}
}
static Tuple <CropTransform, Layer> ReadDataLayer(
int index,
Func <int> readInt32, Func <double> readSingle,
ImageCoordinates inputCoordinates,
int inputDim)
{
int has_transform_param = readInt32();
if (has_transform_param == 0)
{
DataLayer layer = new DataLayer(index, inputDim, inputCoordinates);
return(new Tuple <CropTransform, Layer>(null, layer));
}
// Scale
double scale = 1.0;
int has_scale = readInt32();
if (has_scale != 0)
{
scale = readSingle();
}
// Mirror
int has_mirror = readInt32(); // ignore
// Crop size
CropTransform cropT_ = null;
int has_crop_siz = readInt32();
if (has_crop_siz != 0)
{
int crop_siz = readInt32();
cropT_ = new CropTransform(inputCoordinates, inputDim, crop_siz, true);
}
// Mean value
List <double> mean_val = new List <double>();
int mean_val_cnt = readInt32();
for (int x = 0; x < mean_val_cnt; x++)
{
mean_val.Add(readSingle());
}
// Mean file
int has_mean_file = readInt32();
double[] mean_image = null;
if (has_mean_file != 0)
{
int mean_image_siz = readInt32();
if (mean_image_siz > 0)
{
mean_image = new double[mean_image_siz];
}
for (int x = 0; x < mean_image_siz; x++)
{
mean_image[x] = readSingle();
}
}
ImageCoordinates dataLayerInputCoordinates = inputCoordinates;
int dataLayerInputDim = inputDim;
double[] dataLayerMeanImage = mean_image;
if (cropT_ != null)
{
dataLayerInputCoordinates = cropT_.TransformedCoordinates();
dataLayerInputDim = cropT_.TransformedDimension();
if (mean_image != null)
{
dataLayerMeanImage = cropT_.Transform(DenseVector.OfArray(mean_image)).ToArray();
}
}
Layer l = new DataLayer(
index,
dataLayerInputDim,
dataLayerInputCoordinates,
scale,
dataLayerMeanImage,
mean_val);
return(new Tuple <CropTransform, Layer>(cropT_, l));
}
public ReLULayer(int index, int dimension, ImageCoordinates coordinates)
{
dimension_ = dimension;
InitLayer(index, LayerType.RECTIFIED_LINEAR, dimension, dimension, coordinates, coordinates);
}
public MaxPoolingLayer(int index, ImageCoordinates inputCoordinates, int kernelDimension, int padding, int stride) :
base(index, inputCoordinates, kernelDimension, padding, stride)
{
}
static Layer ReadInnerProductLayer(int index, Func <int> readInt32, Func <double> readSingle, ImageCoordinates inputCoordinates, int inputDim)
{
// Caffe format:
// K : input dimension
// N : output dimension
// A : N * K dimensional matrix (row major order)
// B : N dimensional vector
// Matrix formula: output = A * input + B
// Array formula: output[i] = (\sum_j A[i][j] * x[j]) + B[i]
int inputDimension = readInt32();
int outputDimension = readInt32();
double[][] weights = new double[outputDimension][];
for (int i = 0; i < outputDimension; i++)
{
weights[i] = new double[inputDimension];
for (int j = 0; j < inputDimension; j++)
{
weights[i][j] = readSingle();
}
}
double[] intercept = new double[outputDimension];
for (int i = 0; i < outputDimension; i++)
{
intercept[i] = readSingle();
}
Console.WriteLine("Dimensions: " + inputDimension + " * " + outputDimension);
return(new InnerProductLayer(index, weights, intercept, inputCoordinates));
}
public InnerProductLayer(int index, Tuple <Matrix <double>, Vector <double> > ws_and_is, ImageCoordinates inputCoordinates)
: this(index, ws_and_is.Item1, ws_and_is.Item2, inputCoordinates)
{
}
