Premier apprentissage profond en C # -Imitation de l'implémentation en Python-
Apprentissage profond en C # (calcul matriciel)
Cette fois, j'ai créé uniquement un programme qui calcule la matrice nécessaire à l'apprentissage profond. Le livre auquel j'ai fait référence était "Make from scratch Deep Learning". Je recommande ce livre car il est très facile à comprendre et je pense que c'est un bon livre. Ce n'est pas un manga, mais ça ne s'arrête pas ... J'étais tellement intéressé. Je n'en ai encore lu que la moitié environ, donc il y a beaucoup de parties que je ne comprends pas bien, mais cette fois j'ai fait un programme de calcul matriciel en C #.
C #, pas Python?
Ce livre explique également la théorie, donc je voulais le faire ** à partir de zéro ** en C # sans compter sur la bibliothèque Python. J'essaierai de l'implémenter en F # et Haskell plus tard.
Pourquoi avez-vous commencé l'apprentissage en profondeur?
J'ai récemment commencé à étudier des langages fonctionnels tels que F # et Haskell, et je ne comprends toujours pas la signification de l'utilisation des langages fonctionnels. "Au fait, les langages fonctionnels se sont rapprochés des idées mathématiques." Ensuite, l'apprentissage en profondeur! (Le motif était que je ne savais pas comment utiliser le langage fonctionnel.) Pour le moment, je l'ai fait en C #.
Code source C
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;
}
}
}
La classe Mat est une classe qui calcule la matrice.
L'exemple d'utilisation est le suivant.
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; //Programme Tammy pour définir les points d'arrêt
}
}
}
C'était compliqué de sortir sur cette semelle, j'ai donc mis un point d'arrêt sur la ligne _ = 1; et vérifié le contenu du tableau ʻans`.
Il est calculé correctement. Cette fois, le produit scalaire est calculé avec "Mat", mais l'addition et la soustraction sont également possibles.
- La raison pour laquelle il n'est pas représenté par un tableau bidimensionnel est qu'il était possible qu'il s'agisse d'un tableau unidimensionnel tel qu'une entrée pour l'apprentissage en profondeur. J'ai pensé à surcharger avec le constructeur, mais je n'ai pas pu le faire faute de puissance.
Recommended Posts