public double[,,] FastFunc(double[,,] val) { double max = double.MinValue; val.ForEach(x => { max = Math.Max(max, x); }); val.ForEach(x => x / max); return(val); }
public double[,,] FastFunc(double[,,] val) { double sum = 0; val.ForEach(x => { sum += x * x; }); val.ForEach(x => x * x / sum); return(val); }
public void SyncDiff(double[,,] val, double[,,] result) { double max = double.MinValue; val.ForEach(x => { max = Math.Max(max, Math.Abs(x)); }); result.ForEach(val, (y, x) => x == max ? 0 : 1); }
private void button1_Click(object sender, EventArgs e) { if (listBox1.SelectedIndex != -1) { pretrain.SetupPretrain(listBox1.SelectedIndex); double[,,] res = pretrain.ProcessBackground(base_arr); double max = -1; res.ForEach((x) => { max = Math.Max(max, x); }); res.ForEach((x) => x / max); //pictureBox1.Image = ImageDataConverter.GetImage(res.ConvertToRGD()); RunPretrain(); timer1.Start(); } }
public override Value PassForward(Value value) { _featureMaps.ForEach((k, i, j) => _featureMaps[k, i, j] = _activator.CalculateValue(value.Multi[k, i, j])); return(new MultiValue(_featureMaps)); }
public double[,,] Func(double[,,] val) { double max = double.MinValue; val.ForEach(x => { max = Math.Max(max, Math.Abs(x)); }); return(val.NewEach(x => x / max)); }
public void RandomizeWeights(IWeightInitializer weightInitializer) { int inputs = Weights.GetLength(0) * Weights.GetLength(1) * Weights.GetLength(2); double magnitude = Math.Sqrt((double)1 / inputs); Weights.ForEach((i, j, k) => Weights[i, j, k] = weightInitializer.GenerateRandom(magnitude)); }
public double[,,] Diff(double[,,] val) { double max = double.MinValue; val.ForEach(x => { max = Math.Max(max, Math.Abs(x)); }); return(val.NewEach(x => x == max ? 0 : 1)); }
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); }
public void SyncDiff(double[,,] val, double[,,] result) { double sum = 0; val.ForEach(x => { sum += x * x; }); sum += c; result.ForEach(x => x * (1 - x / sum) / sum); }
private void timer1_Tick(object sender, EventArgs e) { if (pretrain_task != null) { if (pretrain_task.IsCompleted) { pretrain.UpdateWeights(ref NetworkData.network); label1.Text = "Error: " + (float)pretrain_task.Result; double[,,] res = pretrain.ProcessAutoEncoder(base_arr); ContinuePretrain(); double max = -1; res.ForEach((x) => { max = Math.Max(max, x); }); res.ForEach((x) => x / max); //pictureBox2.Image = ImageDataConverter.GetImage(res.ConvertToRGD()); } } }
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 override KeyValuePair <double, double[, , ]> WriteG(int pos, double[,,] input, double[,,] t, double k) { List <IOPair> pairs; double err; double[][,,] errors = GetBackwardErrors(input, t, out err, out pairs); layers[0].WriteG(pos, errors[0], input, k); for (int i = 1; i < layers.Count; i++) { layers[i].WriteG(pos, errors[i], pairs[i - 1].Key, k); } int depth = memory_layer.output_size[0]; int height = memory_layer.output_size[1]; int width = memory_layer.output_size[2]; #region асчет ошибки для входа double[,,] diff = doubleArrayExtensions.CreateArray(layers[0].input_size); diff.ForEach((val) => 1); var true_diff = memory_layer.GetOutputAndDiff(cached_last_layer).Value; for (int z = 0; z < depth; z++) { int z2 = z + z_offset; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { diff[z2, y, x] = true_diff[z, y, x]; } } } var error = layers[0].CreateInpuut(); layers[0].GetError(errors[0], diff, input, error); #endregion #region Запись градиента для рекурсивного слоя double[,,] new_err = doubleArrayExtensions.CreateArray(memory_layer.output_size); for (int z = 0; z < depth; z++) { int z2 = z + z_offset; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { new_err[z, y, x] = error[z2, y, x]; } } } memory_layer.WriteG(pos, new_err, cached_last_layer, k); #endregion return(new KeyValuePair <double, double[, , ]>(Math.Sqrt(err / t.Length), pairs.Last().Key)); }
public double[,,] Func(double[,,] val) { double sum = 0; val.ForEach(x => { sum += x * x; }); sum += c; double[,,] result = (double[, , ])val.Clone(); result.ForEach(x => x * x / sum); return(result); }
KeyValuePair <double, double[, , ]> SetBackwardErrors(double[,,] input, double[,,] t) { double[,,] output = GetOutput(input); //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 = errors.Last(); double[,,] diff = layers.Last().GetCachedDiff(); 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.Count - 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], prev.GetCachedDiff(), prev.GetCachedOutpur()); } else { double[,,] diff2 = (double[, , ])input.Clone(); diff2.ForEach(x => 1); errors[i - 1] = layers[i].GetError(errors[i], diff2, input); } } } return(new KeyValuePair <double, double[, , ]>(val, output)); }
public static double[,,] Pad(double[,,] input, int padding) { int d = input.GetLength(0); int w = input.GetLength(1) + padding * 2; int h = input.GetLength(2) + padding * 2; var output = new double[d, w, h]; input.ForEach((q, k, i, j) => output[k, i + padding, j + padding] = q); return(output); }
public KeyValuePair <double, double> GetErrorPair(double[,,] input, double[,,] t) { double[,,] output = GetOutput(input); int depth2 = output.GetLength(0); int height2 = output.GetLength(1); int width2 = output.GetLength(2); double err = 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]; err += temp * temp; } } } double max = -1; int max_arg = -1; t.ForEach((val, z, y, x) => { if (val > max) { max_arg = x; max = val; } }); max = -1; int max_arg2 = -2; output.ForEach((val, z, y, x) => { if (val > max) { max_arg2 = x; max = val; } }); return(new KeyValuePair <double, double>(err, max_arg == max_arg2 ? 1 : 0)); }
public override void GetError(double[,,] error_out, double[,,] diff, double[,,] indata, double[,,] input) { int dh = input.GetLength(1) - height_in + 1; int dw = input.GetLength(2) - width_in + 1; input.ForEach((x) => 0); double val = 0; for (int c1 = 0; c1 < ch_out; c1++) { for (int c2 = 0; c2 < ch_in; c2++) { for (int y0 = 0; y0 < dh; y0++) { for (int x0 = 0; x0 < dw; x0++) { for (int y1 = 0; y1 < height_out; y1++) { for (int x1 = 0; x1 < width_out; x1++) { for (int y2 = 0; y2 < height_in; y2++) { for (int x2 = 0; x2 < width_in; x2++) { input[c2, y0 + y2, x0 + x2] += weights[c1, y1, x1, c2, y2, x2] * error_out[c1, y0 + y1, x0 + x1]; } } } } } } } } for (int c = 0; c < ch_in; c++) { for (int y = 0; y < input_size[1]; y++) { for (int x = 0; x < input_size[2]; x++) { input[c, y, x] *= diff[c, y, x]; } } } }
public override void GetError(double[,,] error_out, double[,,] diff, double[,,] indata, double[,,] input) { int depth = input_size[0]; int height2 = input_size[1]; int width2 = input_size[2]; int dh = height2 - height + 1; int dw = width2 - width + 1; input.ForEach((x) => 0); for (int c = 0; c < count; c++) { for (int y0 = 0; y0 < dh; y0++) { for (int x0 = 0; x0 < dw; x0++) { double val = 0; for (int ch = 0; ch < depth; ch++) { for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { input[ch, y0 + y, x0 + x] += weights[c, ch, y, x] * error_out[c, y0, x0]; } } } } } } for (int z = 0; z < depth; z++) { for (int y = 0; y < height2; y++) { for (int x = 0; x < width2; x++) { input[z, y, x] *= diff[z, y, x]; } } } }
public SingleValue ToSingle() { if (Multi.Length == 0) { throw new Exception(Consts.CanNotConvertMultiValueToSingleValue); } double[] output = new double[Multi.Length]; Multi.ForEach((i, j, k) => { int depth = Multi.GetLength(0); int width = Multi.GetLength(1); int height = Multi.GetLength(2); output[i * width * height + j * width + k] = Multi[i, j, k]; }); return(new SingleValue(output)); }
public override void GetOutputAndDiff(double[,,] input, double[,,] output, double[,,] diff) { int dh = input.GetLength(1) - height_in + 1; int dw = input.GetLength(2) - width_in + 1; output.ForEach((x) => 0); double val = 0; for (int c1 = 0; c1 < ch_out; c1++) { for (int c2 = 0; c2 < ch_in; c2++) { for (int y0 = 0; y0 < dh; y0++) { for (int x0 = 0; x0 < dw; x0++) { for (int y1 = 0; y1 < height_out; y1++) { for (int x1 = 0; x1 < width_out; x1++) { val = 0; for (int y2 = 0; y2 < height_in; y2++) { for (int x2 = 0; x2 < width_in; x2++) { val += weights[c1, y1, x1, c2, y2, x2] * input[c2, y0 + y2, x0 + x2]; } } output[c1, y0 + y1, x0 + x1] += val; } } } } } } func.SyncDiff(output, diff); func.FastFunc(output); }
/// <summary> /// Возражаешь координаты положения максимального числа в массиве /// </summary> /// <param name="array"></param> /// <param name="c"></param> /// <param name="y"></param> /// <param name="x"></param> public static void ArgMax(this double[,,] array, out int c_res, out int y_res, out int x_res) { double max = double.MinValue; int max_arg_x = -1; int max_arg_y = -1; int max_arg_c = -1; array.ForEach((val, c, y, x) => { if (val > max) { max_arg_x = x; max_arg_y = y; max_arg_c = c; max = val; } }); c_res = max_arg_c; y_res = max_arg_y; x_res = max_arg_x; }
/// <summary> /// Возращает ошибку с процентами угаданных максимумов /// </summary> /// <param name="input"></param> /// <param name="t"></param> /// <returns></returns> public virtual KeyValuePair <double, double> GetErrorPair(double[,,] input, double[,,] t) { double[,,] output = GetOutput(input); int depth2 = output.GetLength(0); int height2 = output.GetLength(1); int width2 = output.GetLength(2); var loss_err = loss.Metric(output, t); double max = -1; int max_arg = -1; t.ForEach((val, z, y, x) => { if (val > max) { max_arg = x; max = val; } }); max = -1; int max_arg2 = -2; output.ForEach((val, z, y, x) => { if (val > max) { max_arg2 = x; max = val; } }); return(new KeyValuePair <double, double>(loss_err, max_arg == max_arg2 ? 1 : 0)); }
protected virtual double[][,,] GetBackwardErrors(double[,,] input, double[,,] t, out double err, int pos) { GetOutAndDiff(input, pos); double[,,] output = cached_outputs[pos].Last(); //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[,,] out_err = (double[, , ])t.Clone(); loss.Error(output, t, out_err); double[,,] diff = cached_diffs[pos].Last(); #region асчет ошибки конечного слоя for (int z2 = 0; z2 < depth2; z2++) { for (int y2 = 0; y2 < height2; y2++) { for (int x2 = 0; x2 < width2; x2++) { out_err[z2, y2, x2] *= -diff[z2, y2, x2]; } } } #endregion #region Обратное распостронение ошибки cached_errors[pos][cached_errors[pos].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) { layers[i].GetError(cached_errors[pos][i], cached_diffs[pos][i - 1], cached_outputs[pos][i - 1], cached_errors[pos][i - 1]); //cached_errors[pos][i - 1].MaxNorm(); } else { double[,,] diff2 = (double[, , ])input.Clone(); diff2.ForEach(x => 1); layers[i].GetError(errors[i], diff2, input, cached_errors[pos][i - 1]); //cached_errors[pos][i - 1].MaxNorm(); } } } #endregion err = loss.Metric(output, t); return(cached_errors[pos]); }
public override void ClearBuffers() { cached_last_layer.ForEach((val) => 0); cached_output.ForEach((val) => 0); }
public void SyncDiff(double[,,] val, double[,,] result) { result.ForEach((x) => 1); }
public void SyncDiff(double[,,] val, double[,,] result) { result.ForEach(val, (y, x) => x >= 0 ? 1 : 0); }
public double[,,] FastFunc(double[,,] val) { val.ForEach(x => x > 0 ? x : 0); return(val); }
public void UpdateWeights() { Gradient.ForEach((q, i, j, k) => Weights[i, j, k] += _learningRateAnnealers[i, j, k].Compute(q)); }
public void Error(double[,,] prediction, double[,,] output, double[,,] result) { output.ArgMax(out int cout, out int yout, out int xout); result.ForEach((v) => - 1); result[cout, yout, xout] = 1; }