//-------------------------------------------------------------------------------------- public mat Calculate_Matrix(mat mat1, char calc, double rowOrcolumn) { switch (calc) { case 'o': return(Ones(mat1)); case 'z': return(Zeros(mat1)); case 's': return(Multple_single(mat1, rowOrcolumn)); case 'r': return(cutting_row(mat1, 1, (mat1.n) - 1, (int)rowOrcolumn)); case 'c': return(cutting_column(mat1, 1, mat1.m, (int)rowOrcolumn)); case 't': return(Transpose(mat1)); case 'd': return(randumming(mat1)); default: return(mat1); } }
public mat cutting_column(mat mat1, int n, int m) { mat temp; int[] array = new int[n]; for (int i = 0; i < n; i++) { Console.WriteLine("Enter number of column "); array[i] = Convert.ToInt32(Console.ReadLine()); } temp = new mat(m + 1, n); int u = -1; for (int j = 0; j < temp.n; j++) { u++; n = array[u]; for (int i = 0; i < temp.m; i++) { temp.matrex1[i, j] = mat1.matrex1[i, n]; } } return(temp); }
//------------------------------------------------------------------------------------------------ public void order(mat pic) { input = rescaling(pic); forword(); backword(); }
//--------------------------------------------------------------------------------------------------- public mat rescaling(mat input) { double max = input.matrex1[0, 0], min = input.matrex1[0, 0]; // max for (int i = 0; i < input.m; i++) { if (input.matrex1[i, 0] > max) { max = input.matrex1[i, 0]; } } for (int i = 0; i < input.m - 1; i++) // min { if (input.matrex1[i, 0] < min) { min = input.matrex1[i, 0]; } } for (int i = 0; i < input_num; i++) // normalization [0,1] { double sub = (input.matrex1[i, 0]) - min; input.matrex1[i, 0] = (sub / (max - min)); } input.matrex1[input_num - 1, 0] = 1; return(input); }
//--------------------------------------------------------------------------------------------------------------------- public mat erroring(mat d, mat o) { mat e = new mat(output.m, output.n); e = matrixProcess.Calculate_Matrix(o, d, '-'); return(e); }
public mat Zeros(mat mat1) { for (int i = 0; i < mat1.m; i++) { for (int j = 0; j < mat1.n; j++) { mat1.matrex1[i, j] = 0; } } return(mat1); }
public mat hidd(mat mat) { mat m = new mat(mat.m + 1, 1); for (int i = 0; i < mat.m; i++) { m.matrex1[i, 0] = mat.matrex1[i, 0]; } m.matrex1[mat.m, 0] = 1; return(m); }
//--------------------------------------------------------------------------------------------------------------------- public double total_error(mat e) { double tot = 0; for (int j = 0; j < e.m; j++) { tot += Math.Pow(e.matrex1[j, 0], 2); //tot += (-1*desire.matrex1[j,0]*Math.Log(output.matrex1[j,0]) - (1-desire.matrex1[j,0])*Math.Log(1-output.matrex1[j,0])); } return(tot / 2); }
public mat Multple_array(mat mat1, mat mat2) { mat temp = new mat(mat1.m, mat1.n); for (int i = 0; i < mat1.m; i++) { for (int j = 0; j < mat1.n; j++) { temp.matrex1[i, j] = Math.Round(mat1.matrex1[i, j] * mat2.matrex1[i, j], 6); } } return(temp); }
public mat Ones(mat mat1) { mat temp = new mat(mat1.m, mat1.n); for (int i = 0; i < mat1.m; i++) { for (int j = 0; j < mat1.n; j++) { temp.matrex1[i, j] = 1; } } return(temp); }
public void forword() { hidd_temp = matrixProcess.Calculate_Matrix(hidden_weight, input, '*'); hidd_temp = out_sig(hidd_temp); hidden = matrixProcess.hidd(hidd_temp); output = matrixProcess.Calculate_Matrix(output_weight, hidden, '*'); output = out_sig(output); desire = matrixProcess.choosing(desire, ln); error = erroring(desire, output); toterror += total_error(error); }
public mat Subing(mat mat1, mat mat2) { mat temp = new mat(mat1.m, mat1.n); for (int i = 0; i < mat1.m; i++) { for (int j = 0; j < mat1.n; j++) { temp.matrex1[i, j] = mat1.matrex1[i, j] - mat2.matrex1[i, j]; } } return(temp); }
public mat Multple_single(mat mat1, double num) { mat temp = new mat(mat1.m, mat1.n); for (int i = 0; i < mat1.m; i++) { for (int j = 0; j < mat1.n; j++) { temp.matrex1[i, j] = Math.Round(mat1.matrex1[i, j] * num, 6); } } return(temp); }
public mat Transpose(mat mat1) { mat temp = new mat(mat1.n, mat1.m); for (int i = 0; i < mat1.m; i++) { for (int j = 0; j < mat1.n; j++) { temp.matrex1[j, i] = mat1.matrex1[i, j]; } } return(temp); }
//--------------------------------------------------------------------------------------------------------------- public mat Calculate_Matrix(mat mat1, mat mat2, char calc) { switch (calc) { case '+': return(Adding(mat1, mat2)); case '-': return(Subing(mat1, mat2)); case '*': return(Producting(mat1, mat2)); case 'o': return(Ones(mat1)); case 'z': return(Zeros(mat1)); case 'a': return(Multple_array(mat1, mat2)); case 's': return(Multple_single(mat1, 0)); // num); case 'r': Console.WriteLine("how many rows "); int num_rows = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("which column "); int which_column = Convert.ToInt32(Console.ReadLine()); return(cutting_row(mat1, num_rows, which_column)); case 'c': Console.WriteLine("how many column "); int num_column = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("which row "); int which_row = Convert.ToInt32(Console.ReadLine()); return(cutting_column(mat1, num_column, which_row)); case 't': return(Transpose(mat1)); case 'd': return(randumming(mat1)); default: return(mat1); } }
public mat randumming(mat mat1) { double value = 0.1; Random randNum = new Random(); for (int i = 0; i < mat1.m; i++) { for (int j = 0; j < mat1.n; j++) { mat1.matrex1[i, j] = Math.Round((value * 2 * randNum.NextDouble()) - value, 6); } } return(mat1); }
//-------------------------------------------------------------------------------------------------- public mat out_sig(mat mat1) { mat temping = new mat(mat1.m, mat1.n); for (int i = 0; i < mat1.m; i++) { for (int j = 0; j < mat1.n; j++) { temping.matrex1[i, j] = 1 / (1 + Math.Exp(-1 * lamda * mat1.matrex1[i, j])); } } return(temping); }
public void outing(mat temp) { Console.WriteLine(); int uu = 1; for (int i = 0; i < temp.m; i++) { for (int j = 0; j < temp.n; j++) { Console.Write(Math.Round(temp.matrex1[i, j], 3) + " "); uu++; } Console.WriteLine(); } }
public void entering(mat mat) { for (int i = 0; i < mat.m; i++) { for (int j = 0; j < mat.n; j++) { Console.WriteLine("Enter the value "); mat.matrex1[i, j] = Convert.ToDouble(Console.ReadLine()); } } for (int i = 0; i < mat.m; i++) { for (int j = 0; j < mat.n; j++) { Console.Write(mat.matrex1[i, j] + " "); } Console.WriteLine(); } }
public void backword() { // double temp2=0; mat ones = new mat(output_num, 1); mat backtemp = new mat(hidden_num, 1); mat output_error = new mat(output_num, 1); mat backtemp2 = new mat(hidden_num - 1, 1); ones = matrixProcess.Calculate_Matrix(ones, 'o', 0); output_error = matrixProcess.Calculate_Matrix(error, matrixProcess.Calculate_Matrix(output, matrixProcess.Calculate_Matrix(ones, output, '-'), 'a'), 'a'); output_deltaweight = matrixProcess.Calculate_Matrix(output_deltaweight, matrixProcess.Calculate_Matrix(output_error, matrixProcess.Calculate_Matrix(hidden, 't', 0), '*'), '+'); backtemp = matrixProcess.Calculate_Matrix(matrixProcess.Calculate_Matrix(output_weight, 't', 0), output_error, '*'); for (int i = 0; i < hidden_num - 1; i++) { backtemp2.matrex1[i, 0] = backtemp.matrex1[i, 0] * hidden.matrex1[i, 0] * (1 - hidden.matrex1[i, 0]); } hidden_deltaweight = matrixProcess.Calculate_Matrix(hidden_deltaweight, matrixProcess.Calculate_Matrix(backtemp2, matrixProcess.Calculate_Matrix(input, 't', 0), '*'), '+'); j++; }
public mat Producting(mat mat1, mat mat2) { mat temp; int m1 = mat1.m, n1 = mat1.n, m2 = mat2.m, n2 = mat2.n; double temp_pro = 0; temp = new mat(m1, n2); for (int j = 0; j < m1; j++) { for (int u = 0; u < n2; u++) { for (int i = 0; i < n1; i++) { temp_pro += mat1.matrex1[j, i] * mat2.matrex1[i, u]; } temp.matrex1[j, u] = temp_pro; temp_pro = 0; } } return(temp); }
public mat cutting_row(mat mat1, int m, int n) { mat temp; int[] array = new int[n]; temp = new mat(m, n + 1); int u = -1; for (int j = 0; j < temp.m; j++) { u++; m = array[u]; for (int i = 0; i < temp.n; i++) { temp.matrex1[j, i] = mat1.matrex1[m, i]; } } return(temp); }
//------------------------------------------------------------------------------------------- public mat cutting_column(mat mat1, int n, int m, int y) { mat temp; int[] array = new int[1]; array[0] = y; temp = new mat(m + 1, n); int u = -1; for (int j = 0; j < temp.n; j++) { u++; n = array[u]; for (int i = 0; i < temp.m; i++) { temp.matrex1[i, j] = mat1.matrex1[i, n]; } } return(temp); }
//--------------------------------------------------------------------------------------------------------------------------------------- public void update_weight(double number) { num = 1 / number; output_weight = matrixProcess.Calculate_Matrix(output_weight, matrixProcess.Calculate_Matrix(output_deltaweight, 's', num), '-'); hidden_weight = matrixProcess.Calculate_Matrix(hidden_weight, matrixProcess.Calculate_Matrix(hidden_deltaweight, 's', num), '-'); }
public void initiation() { hidden_weight = matrixProcess.Calculate_Matrix(hidden_weight, 'd', 0); output_weight = matrixProcess.Calculate_Matrix(output_weight, 'd', 0); }
//-------------------------------------------------------------------------------------------------------------- public mat choosing(mat desire, int ln) { desire = Calculate_Matrix(desire, 'z', 0); desire.matrex1[ln, 0] = 1; return(desire); }