// get X/Y/Z private double getweight(double[, ,] XYZ, int index) { if (index < 0) { index = 0; } else if (index > 2) { index = 2; } double sum = 0; double mean = 0; float w = XYZ.GetLength(0); float h = XYZ.GetLength(1); for (int r = 0; r < w; r++) { for (int c = 0; c < h; c++) { sum += XYZ[r, c, index]; } } mean = sum / (w * h); return(mean); }
public double[, ,] RGB2XYZ(double[, ,] rgbstr) { int w = rgbstr.GetLength(0); int h = rgbstr.GetLength(1); double[, ,] xyzstr = new double[w, h, 3]; var ccm = new[, ] { { 0.5767309, 0.2973769, 0.0270343 }, { 0.1855540, 0.6273491, 0.0706872 }, { 0.1881852, 0.0752741, 0.9911085 } }; for (int i = 0; i < w; i++) { for (int j = 0; j < h; j++) { double[] rgb = new double[] { rgbstr[i, j, 0], rgbstr[i, j, 1], rgbstr[i, j, 2] }; double[] xyz = MultiplyVector(ccm, rgb); xyzstr[i, j, 0] = xyz[0]; xyzstr[i, j, 1] = xyz[1]; xyzstr[i, j, 2] = xyz[2]; } } return(xyzstr); }
/// <summary> /// Returns the input vector for the sample at position (x,y) /// </summary> public IEnumerable <double> GetInputs(int x, int y) { for (int i = 0; i < samples.GetLength(0); i++) { yield return(samples[i, x, y]); } }
private static double[,,] processImage(double[,,] arrayImage, Action <ColorCustom> pixelAction) { double[,,] res = (double[, , ])arrayImage.Clone(); int width = arrayImage.GetLength(2), height = arrayImage.GetLength(1); ColorCustom c = new ColorCustom(); for (int h = 0; h < height; h++) { for (int w = 0; w < width; w++) { c.r = res[0, h, w]; c.g = res[1, h, w]; c.b = res[2, h, w]; pixelAction(c); res[0, h, w] = c.r; res[1, h, w] = c.g; res[2, h, w] = c.b; } } return(res); }
// get average Y from input XYZ matrix public double getlv(double[, ,] XYZ) { double sum = 0; double mean = 0; float w = XYZ.GetLength(0); float h = XYZ.GetLength(1); List <double> pointLv = new List <double>(); double value = 0; for (int r = 0; r < w; r++) { for (int c = 0; c < h; c++) { value = XYZ[r, c, 1]; sum += XYZ[r, c, 1]; pointLv.Add(value); } } pointLv.Sort(); int index = (int)(w * h * 3 / 10.0); pointLv.RemoveRange(0, index); pointLv.RemoveRange(pointLv.Count - index, index); double sumAverage = pointLv.Average(); return(sumAverage); // mean = sum / (w * h); //return mean; }
public unsafe static Bitmap DoubleRgbToBitmap(double[,,] arrayImage) { int width = arrayImage.GetLength(2), height = arrayImage.GetLength(1); Bitmap res = new Bitmap(width, height); BitmapData bd = res.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb); try { byte *curpos; fixed(double *_arrImage = arrayImage) { double *_r = _arrImage, _g = _arrImage + width * height, _b = _arrImage + 2 * width * height; for (int h = 0; h < height; h++) { curpos = ((byte *)bd.Scan0) + h * bd.Stride; for (int w = 0; w < width; w++) { *(curpos++) = Limit(*_b); ++_b; *(curpos++) = Limit(*_g); ++_g; *(curpos++) = Limit(*_r); ++_r; } } } } finally { res.UnlockBits(bd); } return(res); }
/// <summary> /// Act Loop on Estimated Chip Data. /// </summary> /// <param name="this"></param> /// <param name="boxlsit">BoxList for compare with chip Est data</param> /// <param name="centerPoints"></param> /// <param name="loopAct"></param> /// <returns></returns> public static double[,,] Act_LoopChipPos( this double[,,] @this, List <System.Drawing.Rectangle> boxlsit, System.Drawing.Point[] centerPoints, Action <int, int, double, double, List <System.Drawing.Rectangle>, System.Drawing.Point[]> loopAct) { try { for (int j = 0; j < @this.GetLength(0); j++) // row { for (int i = 0; i < @this.GetLength(1); i++) // col { loopAct( j, i , @this[j, i, 0] , @this[j, i, 1] , boxlsit , centerPoints); } } return(@this); } catch { return(@this); } }
public override void GetError(double[,,] error_out, double[,,] diff, double[,,] inarray, double[,,] input) { int a = 0; int depth1 = input_size[0]; int height1 = input_size[1]; int width1 = input_size[2]; int depth2 = error_out.GetLength(0); int height2 = error_out.GetLength(1); int width2 = error_out.GetLength(2); for (int z1 = 0; z1 < depth1; z1++) { for (int y1 = 0; y1 < height1; y1++) { for (int x1 = 0; x1 < width1; x1++) { double val = 0; for (int z2 = 0; z2 < depth2; z2++) { for (int y2 = 0; y2 < height2; y2++) { for (int x2 = 0; x2 < width2; x2++) { val += weights[z2, y2, x2, z1, y1, x1] * error_out[z2, y2, x2]; } } } input[z1, y1, x1] = val * diff[z1, y1, x1]; } } } }
/*public static void SaveHDR(float[, ,] hdr, string path) * { * FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write); * BinaryWriter bw = new BinaryWriter(fs); * * int width = hdr.GetLength(0); * int height = hdr.GetLength(1); * int depth = hdr.GetLength(2); * * bw.Write(width); * bw.Write(height); * bw.Write(depth); * * for (int x = 0; x < width; x++) * for (int y = 0; y < height; y++) * for (int z = 0; z < depth; z++) * bw.Write(hdr[x, y, z]); * * bw.Close(); * } * public static float[, ,] LoadHDR(string path) * { * FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read); * BinaryReader br = new BinaryReader(fs); * * int width = br.ReadInt32(); * int height = br.ReadInt32(); * int depth = br.ReadInt32(); * * float[, ,] hdr = new float[width, height, depth]; * * for (int x = 0; x < width; x++) * for (int y = 0; y < height; y++) * for (int z = 0; z < depth; z++) * hdr[x, y, z] = br.ReadSingle(); * * br.Close(); * }*/ public static void ToFile(double[, ,] hdr, string path) { FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write); BinaryWriter bw = new BinaryWriter(fs); int width = hdr.GetLength(0); int height = hdr.GetLength(1); int depth = hdr.GetLength(2); bw.Write(width); bw.Write(height); bw.Write(depth); for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { for (int z = 0; z < depth; z++) { bw.Write(hdr[x, y, z]); } } } bw.Close(); }
public double GetError(double[,,] input, double[,,] t) { double[,,] output = GetOutput(input); int depth2 = output.GetLength(0); int height2 = output.GetLength(1); int width2 = output.GetLength(2); double val = 0; double temp = 0; for (int z2 = 0; z2 < depth2; z2++) { for (int y2 = 0; y2 < height2; y2++) { for (int x2 = 0; x2 < width2; x2++) { temp = output[z2, y2, x2] - t[z2, y2, x2]; val += temp * temp; } } } return(val); }
public double[] FlatternLayer(double[,,] input) { int rgbChannel = input.GetLength(0); int rowPixel = input.GetLength(1); int columnPixel = input.GetLength(2); int length = rgbChannel * rowPixel * columnPixel; double[] output = new double[length]; try { int count = 0; for (int i = 0; i < rgbChannel; i++) { for (int j = 0; j < rowPixel; j++) { for (int k = 0; k < columnPixel; k++) { output[count] = input[i, j, k]; count = count + 1; } } } } catch (Exception ex) { } return(output); }
// METODO per il salvataggio su csv public void saveData(double[,,] toSaveData, double[,,] toSaveQuaternioni, string ID) { using (sw_Save = File.AppendText(FILEPATHSAVE)) { int length = (toSaveData.GetLength(1) == 500) ? toSaveData.GetLength(1) / 2 : toSaveData.GetLength(1); //Scorro i campionamenti e salvo su csv for (int k = 0; k < length; k++) { for (int j = 0; j < numSensori; j++) { for (int i = 0; i < toSaveData.GetLength(0); i++) { sw_Save.Write(toSaveData[i, k, j] + ";"); } for (int i = 0; i < toSaveQuaternioni.GetLength(0); i++) { sw_Save.Write(toSaveQuaternioni[i, k, j] + ";"); } sw_Save.Write(";"); } sw_Save.Write("\r"); } } mainForm.displayText("[" + ID + "] Il file PinApp_save_xSimulator.csv è stato aggiornato.\r\r"); Console.Beep(); }
/// <summary> /// Производит повышение разрешения данных /// </summary> /// <param name="init">Исходные данные</param> /// <returns>Данные с повышенным разрешением</returns> public double[,,] UpSample(double[,,] init) { var res = new double[MaxPositions.GetLength(0), MaxPositions.GetLength(1), MaxPositions.GetLength(2)]; for (int l = 0; l < init.GetLength(0); l++) { for (int i = 0; i < init.GetLength(1); i++) { for (int j = 0; j < init.GetLength(2); j++) { // начинает пулинг for (int poolL = 0; poolL < HowLayers; poolL++) { for (int poolI = 0; poolI < PoolSize; poolI++) { for (int poolJ = 0; poolJ < PoolSize; poolJ++) { res[l * HowLayers + poolL, i *PoolSize + poolI, j *PoolSize + poolJ] = MaxPositions[l * HowLayers + poolL, i *PoolSize + poolI, j *PoolSize + poolJ] * init[l, i, j]; } } } } } } return(res); }
public static double[][,] ToArray2d(this double[,,] coordinateSets) { var length0 = coordinateSets.GetLength(0); var length1 = coordinateSets.GetLength(1); var length2 = coordinateSets.GetLength(2); var result = new double[length0][, ]; for (int i = 0; i < length0; i++) { var a = new double[length1, length2]; for (int j = 0; j < length1; j++) { for (int k = 0; k < length2; k++) { a[j, k] = coordinateSets[i, j, k]; } } result[i] = a; } return(result); }
private void Totalpckxg(int numClusters, int fernsNumber, double[,] fernpcknumber, int[,] _r1, double[, ,] totalpck_xg, double[] mmm, out double[,] pck_xgtotal) { pck_xgtotal = new double[pck_xg.GetLength(0), pck_xg.GetLength(1)]; double[] nu = new double[numClusters]; double sum = mmm.Sum(); for (int j = 0; j < totalpck_xg.GetLength(1); j++) { for (int k = 0; k < totalpck_xg.GetLength(2); k++) { for (int i = 0; i < fernsNumber; i++) { pck_xgtotal[j, k] += (mmm[i] / sum) * totalpck_xg[i, j, _r1[i, k]]; nu[k] += fernpcknumber[i, _r1[i, k]]; } if (nu[k] == 0) { pck_xgtotal[j, k] = 0; } else { pck_xgtotal[j, k] = pck_xgtotal[j, k] / nu[k]; } } } }
public static double[,] Flatten(double[,,] input) { int inputRows = input.GetLength(0); int inputColumns = input.GetLength(1); int inputDepth = input.GetLength(2); int flattenLength = inputRows * inputColumns * inputDepth; double[,] result = new double[1, flattenLength]; int resultColumn = 0; for (int c = 0; c < inputDepth; c++) { for (int i = 0; i < inputRows; i++) { for (int j = 0; j < inputColumns; j++) { result[0, resultColumn] = input[i, j, c]; resultColumn++; } } } return(result); }
public static double[,,] PointWiseConv(double[,,] input, double[,,,] kernels) { int inputRows = input.GetLength(0); int inputColumns = input.GetLength(1); int inputDepth = input.GetLength(2); int kernelDepth = kernels.GetLength(3); double[,,] result = new double[inputRows, inputColumns, kernelDepth]; for (int kernel = 0; kernel < kernelDepth; kernel++) { for (int i = 0; i < inputRows; i++) { for (int j = 0; j < inputColumns; j++) { double convResult = 0d; for (int channel = i; channel < inputDepth; channel++) { convResult += input[i, j, channel] * kernels[0, 0, channel, kernel]; } result[i, j, kernel] = Mathf.Clamp((float)convResult, float.MinValue, float.MaxValue); } } } return(result); }
public static void Save(double[, ,] qTable) { // Verify the directory exists if (!Directory.Exists(EXPORT_DIRECTORY)) { Directory.CreateDirectory(EXPORT_DIRECTORY); } // Save a CSV file for each direction foreach (Direction direction in Enum.GetValues(typeof(Direction))) { if (direction != Direction.NONE) { using (StreamWriter file = new StreamWriter(EXPORT_DIRECTORY + @"\" + direction.ToString() + ".csv")) { for (int rowIndex = 0; rowIndex < qTable.GetLength(0); rowIndex++) { for (int columnIndex = 0; columnIndex < qTable.GetLength(1); columnIndex++) { file.Write(qTable[rowIndex, columnIndex, (int)direction]); if (columnIndex == qTable.GetLength(1) - 1) { file.WriteLine(); } else { file.Write(","); } } } } } } }
private static async Task UpdateH ( double[,,] Hx, double[,,] Hy, double[,,] Hz, double[,,] Ex, double[,,] Ey, double[,,] Ez, double tx, double ty, double tz, double[,,] AH ) { var Lx = Hx.GetLength(0); var Ly = Hx.GetLength(1); var Lz = Hx.GetLength(2); var tHx = Task.Factory.StartNew(() => { for (var i = 0; i < Lx; i++) { for (var j = 0; j < Ly - 1; j++) { for (var k = 0; k < Lz - 1; k++) { Hx[i, j, k] -= ((Ez[i, j + 1, k] - Ez[i, j, k]) / ty - (Ey[i, j, k + 1] - Ey[i, j, k]) / tz) * AH[i, j, k]; } } } }); var tHy = Task.Factory.StartNew(() => { for (var i = 0; i < Lx - 1; i++) { for (var j = 0; j < Ly; j++) { for (var k = 0; k < Lz - 1; k++) { Hy[i, j, k] -= ((Ex[i, j, k + 1] - Ex[i, j, k]) / tz - (Ez[i + 1, j, k] - Ez[i, j, k]) / tx) * AH[i, j, k]; } } } }); var tHz = Task.Factory.StartNew(() => { for (var i = 0; i < Lx - 1; i++) { for (var j = 0; j < Ly - 1; j++) { for (var k = 0; k < Lz; k++) { Hz[i, j, k] -= ((Ey[i + 1, j, k] - Ey[i, j, k]) / tx - (Ex[i, j + 1, k] - Ex[i, j, k]) / ty) * AH[i, j, k]; } } } }); await Task.WhenAll(tHx, tHy, tHz).ConfigureAwait(false); }
double[][,,] GetBackwardErrors(double[,,] input, double[,,] t, out double err, out List <KeyValuePair <double[, , ], double[, , ]> > getOutput) { double[][,,] errors = new double[layers.Count][, , ]; var out_pairs = GetOutAndDiff(input); double[,,] output = out_pairs.Last().Key; //Console.WriteLine("{0} {1}", (float)output[0, 0, 0], (float)output[0, 0, 1]); int depth2 = output.GetLength(0); int height2 = output.GetLength(1); int width2 = output.GetLength(2); double val = 0; double temp = 0; double[,,] out_err = (double[, , ])t.Clone(); double[,,] diff = out_pairs.Last().Value; for (int z2 = 0; z2 < depth2; z2++) { for (int y2 = 0; y2 < height2; y2++) { for (int x2 = 0; x2 < width2; x2++) { temp = t[z2, y2, x2] - output[z2, y2, x2]; out_err[z2, y2, x2] = -temp * diff[z2, y2, x2]; val += temp * temp; } } } errors[errors.Length - 1] = out_err; for (int i = layers.Count - 1; i >= 0; i--) { Layer prev = null; if (i != 0) { prev = layers[i - 1]; if (prev != null) { errors[i - 1] = layers[i].GetError(errors[i], out_pairs[i - 1].Value, out_pairs[i - 1].Key); } else { double[,,] diff2 = (double[, , ])input.Clone(); diff2.ForEach(x => 1); errors[i - 1] = layers[i].GetError(errors[i], diff2, input); } } } err = val; getOutput = out_pairs; return(errors); }
private static async Task UpdateE ( double[,,] Hx, double[,,] Hy, double[,,] Hz, double[,,] Ex, double[,,] Ey, double[,,] Ez, double tx, double ty, double tz, double[,,] AE ) { var Lx = Ex.GetLength(0); var Ly = Ex.GetLength(1); var Lz = Ex.GetLength(2); var tEx = Task.Factory.StartNew(() => { for (var i = 0; i < Lx - 1; i++) { for (var j = 1; j < Ly - 1; j++) { for (var k = 1; k < Lz - 1; k++) { Ex[i, j, k] = Ex[i, j, k] * AE[i, j, k] + ((Hz[i, j, k] - Hz[i, j - 1, k]) / ty - (Hy[i, j, k] - Hy[i, j, k - 1]) / tz); } } } }); var tEy = Task.Factory.StartNew(() => { for (var i = 1; i < Lx - 1; i++) { for (var j = 0; j < Ly - 1; j++) { for (var k = 1; k < Lz - 1; k++) { Ey[i, j, k] = Ey[i, j, k] * AE[i, j, k] + ((Hx[i, j, k] - Hx[i, j, k - 1]) / tz - (Hz[i, j, k] - Hz[i - 1, j, k]) / tx); } } } }); var tEz = Task.Factory.StartNew(() => { for (var i = 1; i < Lx - 1; i++) { for (var j = 1; j < Ly - 1; j++) { for (var k = 0; k < Lz - 1; k++) { Ez[i, j, k] = Ez[i, j, k] * AE[i, j, k] + ((Hy[i, j, k] - Hy[i - 1, j, k]) / tx - (Hx[i, j, k] - Hx[i, j - 1, k]) / ty); } } } }); await Task.WhenAll(tEx, tEy, tEz).ConfigureAwait(false); }
public static System.Drawing.Point[] GetMomnetList( this double[,,] @this) { return(Enumerable.Range(0, @this.GetLength(0)) .SelectMany(j => Enumerable.Range(0, @this.GetLength(1)) , (j, i) => new System.Drawing.Point(i, j)) .ToArray()); }
public frmPlotPSO(double[,,] PlotSwarmPsition, double[,] PlotGlobalPosition) { InitializeComponent(); plotSwarmPositions = (double[, , ])PlotSwarmPsition.Clone(); plotGlobalPositions = (double[, ])PlotGlobalPosition.Clone(); maxIter = plotSwarmPositions.GetLength(0); maxSwarm = plotSwarmPositions.GetLength(1); }
private static bool NoiseExists(Vector3 position) { bool xInBounds = position.x < noise.GetLength(0) - 1 && position.x >= 0; bool yInBounds = position.y < noise.GetLength(1) - 1 && position.y >= 0; bool zInBounds = position.z < noise.GetLength(2) - 1 && position.z >= 0; return(xInBounds && yInBounds && zInBounds); }
/// <summary> /// Blur bitmap with the Fastest Fourier Transform /// </summary> /// <returns>Blurred bitmap</returns> public double[,,] Blur(double[,,] imageData) { int length = imageData.Length; int n0 = imageData.GetLength(0); int n1 = imageData.GetLength(1); int n2 = imageData.GetLength(2); var doubles = new double[length]; Buffer.BlockCopy(imageData, 0, doubles, 0, length * sizeof(double)); double average; double delta; AverageAndDelta(out average, out delta, doubles, _keepOption); Complex[] complex = doubles.Select(x => new Complex(x, 0)).ToArray(); Fourier(n0, n1, n2, complex, FourierDirection.Forward); Complex level = complex[0]; Size filterSize = _filterSize; switch (_filterMode) { case FilterMode.FilterSize: break; case FilterMode.FilterStep: int filterStep = _filterStep; filterSize = new Size(MulDiv(n1, filterStep, filterStep + 1), MulDiv(n0, filterStep, filterStep + 1)); break; default: throw new NotImplementedException(); } BlindInner(n0, n1, complex, filterSize, n2); complex[0] = level; Fourier(n0, n1, n2, complex, FourierDirection.Backward); doubles = complex.Select(x => x.Magnitude).ToArray(); double average2; double delta2; AverageAndDelta(out average2, out delta2, doubles, _keepOption); // a*average2 + b == average // a*delta2 == delta double a = (_keepOption == KeepOption.AverageAndDelta) ? (delta / delta2) : (average / average2); double b = (_keepOption == KeepOption.AverageAndDelta) ? (average - a * average2) : 0; Debug.Assert(Math.Abs(a * average2 + b - average) < 0.1); doubles = doubles.Select(x => Math.Round(a * x + b)).ToArray(); Buffer.BlockCopy(doubles, 0, imageData, 0, length * sizeof(double)); return(imageData); }
public static double[,,] Flip(double[,,] input) { int w = input.GetLength(1); int h = input.GetLength(2); var output = new double[input.GetLength(0), w, h]; input.ForEach((q, k, i, j) => output[k, w - i - 1, h - j - 1] = q); return(output); }
public static double[] GetRank(this double[,,] D, int r1, int r2) { double[] r = new double[D.GetLength(2)]; if (D.GetLength(0) > r1 && D.GetLength(1) > r2) { Parallel.For(0, D.GetLength(2), j => r[j] = D[r1, r2, j]); } return(r); }
public static int[] get_shape(double[,,] input) { int[] res = new int[3]; res[0] = input.GetLength(0); res[1] = input.GetLength(1); res[2] = input.GetLength(2); Console.WriteLine("(" + res[0] + "," + res[1] + "," + res[2] + ")"); return(res); }
protected double[] GeneralCNN(double[,,] inputData) { int elementAmount = inputData.GetLength(0) * inputData.GetLength(1) * inputData.GetLength(2); int kernelListCounter = 0; double[,,] current = new double[0, 0, 0]; while (elementAmount < this.transitionElementAmount && kernelListCounter < convLayerKernels.Capacity) { //reassign elementAmount after convolution and pooling int kernelIndex = 0; int convLayerIndex = 0; this.convLayerNetwork.Add(inputData); current = convLayerNetwork[convLayerIndex];//first time while ((current.GetLength(0) * current.GetLength(1) * current.GetLength(2) < this.transitionElementAmount) && kernelIndex < convLayerKernels.Capacity) { double[,,] currentKernel = convLayerKernels[kernelIndex]; current = convLayerNetwork[convLayerIndex]; int[] currentKernelDimensions = new int[] { currentKernel.GetLength(0), currentKernel.GetLength(1), currentKernel.GetLength(2) }; this.convLayerNetwork.Add(REluOperation(MaxPoolingOperation(ConvolutionOperation(current, currentKernel), currentKernelDimensions))); } } //converting 3d tensor to 1d vector double[] transitionVector = new double[current.GetLength(0) * current.GetLength(1) * current.GetLength(2)]; double[,,] transitionTensor = convLayerNetwork[convLayerNetwork.Capacity - 1]; int transitionAccum = 0; for (int i = 0; i < convLayerNetwork[convLayerNetwork.Capacity - 1].GetLength(0); i++) { for (int j = 0; j < convLayerNetwork[convLayerNetwork.Capacity - 1].GetLength(1); j++) { for (int k = 0; k < convLayerNetwork[convLayerNetwork.Capacity - 1].GetLength(2); k++) { transitionVector[transitionAccum] = transitionTensor[i, j, k]; transitionAccum++; } } } double[] currentLayer = new double[0]; for (int i = 0; i < this.weights.Capacity; i++) { if (i == 0) { currentLayer = this.Add(SoftmaxOperation(MatrixVectorProduct(weights[i], transitionVector)), biases[i]); } else { currentLayer = this.Add(SoftmaxOperation(MatrixVectorProduct(weights[i], currentLayer)), biases[i]); } } return(currentLayer); }
public MapClusteringView(IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder, IMapClusteringDataset dataset, MapClusteringEvaluator evaluator, int nbClusters) : this() { this.dataset = dataset; this.nbClusters = nbClusters; this.decoder = genomeDecoder; this.evaluator = evaluator; samples = dataset.GetSamplesMatrix(); outputs = new double[nbClusters, samples.GetLength(1), samples.GetLength(2)]; inputView.LabelName = "Input"; outputView.LabelName = "Output"; inputView.SetDimensions(samples.GetLength(0), samples.GetLength(1), samples.GetLength(2)); outputView.SetDimensions(nbClusters, samples.GetLength(1), samples.GetLength(2)); maxValue = 0.0; minValue = double.PositiveInfinity; for (var i = 0; i < samples.GetLength(0); i++) { for (var j = 0; j < samples.GetLength(1); j++) { for (var k = 0; k < samples.GetLength(2); k++) { var value = samples[i, j, k]; if (value > maxValue) { maxValue = value; } if (value < minValue) { minValue = value; } } } } // Add some margin maxValue *= 2; minValue *= 2; inputView.OnClusterChanged += (id) => { currentInputIdx = id; RefreshInput(); }; outputView.OnClusterChanged += (id) => { currentClusterIdx = id; RefreshOutput(); }; RefreshInput(); }
public override void Initialize(string name, XmlElement xmlConfig) { base.Initialize(name, xmlConfig); _dataset = CreateDataset(); _dataset.LoadFromFile(DatasetFileName); samples = _dataset.GetSamplesMatrix(); nbInputs = _dataset.InputCount; n = samples.GetLength(1); m = samples.GetLength(2); }
public MapClusteringView(IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder, IMapClusteringDataset dataset, MapClusteringEvaluator evaluator, int nbClusters) : this() { this.dataset = dataset; this.nbClusters = nbClusters; this.decoder = genomeDecoder; this.evaluator = evaluator; samples = dataset.GetSamplesMatrix(); outputs = new double[nbClusters, samples.GetLength(1), samples.GetLength(2)]; inputView.LabelName = "Input"; outputView.LabelName = "Output"; inputView.SetDimensions(samples.GetLength(0), samples.GetLength(1), samples.GetLength(2)); outputView.SetDimensions(nbClusters, samples.GetLength(1), samples.GetLength(2)); maxValue = 0.0; minValue = double.PositiveInfinity; for (var i = 0; i < samples.GetLength(0); i++) { for (var j = 0; j < samples.GetLength(1); j++) { for (var k = 0; k < samples.GetLength(2); k++) { var value = samples[i, j, k]; if (value > maxValue) maxValue = value; if (value < minValue) minValue = value; } } } // Add some margin maxValue *= 2; minValue *= 2; inputView.OnClusterChanged += (id) => { currentInputIdx = id; RefreshInput(); }; outputView.OnClusterChanged += (id) => { currentClusterIdx = id; RefreshOutput(); }; RefreshInput(); }
/// <summary> /// Construct evaluator with the provided task arguments/variables. /// </summary> public MapClusteringEvaluator(IMapClusteringDataset dataset, int nbClusters, Phenotype phenotype) { this.nbClusters = nbClusters; this.phenotype = phenotype; // Build input layers (samples matrices) nbInputs = dataset.InputCount; samples = dataset.GetSamplesMatrix(); // Extract useful values n = samples.GetLength(1); // layers width m = samples.GetLength(2); // layers height nbInputsNN = samples.Length; nbOutputsNN = nbClusters * n * m; }
/// <summary> /// Construct evaluator with the provided task arguments/variables. /// </summary> public WindowMapClusteringEvaluator(IMapClusteringDataset dataset, int nbClusters, Phenotype phenotype, bool[,] filter) { this.nbClusters = nbClusters; this.phenotype = phenotype; this.filter = filter; Debug.Assert(filter.GetLength(0) % 2 != 0 && filter.GetLength(1) % 2 != 0); // Build input layers (samples matrices) nbInputs = dataset.InputCount; samples = dataset.GetSamplesMatrix(); // Extract useful values f = filter.GetLength(0); // filter width f2 = filter.Length; // f^2 t = (f - 1) / 2; // filter thickness nbInputsNN = nbInputs * f2; nbOutputsNN = nbClusters * f2; n = samples.GetLength(1); // layers width m = samples.GetLength(2); // layers height }
public void Initialize(IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder, IMapClusteringDataset dataset, MapClusteringEvaluator evaluator, int nbClusters) { this.dataset = dataset; this.nbClusters = nbClusters; this.decoder = genomeDecoder; this.evaluator = evaluator; samples = dataset.GetSamplesMatrix(); outputs = new double[nbClusters, samples.GetLength(1), samples.GetLength(2)]; this.nbInputs = samples.GetLength(0); maxValue = 0.0; for (var i = 0; i < samples.GetLength(0); i++) { for (var j = 0; j < samples.GetLength(1); j++) { for (var k = 0; k < samples.GetLength(2); k++) { var value = samples[i, j, k]; if (value > maxValue) maxValue = value; } } } maxValue *= 2; // margin }