Erstes tiefes Lernen in C # - Einführung in Python implementieren-
Deep Learning in C # (Matrixberechnung)
Dieses Mal habe ich nur ein Programm erstellt, das die für das Tiefenlernen erforderliche Matrix berechnet. Das Buch, auf das ich mich bezog, war "Make from Grund Deep Learning". Ich empfehle dieses Buch, weil es sehr leicht zu verstehen ist und ich denke, dass es ein gutes Buch ist. Es ist kein Manga, aber es hört nicht auf ... Ich war so interessiert. Ich habe bisher nur etwa die Hälfte davon gelesen, daher gibt es viele Teile, die ich nicht gut verstehe, aber dieses Mal habe ich ein Matrixberechnungsprogramm in C # erstellt.
C #, nicht Python?
Dieses Buch erklärt auch die Theorie, deshalb wollte ich sie in C # von Grund auf neu erstellen, ohne mich auf die Python-Bibliothek verlassen zu müssen. Ich werde später versuchen, es in F # und Haskell zu implementieren.
Warum hast du angefangen tief zu lernen?
Ich habe vor kurzem angefangen, funktionale Sprachen wie F # und Haskell zu studieren, und ich kann immer noch nicht verstehen, was es bedeutet, funktionale Sprachen zu verwenden. "Funktionale Sprachen sind übrigens mathematischen Ideen näher gekommen." Dann tiefes Lernen! (Das Motiv war, dass ich nicht wusste, wie man eine funktionale Sprache benutzt.) Vorerst habe ich es in C # gemacht.
C # -Quellcode
Matrix.cs
namespace Matrix
{
class Mat
{
private int r = 0;
public int R
{
get { return r; }
}
private int c = 0;
public int C
{
get { return c; }
}
private bool err = false;
public bool Err
{
get { return err; }
}
private double[][] matrix_data;
public double[][] Matrix_data
{
get {
double[][] a = new double[2][];
a[0] = new double[] { 0, 0 };
a[1] = new double[] { 0, 0 };
if (err) return a;
else return matrix_data;
}
set
{
matrix_data = value;
}
}
public Mat(params double[][] vs)
{
int len = vs[0].Length;
for (int i = 0; i < vs.Length; i++)
{
if (i != 0 && len != vs[i].Length)
{
err = true;
}
}
if (!err)
{
r = vs.Length;
c = vs[0].Length;
matrix_data = vs;
}
}
public static double[][] operator +(Mat p1, Mat p2)
{
double[][] d = new double[p1.R][];
if (p1.C == p2.C && p1.R == p2.R)
{
for (int i = 0; i < p1.R; i++)
{
d[i] = new double[p1.C];
for (int j = 0; j < p1.C; j++)
{
d[i][j] = p1.Matrix_data[i][j] + p2.Matrix_data[i][j];
}
}
}
else
{
for (int k = 0; k < p1.R; k++)
{
d[k] = new double[2] { 0, 0 };
}
}
return d;
}
public static double[][] operator +(double p1, Mat p2)
{
double[][] d = new double[p2.R][];
for (int i = 0; i < p2.R; i++)
{
d[i] = new double[p2.C];
for (int j = 0; j < p2.C; j++)
{
d[i][j] = p2.Matrix_data[i][j] + p1;
}
}
return d;
}
public static double[][] operator +(Mat p1, double p2)
{
double[][] d = new double[p1.R][];
for (int i = 0; i < p1.R; i++)
{
d[i] = new double[p1.C];
for (int j = 0; j < p1.C; j++)
{
d[i][j] = p1.Matrix_data[i][j] + p2;
}
}
return d;
}
public static double[][] operator -(Mat p1, Mat p2)
{
double[][] d = new double[p1.R][];
if (p1.C == p2.C && p1.R == p2.R)
{
for (int i = 0; i < p1.R; i++)
{
d[i] = new double[p1.C];
for (int j = 0; j < p1.C; j++)
{
d[i][j] = p1.Matrix_data[i][j] - p2.Matrix_data[i][j];
}
}
}
else
{
for (int k = 0; k < p1.R; k++)
{
d[k] = new double[2] { 0, 0 };
}
}
return d;
}
public static double[][] operator -(double p1, Mat p2)
{
double[][] d = new double[p2.R][];
for (int i = 0; i < p2.R; i++)
{
d[i] = new double[p2.C];
for (int j = 0; j < p2.C; j++)
{
d[i][j] = p1 - p2.Matrix_data[i][j];
}
}
return d;
}
public static double[][] operator -(Mat p1, double p2)
{
double[][] d = new double[p1.R][];
for (int i = 0; i < p1.R; i++)
{
d[i] = new double[p1.C];
for (int j = 0; j < p1.C; j++)
{
d[i][j] = p1.Matrix_data[i][j] - p2;
}
}
return d;
}
public static double[][] dot(Mat p1, Mat p2)
{
double[][] d = new double[p1.R][];
double temp = 0;
if (p1.C == p2.R)
{
for (int i = 0; i < p1.R; i++)
{
d[i] = new double[p2.C];
for (int j = 0; j < p2.C; j++)
{
for(int a = 0; a < p1.C; a++)
{
temp = temp + p1.Matrix_data[i][a] * p2.Matrix_data[a][j];
}
d[i][j] = temp;
temp = 0.0;
}
}
}
else
{
for (int k = 0; k < p1.R; k++)
{
d[k] = new double[2] { 0, 0 };
}
}
return d;
}
}
}
Klasse Mat ist eine Klasse, die die Matrix berechnet.
Das Verwendungsbeispiel lautet wie folgt.
Program.cs
namespace Matrix
{
class Program
{
static void Main(string[] args)
{
Mat A = new Mat(
new double[] { 1, 2, 3 },
new double[] { 2, 3, 4 }) ,
B = new Mat(
new double[] { 1, 2 },
new double[] { 2, 3 },
new double[] { 3, 4 });
double[][] ans = Mat.dot(A, B);
_ = 1; //Tammy-Programm zum Setzen von Haltepunkten
}
}
}
Die Ausgabe auf diese Sohle war mühsam, daher habe ich einen Haltepunkt in die Zeile "_ = 1;" gesetzt und den Inhalt des Arrays "ans" überprüft.
Es wird richtig berechnet. Dieses Mal wird das Punktprodukt mit "Mat" berechnet, aber Addition und Subtraktion sind ebenfalls möglich.
- Der Grund, warum es nicht durch ein zweidimensionales Array dargestellt wird, besteht darin, dass die Möglichkeit bestand, dass es sich um ein eindimensionales Array handelt, beispielsweise als Eingabe für tiefes Lernen. Ich dachte über eine Überladung mit dem Konstruktor nach, konnte es aber wegen mangelnder Leistung nicht tun.
Recommended Posts