// Create Value object from sparse input as sequence data, for N-dimensional tensor. Only CreateSequence() for now. public static Value CreateSequence <T>(NDShape sampleShape, int sequenceLength, int[] colStarts, int[] rowIndices, T[] nonZeroValues, DeviceDescriptor device, bool readOnly = false) { return(Value.CreateSequence <T>(sampleShape, sequenceLength, colStarts, rowIndices, nonZeroValues, true, device, readOnly)); }
// Create Value object from sparse input as sequence data with sequenceStartFlag, for N-dimensional tensor. Only CreateSequence() for now. public static Value CreateSequence <T>(NDShape sampleShape, int sequenceLength, int[] colStarts, int[] rowIndices, T[] nonZeroValues, bool sequenceStartFlag, DeviceDescriptor device, bool readOnly = false) { if (nonZeroValues.Length != rowIndices.Length) { throw new System.ArgumentException("The length of rowIndicies must be same as the length of nonZeroValues."); } if (colStarts.Length != sequenceLength + 1) { throw new System.ArgumentException("The length of colStarts must be equal to (sequenceLength + 1)"); } uint numNonZeroValues = (uint)nonZeroValues.Length; if (typeof(T).Equals(typeof(float))) { return(Value._CreateSequenceFloat(sampleShape, (uint)sequenceLength, colStarts, rowIndices, nonZeroValues as float[], numNonZeroValues, sequenceStartFlag, device, readOnly)); } else if (typeof(T).Equals(typeof(double))) { return(Value._CreateSequenceDouble(sampleShape, (uint)sequenceLength, colStarts, rowIndices, nonZeroValues as double[], numNonZeroValues, sequenceStartFlag, device, readOnly)); } else { throw new System.ArgumentException("The data type " + typeof(T).ToString() + " is not supported. Only float or double is supported by CNTK."); } }
// Create Value object from NDArrayViews. public static Value Create(NDShape sampleShape, System.Collections.Generic.IEnumerable <NDArrayView> sequences, DeviceDescriptor device, bool readOnly = false) { return(Create(sampleShape, sequences, new System.Collections.Generic.List <bool>(0), device, readOnly)); }
// Create Value object from OneHotVector input, for N-dimenstional tensor. Only Create() method for now. public static Value Create <T>(NDShape sampleShape, System.Collections.Generic.IEnumerable <System.Collections.Generic.IEnumerable <int> > sequences, System.Collections.Generic.IEnumerable <bool> sequenceStartFlags, DeviceDescriptor device, bool readOnly = false) { var seqFlags = Helper.AsBoolVector(sequenceStartFlags); var inputSeqVector = new SizeTVectorVector(); foreach (var seq in sequences) { var s = Helper.AsSizeTVector(seq); inputSeqVector.Add(s); } if (typeof(T).Equals(typeof(float))) { return(Value._CreateOneHotFloat(sampleShape, inputSeqVector, seqFlags, device, readOnly)); } else if (typeof(T).Equals(typeof(double))) { return(Value._CreateOneHotDouble(sampleShape, inputSeqVector, seqFlags, device, readOnly)); } else { throw new System.ArgumentException("The data type " + typeof(T).ToString() + " is not supported. Only float or double is supported by CNTK."); } }
public NDMask(NDShape shape) : this(CNTKLibPINVOKE.new_NDMask__SWIG_1(NDShape.getCPtr(shape)), true) { if (CNTKLibPINVOKE.SWIGPendingException.Pending) { throw CNTKLibPINVOKE.SWIGPendingException.Retrieve(); } }
//Copy bias to match the dimensions of the input private static float[] make_copies(float[] kernel, NDShape dims, bool swap_axes = false) { int K = dims[0] * dims[1]; float[] outarray = new float[dims[0] * dims[1] * dims[2]]; if (swap_axes == false) { //Loop over number of maps for (int k = 0; k < dims[2]; k++) { //Loop over spatial dimensions for (int kk = 0; kk < K; kk++) { outarray[k * K + kk] = kernel[k]; } } } else { //Loop over number of maps for (int k = 0; k < K; k++) { //Loop over spatial dimensions for (int kk = 0; kk < dims[2]; kk++) { outarray[k * dims[2] + kk] = kernel[kk]; } } } return(outarray); }
/// <summary> /// from HxWxC input, reshape it to (H*W)xC, get mean and covariance matrix for channels /// Uses CNTK . This is priamarily used by whitening related /// </summary> /// <param name="input"></param> /// <param name="device"></param> /// <returns>tuple of cov, mean and reshaped inputs</returns> private static Tuple <Value, Value, Value> CovarianceMatrixFromImage(Value image, DeviceDescriptor device, out Tuple <Variable, Variable, Variable> outputs) { //create the CNTK model to multiply and reshape to get the covariance matrix, also get the mean NDShape inputShape = image.Shape; Variable input = Variable.InputVariable(inputShape, DataType.Float, "input"); Variable reshaped = CNTKLib.Reshape(input, new int[] { inputShape[0] * inputShape[1], inputShape[2] });//change the shape to (W*H)xC Variable mean = CNTKLib.ReduceMean(reshaped, new Axis(0)); Variable centered = CNTKLib.Minus(reshaped, mean); Variable covMat = CNTKLib.ElementDivide(CNTKLib.TransposeTimes(centered, centered), Constant.Scalar(DataType.Float, inputShape[0] * inputShape[1] - 1.0)); var inputDataMap = new Dictionary <Variable, Value>() { { input, image } }; var outputDataMap = new Dictionary <Variable, Value>() { { covMat, null }, { mean, null }, { centered, null } }; ((Function)covMat).Evaluate(inputDataMap, outputDataMap, false, device); outputs = new Tuple <Variable, Variable, Variable>(covMat, mean, reshaped); var result = new Tuple <Value, Value, Value>(outputDataMap[covMat], outputDataMap[mean], outputDataMap[centered]); return(result); }
static void Main(string[] args) { string filePath = @"D:/Users/Sachit/source/repos/SamplesRepo/IrisData/IrisData/iris-data/saved_model.model"; var cpu = DeviceDescriptor.UseDefaultDevice(); Console.WriteLine($"Hello from CNTK for {cpu.Type} only!"); Variable input; Function f = Function.Load(filePath, cpu); Variable inp = f.Arguments.Single(); NDShape iShape = inp.Shape; var iDataMap = new Dictionary <Variable, Value>(); float[] a = new float[] { 1.2f, 2.3f, 3f, 4f, 8f, 2f, 3f, 1f }; var iVal = Value.CreateBatch(iShape, a, cpu); iDataMap.Add(inp, iVal); Variable outVar = f.Output; var outDataMap = new Dictionary <Variable, Value>(); outDataMap.Add(outVar, null); f.Evaluate(iDataMap, outDataMap, cpu); var oval = outDataMap[outVar]; var odata = oval.GetDenseData <float>(outVar); Console.WriteLine(""); }
public static NDArrayView SafeCreate(NDShape shape, float[] data, DeviceDescriptor device) { if (device == null) { device = DeviceDescriptor.UseDefaultDevice(); } if (device == DeviceDescriptor.CPUDevice) { unsafe { fixed(float *f = data) { using (var a = new NDArrayView(shape, data, DeviceDescriptor.CPUDevice, false)) { // The NDArrayview constructor with float[] data does not copy nor hold the reference to the source data. // To make the object keep track of its data by itself, make a copy of it by calling DeepClone(). return(a.DeepClone(device, false)); } } } } // Allocating in GPU memory inevitably causes copying. return(new NDArrayView(shape, data, device, false)); }
private Function Conv(int[] convMapSize, Variable x, DataType dType, DeviceDescriptor device, bool usePadding, bool useBias, string name, uint seed) { var shape = CNTK.NDShape.CreateNDShape(convMapSize); var W = Weights(shape, dType, device, seed); // var strides = new int[] { 1 }; var sharing = new bool[] { true }; var aPadding = new bool[] { usePadding }; // var result = CNTKLib.Convolution(W, x, strides, sharing, aPadding); if (useBias) { var intArray = convMapSize.Length == 4 ? new int[] { 1, 1, NDShape.InferredDimension } : new int[] { 1, }; var bShape = NDShape.CreateNDShape(intArray); var b = Bias(bShape, dType, device); result = CNTK.CNTKLib.Plus(result, b); } result = CNTK.CNTKLib.ReLU(result, name); return(result); }
public List <int> Recognize(string Path) { var outputDataMap = new Dictionary <Variable, Value>() { { Classifier.Output, null } }; Variable inputVar = Classifier.Arguments.Single(); NDShape inputShape = inputVar.Shape; int imageWidth = inputShape[0]; int imageHeight = inputShape[1]; string sampleImage = Path; Bitmap bmp = new Bitmap(Bitmap.FromFile(sampleImage)); var resized = bmp.Resize(imageWidth, imageHeight, true); List <float> resizedCHW = resized.ParallelExtractCHW(); var inputDataMap = new Dictionary <Variable, Value>(); var inputVal = Value.CreateBatch(inputShape, resizedCHW, device); inputDataMap.Add(inputVar, inputVal); Classifier.Evaluate(inputDataMap, outputDataMap, device); var outputData = outputDataMap[Classifier.Output].GetDenseData <float>(Classifier.Output); return(outputData.Select(l => l.IndexOf(l.Max())).ToList()); }
// Create Value object from dense input as batch of sequences data. public static Value CreateBatchOfSequences <T>(NDShape sampleShape, System.Collections.Generic.IEnumerable <System.Collections.Generic.IEnumerable <T> > batchOfSequences, DeviceDescriptor device, bool readOnly = false) { return(Create(sampleShape, batchOfSequences, new System.Collections.Generic.List <bool>(0), device, readOnly)); }
public NDArrayView(NDShape viewShape, int[] colStarts, int[] rowIndices, double[] nonZeroValues, uint numNonZeroValues, DeviceDescriptor device, bool readOnly) : this(CNTKLibPINVOKE.new_NDArrayView__SWIG_20(NDShape.getCPtr(viewShape), colStarts, rowIndices, nonZeroValues, numNonZeroValues, DeviceDescriptor.getCPtr(device), readOnly), true) { if (CNTKLibPINVOKE.SWIGPendingException.Pending) { throw CNTKLibPINVOKE.SWIGPendingException.Retrieve(); } }
public NDArrayView(NDShape viewShape, double[] dataBuffer, uint numBufferElements, DeviceDescriptor device) : this(CNTKLibPINVOKE.new_NDArrayView__SWIG_17(NDShape.getCPtr(viewShape), dataBuffer, numBufferElements, DeviceDescriptor.getCPtr(device)), true) { if (CNTKLibPINVOKE.SWIGPendingException.Pending) { throw CNTKLibPINVOKE.SWIGPendingException.Retrieve(); } }
private CNTK.Function _reshape_dummy_dim(CNTK.Function x, params int[] axis) { // https://github.com/fchollet/keras/blob/f65a56fb65062c8d14d215c9f4b1015b97cc5bf3/keras/backend/cntk_backend.py#L680 List <int> shape = In(x.Output.Shape).ToList(); var _axis = axis.Select(i => i < 0 ? (i + shape.Count) : i).ToArray(); if (shape.Count(s => s == NDShape.InferredDimension) > 1) { var result = x; foreach (int index in _axis.Sorted().Reverse()) { result = C.Reshape(result, replacementShape: NDShape.CreateNDShape(new int[] { }), beginAxis: new Axis(index), endAxis: new Axis(index + 1)); } return(result); } else { foreach (int index in _axis.Sorted().Reverse()) { shape.RemoveAt(index); } return(C.Reshape(x, NDShape.CreateNDShape(shape))); } }
// Todo: move it to separate unit tests. public void NDArrayViewTest(DeviceDescriptor device) { Console.WriteLine("Test creating NDArrayView on devices."); var data = new float[10]; var shape = new NDShape(1, 10); var n1 = new NDArrayView(shape, data, device); var n1Clone = n1.DeepClone(device); var n1CloneCPU = n1.DeepClone(DeviceDescriptor.CPUDevice); Console.WriteLine("n1: on " + n1.Device.AsString() + ", Storage:" + n1.StorageFormat + ", Shape:" + n1.Shape.AsString()); Console.WriteLine("n1Clone: on " + n1Clone.Device.AsString() + ", Storage:" + n1Clone.StorageFormat + ", Shape:" + n1Clone.Shape.AsString()); Console.WriteLine("n1CloneCPU: on " + n1CloneCPU.Device.AsString() + ", Storage:" + n1CloneCPU.StorageFormat + ", Shape:" + n1CloneCPU.Shape.AsString()); int[] dimensions = { 4, 5 }; var shape2 = NDShape.CreateNDShape(dimensions); float[] nonZeroValues = { 1, 5, 4, 2, 3, 9, 7, 8, 6 }; int[] rowIndices = { 0, 2, 0, 1, 1, 3, 2, 2, 3 }; int[] colStarts = { 0, 2, 4, 6, 7, 9 }; var s1 = new NDArrayView(shape2, colStarts, rowIndices, nonZeroValues, device, true); var s1Clone = s1.DeepClone(device); var s1DenseCPU = new NDArrayView(DataType.Float, StorageFormat.Dense, shape2, DeviceDescriptor.CPUDevice); s1DenseCPU.CopyFrom(s1); Console.WriteLine("s1: on " + s1.Device.AsString() + ", Storage:" + s1.StorageFormat + ", Shape:" + s1.Shape.AsString()); Console.WriteLine("s1Clone: on " + s1Clone.Device.AsString() + ", Storage:" + s1Clone.StorageFormat + ", Shape:" + s1Clone.Shape.AsString()); Console.WriteLine("s1DenseCPU: on " + s1DenseCPU.Device.AsString() + ", Storage:" + s1DenseCPU.StorageFormat + ", Shape:" + s1DenseCPU.Shape.AsString()); }
/// <summary> /// create model by w,h,c,outputClassNum /// </summary> /// <param name="w"></param> /// <param name="h"></param> /// <param name="c"></param> /// <param name="outputClassNum"></param> /// <param name="deviceName"></param> public FCN7(int w, int h, int c, int outputClassNum, string deviceName) { device = NP.CNTKHelper.GetDeviceByName(deviceName); //input output variable int[] inputDim = new int[] { w, h, c }; int[] outputDim = new int[] { outputClassNum }; inputVariable = Variable.InputVariable(NDShape.CreateNDShape(inputDim), DataType.Float, "inputVariable"); outputVariable = Variable.InputVariable(NDShape.CreateNDShape(outputDim), DataType.Float, "labelVariable"); //build model classifierOutput = CreateFullyChannelNetwork(inputVariable, c, outputClassNum); Function loss = CNTKLib.SquaredError(classifierOutput, outputVariable); Function pred = CNTKLib.ClassificationError(classifierOutput, outputVariable); //adam leaner ParameterVector parameterVector = new ParameterVector(classifierOutput.Parameters().ToList()); TrainingParameterScheduleDouble learningRateSchedule = new TrainingParameterScheduleDouble(0.00178125, BatchSize); TrainingParameterScheduleDouble momentumRateSchedule = new TrainingParameterScheduleDouble(0.9, BatchSize); Learner leaner = CNTKLib.AdamLearner(parameterVector, learningRateSchedule, momentumRateSchedule, true); //构造leaner方法 trainer = Trainer.CreateTrainer(classifierOutput, loss, pred, new List <Learner>() { leaner }); //TrainingParameterScheduleDouble learningRatePerSample = new TrainingParameterScheduleDouble(0.00178125, BatchSize); //0.00178125 //TrainingParameterScheduleDouble momentumTimeConstant = CNTKLib.MomentumAsTimeConstantSchedule(256); //IList<Learner> parameterLearners = new List<Learner>() { Learner.MomentumSGDLearner(classifierOutput.Parameters(), learningRatePerSample, momentumTimeConstant, true) }; //trainer = Trainer.CreateTrainer(classifierOutput, loss, pred, parameterLearners); }
// Create Value object from dense input as sequence data. public static Value CreateSequence <T>(NDShape sampleShape, System.Collections.Generic.IEnumerable <T> sequence, DeviceDescriptor device, bool readOnly = false) { return(CreateSequence <T>(sampleShape, sequence, true, device, readOnly)); }
public Tensor categorical_crossentropy(Tensor target, Tensor output, bool from_logits = false) { // https://github.com/fchollet/keras/blob/f65a56fb65062c8d14d215c9f4b1015b97cc5bf3/keras/backend/cntk_backend.py#L1480 var _output = In(output); var _target = In(target); if (from_logits) { var result = C.CrossEntropyWithSoftmax(_output, _target); // cntk's result shape is (batch, 1), while keras expect (batch, ) CNTK.Function r = C.Reshape(result, NDShape.CreateNDShape(new int[] { })); return(Out(r)); } else { // scale preds so that the class probas of each sample sum to 1 var o = C.ElementDivide(_output.function, C.ReduceSum(_output, Axis.EndStaticAxis())); var eps = Constant.Scalar(epsilon(), DeviceDescriptor.CPUDevice); var omeps = Constant.Scalar(1.0 - epsilon(), DeviceDescriptor.CPUDevice); // avoid numerical instability with _EPSILON clipping o = C.Clip(o, eps, omeps); CNTK.Function r = C.Negate(C.ReduceSum(C.ElementTimes(_target, C.Log(_output)), Axis.EndStaticAxis())); return(Out(r)); } }
public NDArrayView(NDShape viewShape, int[] colStarts, int[] rowIndices, SWIGTYPE_p_int16_t nonZeroValues, uint numNonZeroValues, DeviceDescriptor device) : this(CNTKLibPINVOKE.new_NDArrayView__SWIG_25(NDShape.getCPtr(viewShape), colStarts, rowIndices, SWIGTYPE_p_int16_t.getCPtr(nonZeroValues), numNonZeroValues, DeviceDescriptor.getCPtr(device)), true) { if (CNTKLibPINVOKE.SWIGPendingException.Pending) { throw CNTKLibPINVOKE.SWIGPendingException.Retrieve(); } }
public NDMask(NDShape shape, DeviceDescriptor device) : this(CNTKLibPINVOKE.new_NDMask__SWIG_0(NDShape.getCPtr(shape), DeviceDescriptor.getCPtr(device)), true) { if (CNTKLibPINVOKE.SWIGPendingException.Pending) { throw CNTKLibPINVOKE.SWIGPendingException.Retrieve(); } }
/// <summary> /// The example shows /// - how to load model from a memory buffer. /// </summary> /// <param name="device">Specify on which device to run the evaluation.</param> public static void LoadModelFromMemory(DeviceDescriptor device) { try { Console.WriteLine("\n===== Load model from memory buffer ====="); // For demo purpose, we first read the the model into memory // The model resnet20.dnn is trained by <CNTK>/Examples/Image/Classification/ResNet/Python/TrainResNet_CIFAR10.py // Please see README.md in <CNTK>/Examples/Image/Classification/ResNet about how to train the model. string modelFilePath = "resnet20.dnn"; ThrowIfFileNotExist(modelFilePath, string.Format("Error: The model '{0}' does not exist. Please follow instructions in README.md in <CNTK>/Examples/Image/Classification/ResNet to create the model.", modelFilePath)); var modelBuffer = File.ReadAllBytes(modelFilePath); // Load model from memroy buffer Function modelFunc = Function.Load(modelBuffer, device); // Get shape data for the input variable Variable inputVar = modelFunc.Arguments.Single(); NDShape inputShape = inputVar.Shape; int imageWidth = inputShape[0]; int imageHeight = inputShape[1]; // Image preprocessing to match input requirements of the model. // This program uses images from the CIFAR-10 dataset for evaluation. // Please see README.md in <CNTK>/Examples/Image/DataSets/CIFAR-10 about how to download the CIFAR-10 dataset. string sampleImage = "00000.png"; ThrowIfFileNotExist(sampleImage, string.Format("Error: The sample image '{0}' does not exist. Please see README.md in <CNTK>/Examples/Image/DataSets/CIFAR-10 about how to download the CIFAR-10 dataset.", sampleImage)); Bitmap bmp = new Bitmap(Bitmap.FromFile(sampleImage)); var resized = bmp.Resize(imageWidth, imageHeight, true); List <float> resizedCHW = resized.ParallelExtractCHW(); // Create input data map. var inputDataMap = new Dictionary <Variable, Value>(); var inputVal = Value.CreateBatch(inputVar.Shape, resizedCHW, device); inputDataMap.Add(inputVar, inputVal); // Get output variable. Variable outputVar = modelFunc.Output; // Create output data map. Using null as Value to indicate using system allocated memory. // Alternatively, create a Value object and add it to the data map. var outputDataMap = new Dictionary <Variable, Value>(); outputDataMap.Add(outputVar, null); // Start evaluation on the device. modelFunc.Evaluate(inputDataMap, outputDataMap, device); // Get evaluate result as dense output. var outputVal = outputDataMap[outputVar]; var outputData = outputVal.GetDenseData <float>(outputVar); PrintOutput(outputVar.Shape.TotalSize, outputData); } 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"); throw ex; } }
private void _MarkSequenceBegin(SizeTVector offset, NDShape sectionShape) { CNTKLibPINVOKE.NDMask__MarkSequenceBegin__SWIG_1(swigCPtr, SizeTVector.getCPtr(offset), NDShape.getCPtr(sectionShape)); if (CNTKLibPINVOKE.SWIGPendingException.Pending) { throw CNTKLibPINVOKE.SWIGPendingException.Retrieve(); } }
private void _InvalidateSection(SizeTVector sectionOffset, NDShape sectionShape) { CNTKLibPINVOKE.NDMask__InvalidateSection(swigCPtr, SizeTVector.getCPtr(sectionOffset), NDShape.getCPtr(sectionShape)); if (CNTKLibPINVOKE.SWIGPendingException.Pending) { throw CNTKLibPINVOKE.SWIGPendingException.Retrieve(); } }
Parameter Parameter(IEnumerable <int> dims) { return(new Parameter(NDShape.CreateNDShape(dims), DataType.Double, CNTKLib.GlorotUniformInitializer( // valeur par défaut aléatoire CNTKLib.DefaultParamInitScale, CNTKLib.SentinelValueForInferParamInitRank, CNTKLib.SentinelValueForInferParamInitRank, 1))); }
// Create Value object from NDArrayViews with sequenceStartFlags public static Value Create(NDShape sampleShape, System.Collections.Generic.IEnumerable <NDArrayView> sequences, System.Collections.Generic.IEnumerable <bool> sequenceStartFlags, DeviceDescriptor device, bool readOnly = false) { return(Create(sampleShape, sequences, sequenceStartFlags, device, readOnly, /*createNewCopy = */ false)); }
/// <summary> /// Based on Dense from: https://github.com/Microsoft/CNTK/blob/master/bindings/python/cntk/layers/layers.py /// </summary> public static Function Dense(this Function input, int units, CNTKDictionary weightInitializer, CNTKDictionary biasInitializer, DeviceDescriptor device, DataType dataType, int inputRank = 0, int mapRank = 0) { if (inputRank != 0 && mapRank != 0) { throw new ArgumentException("Dense: inputRank and mapRank cannot be specified at the same time."); } var outputShape = NDShape.CreateNDShape(new int[] { units }); var outputRank = outputShape.Dimensions.Count; var inputRanks = (inputRank != 0) ? inputRank : 1; var dimensions = Enumerable.Range(0, inputRanks) .Select(v => NDShape.InferredDimension).ToArray(); // infer all dimensions. var inputShape = NDShape.CreateNDShape(dimensions); int inferInputRankToMap; if (inputRank != 0) { inferInputRankToMap = -1; // means map_rank is not specified; input_rank rules. } else if (mapRank == 0) { inferInputRankToMap = 0; // neither given: default to 'infer W to use all input dims'. } else { inferInputRankToMap = mapRank; // infer W to use all input dims except the first static 'map_rank' ones. } var weightsDimensions = outputShape.Dimensions.ToList(); weightsDimensions.AddRange(inputShape.Dimensions); var weightsShape = NDShape.CreateNDShape(weightsDimensions); var weights = new Parameter(weightsShape, dataType, weightInitializer, device, "w"); // Weights and input is in reversed order compared to the original python code. // Same goes for the dimensions. This is because the python api reverses the dimensions internally. // The python API was made in this way to be similar to other deep learning toolkits. // The C# and the C++ share the same column major layout. var r = CNTKLib.Times(weights, input, (uint)outputRank, inferInputRankToMap); if (biasInitializer != null) { var biasParameter = new Parameter(outputShape, dataType, biasInitializer, device, "b"); r = r + biasParameter; } return(r); }
public void cntk_partial_shape_test() { // Note: Keras/TensorFlow represent unknown dimensions // as None, whereas TensorFlowSharp represents as -1: /* * import keras * * from keras.models import Sequential * from keras.layers import Dense * from keras import backend as K * import numpy as np * * a = K.placeholder(shape = (None, 2)) * b = K.variable(np.matrix([[1, 2, 3], [4, 5, 6]])) * ab = K.dot(a, b) * * shape_a = K.int_shape(a) * shape_b = K.int_shape(b) * shape_ab = K.int_shape(ab) * * print(shape_a) * print(shape_b) * print(shape_ab) * * >>> Using TensorFlow backend. * (None, 2) * (2, 3) * (None, 3) */ using (var K = new CNTKBackend()) { Tensor a = K.placeholder(shape: new int?[] { null, 2 }); Tensor b = K.variable(array: new float[, ] { { 1, 2, 3 }, { 4, 5, 6 } }); var ab = K.dot(a, b); int?[] shape_a = K.int_shape(a); int?[] shape_b = K.int_shape(b); int?[] shape_ab = K.int_shape(ab); NDShape tf_shape_a = K.In(a).CNTK_Shape; NDShape tf_shape_b = K.In(b).CNTK_Shape; NDShape tf_shape_ab = K.In(ab).CNTK_Shape; AssertEx.AreEqual(new int?[] { null, 2 }, shape_a); AssertEx.AreEqual(new int?[] { 2, 3 }, shape_b); AssertEx.AreEqual(new int?[] { null, 3 }, shape_ab); Assert.AreEqual(NDShape.CreateNDShape(new[] { NDShape.FreeDimension, 2 }), tf_shape_a); Assert.AreEqual(NDShape.CreateNDShape(new[] { 2, 3 }), tf_shape_b); Assert.AreEqual(NDShape.CreateNDShape(new[] { NDShape.FreeDimension, 3 }), tf_shape_ab); } }
internal static Function Conv(this Function input, int[] filterShape, int filterCount, int[] filterStride, Padding padding, // TODO: Consider if padding should be decided pr. dimension. CNTKDictionary weightInitializer, CNTKDictionary biasInitializer, DeviceDescriptor device, DataType dataType) { var weights = new Parameter(NDShape.CreateNDShape(filterShape), dataType, weightInitializer, device); var strideShape = NDShape.CreateNDShape(filterStride); // Currently, only sharing=true is supported by CNTK. So these are hardcoded. // sharing dimensions follows stride dimensions. 1D, 2D, 3D, etc. var sharing = CntkUtilities.CreateFilledBoolVector(filterStride.Length, true); // Padding dimensions follows stride dimensions. 1D, 2D, 3D, etc. var usePadding = padding.ToBoolean(); var autoPadding = CntkUtilities.CreateFilledBoolVector(filterStride.Length, usePadding); // TODO: Consider if we want to surface the additional options for Convolution: // - dilation // - reductionRank // - groups // - maxTempMemSizeInSamples // Default for dilation seems to be a shape of size (1) with value 1 var dilation = NDShape.CreateNDShape(new[] { 1 }); // Following are defaults extrapolated from CNTK code var reductionRank = 1u; var groups = 1u; var maxTempMemSizeInSamples = 0u; var sequential = false; var result = CNTKLib.Convolution( weights, input, strideShape, sharing, autoPadding, dilation, reductionRank, groups, maxTempMemSizeInSamples, sequential); if (biasInitializer != null) { // Bias dimensions should be defined for filter dimensions. // For instance for 2D case: (1, 1, filterChannels). var biasShape = filterStride.Select(s => 1).ToList(); biasShape.Add(filterCount); var bias = new Parameter(NDShape.CreateNDShape(biasShape.ToArray()), dataType, biasInitializer, device); result = CNTKLib.Plus(result, bias); } return(result); }
public static Value SafeCreate(NDShape shape, float[] data, DeviceDescriptor device) { if (device == null) { device = DeviceDescriptor.UseDefaultDevice(); } return(new Value(new NDArrayView(shape, data, device, false)).DeepClone()); }