A computational graph framework for neural networks written by WeaveNetC# , click here to learn about it.
This is a neural network written in c#, you can see the implementation of any internal details, you can learn about the neural network, and understand the calculation method in it. This architecture does not include automatic backward propagation, in order to show more computational details.
The source code includes cnn, bp, fcn, lstm, convlstm, GRU and other sample content, including the data content used in the example.
- LOSS支持：MESLOSS,cross-entropy
- Activation function support: ReLu, Tanh, Sigmod, Softmax
- Data type support: float[][] and float[][][,], 2D and 4D
- Pooling support: Average pooling Average pooling, Max pooling Maxpooling
- Other support: ConvLayer, Conv2DLayer, MulLayer, ConvTranspose2DLayer
- Each support class contains methods for forward propagation and backward propagation
The following small examples
CNN training implementation
public class CNN
{
Conv2DLayer cl;
Conv2DLayer cl2;
Conv2DLayer cl3;
//TanhLayer sl = new TanhLayer();
//TanhLayer sl2 = new TanhLayer();
//TanhLayer sl3 = new TanhLayer();
Maxpooling ap1;
Maxpooling ap2;
SigmodLayer sl = new SigmodLayer();
SigmodLayer sl2 = new SigmodLayer();
//SigmodLayer sl3 = new SigmodLayer();
Softmax sl3 = new Softmax();
//Averpooling ap2;
//Averpooling ap1;
public CNN()
{
cl = new Conv2DLayer(1, 0, 5, 1, 6);
//ap1 = new Averpooling(2);
ap1 = new Maxpooling(2);
cl2 = new Conv2DLayer(1, 0, 5, 6, 12);
// ap2 = new Averpooling(2);
ap2 = new Maxpooling(2);
cl3 = new Conv2DLayer(in_channels: 12, out_channels: 10, _inSize: 4,_full:true );
}
public dynamic Forward(float[][][,] matrices)
{
dynamic data = cl.Forward(matrices);
data = sl.Forward(data);
data = ap1.Forward(data);
data = cl2.Forward(data);
data = sl2.Forward(data);
data = ap2.Forward(data);
data = cl3.Forward(data);
data = sl3.Forward(data);
return data;
}
dynamic cl3grid;
dynamic cl2grid;
dynamic clgrid;
public void backward(dynamic grid)
{
dynamic grid2 = sl3.Backward(grid);
cl3grid = cl3.backweight(grid2);//获取cl3的权重
//--------------------------------
grid2 = cl3.Backward(grid2);
grid2 =ap2.Backward(grid2);
grid2 = sl2.Backward(grid2);
cl2grid = cl2.backweight(grid2);//获取cl2的权重
//-------------------------------------
grid2 = cl2.Backward(grid2);
grid2 = ap1.Backward(grid2);
grid2 = sl.Backward(grid2);
clgrid = cl.backweight(grid2);//获取cl的权重
}
float lr = 1.0f;
public void update()
{
// int channl = cl3grid.grid.Length;
cl3.wdata = Matrix.MatrixSub(cl3.wdata, Matrix.multiply(cl3grid.grid, lr));
cl3.basicData = Matrix.MatrixSub(cl3.basicData, Matrix.multiply(cl3grid.basic, lr));
cl2.weights = Matrix.MatrixSub(cl2.weights, Matrix.multiply(cl2grid.grid, lr));
cl2.basicData = Matrix.MatrixSub(cl2.basicData, Matrix.multiply(cl2grid.basic, lr));
cl.weights = Matrix.MatrixSub(cl.weights, Matrix.multiply(clgrid.grid, lr));
cl.basicData = Matrix.MatrixSub(cl.basicData, Matrix.multiply(clgrid.basic, lr));
}
}LSTM implementation example
public class LSTMCELL
{
ConvLayer convLayerih;
ConvLayer convLayerhh;
int input_size; int hidden_size;
public LSTMCELL(int _input_size, int _hidden_size)
{
input_size = _input_size;
hidden_size = _hidden_size;
convLayerih = new ConvLayer(input_size, hidden_size * 4 );
//convLayerih.weights = JsonConvert.DeserializeObject<float[][]>(util.getstr("D:\\lstmihw.json"));
//convLayerih.basicData = JsonConvert.DeserializeObject<float[]>(util.getstr("D:\\lstmihb.json"));
convLayerhh = new ConvLayer( hidden_size, hidden_size * 4);
//convLayerhh.weights = JsonConvert.DeserializeObject<float[][]>(util.getstr("D:\\lstmhhw.json"));
//convLayerhh.basicData = JsonConvert.DeserializeObject<float[]>(util.getstr("D:\\lstmhhb.json"));
}
SigmodLayer input_gate_s = new SigmodLayer();
SigmodLayer forget_gate_s = new SigmodLayer();
SigmodLayer output_gate_s = new SigmodLayer();
TanhLayer cell_memory_tl = new TanhLayer();
TanhLayer cell_tl = new TanhLayer();
MulLayer c_next_mul = new MulLayer();
MulLayer mulin_gate_mul = new MulLayer();
MulLayer h_next_mul = new MulLayer();
public dynamic Forward(float[][] input, float[][] h_prev, float[][] c_prev)
{
//a_vector = np.dot(x, self.weight_ih.T) + np.dot(h_prev, self.weight_hh.T)
//a_vector += self.bias_ih + self.bias_hh
Xinput = input;
xh_prev = h_prev;
xc_prev = c_prev;
var ih = convLayerih.Forward(input);
var hh = convLayerhh.Forward(h_prev);
var a_vector = Matrix.MatrixAdd(ih, hh);
List<float[][]> liast = Matrix.chunk(a_vector,4,1);
var a_i = liast[0];
var a_f = liast[1];
var a_c = liast[2];
var a_o = liast[3];
input_gate = input_gate_s.Forward(a_i);
forget_gate = forget_gate_s.Forward(a_f);
cell_memory = cell_memory_tl.Forward(a_c);
output_gate = output_gate_s.Forward(a_o);
var c_next_temp = c_next_mul.Forward(forget_gate, c_prev);
var mulin_gate = mulin_gate_mul.Forward(input_gate, cell_memory);
var c_next = Matrix.MatrixAdd(c_next_temp, mulin_gate);
var h_next = h_next_mul.Forward(output_gate, cell_tl.Forward(c_next));
// dh_prev = Matrix.zroe(h_next.Length, h_next[0].Length);
return (h_next,c_next);//上次的状态，上次的记忆
}
dynamic Xinput, xh_prev, xc_prev, input_gate, forget_gate, cell_memory, output_gate;
// dynamic dh_prev;
dynamic ihweight, hhweight;
public dynamic backward(dynamic grid)
{
var dh = h_next_mul.BackwardY(grid);
var d_tanh_c = cell_tl.Backward(dh);
//var dc_prev=c_next_mul.backwardY(d_tanh_c);
var d_input_gate = mulin_gate_mul.Backward(d_tanh_c);
var d_forget_gate=c_next_mul.Backward(d_tanh_c);
var d_cell_memory = mulin_gate_mul.BackwardY(d_tanh_c);
var d_output_gate = h_next_mul.Backward(grid);// d_tanh_c
var d_ai = input_gate_s.Backward(d_input_gate);
var d_af = forget_gate_s.Backward(d_forget_gate);
var d_ao = output_gate_s.Backward(d_output_gate);
var d_ac = cell_memory_tl.Backward(d_cell_memory);
var temp=Matrix.cat(d_ai, d_af, 1);
var temp2 = Matrix.cat( d_ac, d_ao, 1);
var da= Matrix.cat(temp, temp2, 1);
// var daT=Matrix.T(da);
ihweight = convLayerih.backweight(da);
hhweight = convLayerhh.backweight(da);
return convLayerih.backward(da);
}
float lr = 0.1f;
public void update()
{
convLayerih.weights = Matrix.MatrixSub(convLayerih.weights, Matrix.multiply(ihweight.grid, lr));
convLayerih.basicData = Matrix.MatrixSub(convLayerih.basicData, Matrix.multiply(ihweight.basic, lr));
convLayerhh.weights = Matrix.MatrixSub(convLayerhh.weights, Matrix.multiply(hhweight.grid, lr));
convLayerhh.basicData = Matrix.MatrixSub(convLayerhh.basicData, Matrix.multiply(hhweight.basic, lr));
}
}FCN implementation example
public class FCN
{
Conv2DLayer cl;
Conv2DLayer cl2;
Conv2DLayer cl3;
ConvTranspose2DLayer Tcl1;
Maxpooling mpl = new Maxpooling();
Maxpooling mpl2 = new Maxpooling();
SigmodLayer sl = new SigmodLayer();
SigmodLayer sl2 = new SigmodLayer();
SigmodLayer sl3 = new SigmodLayer();
Softmax sl4 = new Softmax();
public FCN(int weightssize)
{
cl = new Conv2DLayer(1, weightssize / 2, weightssize, 1, 6, bias: false);
cl2 = new Conv2DLayer(1, weightssize / 2, weightssize, 6, 12, bias: false);
cl3 = new Conv2DLayer(1, weightssize / 2, weightssize, 12, 24, bias: false);
Tcl1 = new ConvTranspose2DLayer(2, 1, weightssize + 1, 24, 1, bias: false);
}
public dynamic Forward(dynamic data)
{
dynamic data2= cl.Forward(data);
data2=sl.Forward(data2);
data2=mpl.Forward(data2);
data2 = cl2.Forward(data2);
data2 = sl2.Forward(data2);
data2 = mpl2.Forward(data2);
data2 = cl3.Forward(data2);
data2 = sl3.Forward(data2);
data2=Tcl1.Forward(data2);
data2 = sl4.Forward(data2);
return data2;
}
public dynamic backward(dynamic grid)
{
var grid2 = sl4.Backward(grid);
grid2= Tcl1.Backward(grid2);
grid2 = sl3.Backward(grid2);
grid2 = cl3.Backward(grid2);
grid2 = mpl2.Backward(grid2);
grid2 = sl2.Backward(grid2);
grid2 = cl2.Backward(grid2);
grid2 = mpl.Backward(grid2);
grid2 = sl.Backward(grid2);
grid2 = cl.Backward(grid2);
return grid2;
}
}
{{o.name}}
{{m.name}}