MachineLearning/layer.h at master · WinashAntsaw/MachineLearning · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#pragma once

#define RELU(input) (((input) > 0)? (input) : 0)

#define RELU_DERIV(input) (((input) > 0)? 1 : 0)

typedef float parameter;

typedef struct layer {
	//arrays to contain gradients for each layer
	parameter** weight_gradients;
	parameter* bias_gradients;

	//array to contain the inputs from the previous layer
	parameter* inputs;

	//arrays to contain parameters of layer
	parameter** weights;
	parameter* biases;

	//values to determine input and output size
	int in_size;
	int out_size;
} Layer;

typedef struct convolutional_layer {

	parameter* filter;
	parameter* inputs;
	parameter* gradients;

	int in_size;
	int filter_size;
} Convolution;

typedef struct neural_network Network;

unsigned short init_Layer(Layer* input, int in_size, int out_size);

unsigned short init_Convolution(Convolution* input, int filter_dimension);

unsigned short write_Layer(Layer* layer, int fd);

unsigned short write_Convolution(Convolution* input, int fd);

unsigned short extract_Layer(Layer* layer, int fd);

unsigned short extract_Convolution(Convolution* input, int fd);

parameter activation_function(parameter input);

parameter* calculate_next(Layer* layer, parameter* input);

void apply_gradients(Layer* input, parameter learn_rate);

parameter* calculate_gradients(Layer* layer, parameter* cost_derivative);

void adjust_gradients_slow(Network* network, Layer* layer, char* image, float* expected);

void clear_gradients(Layer* layer);

void print_weights(Layer* layer);

void print_weight_gradients(Layer* layer);

void print_biases(Layer* layer);

void print_bias_gradients(Layer* layer);