neural_layer.h

Go to the documentation of this file.

/*
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "neural.h"
#include "neural_layer_args.h"
 
#define CONNECTED (0) 
#define DROPOUT (1) 
#define NOISE (2) 
#define SOFTMAX (3) 
#define RECURRENT (4) 
#define LSTM (5) 
#define MAXPOOL (6) 
#define CONVOLUTIONAL (7) 
#define AVGPOOL (8) 
#define UPSAMPLE (9) 
 
#define STRING_CONNECTED ("connected\0") 
#define STRING_DROPOUT ("dropout\0") 
#define STRING_NOISE ("noise\0") 
#define STRING_SOFTMAX ("softmax\0") 
#define STRING_RECURRENT ("recurrent\0") 
#define STRING_LSTM ("lstm\0") 
#define STRING_MAXPOOL ("maxpool\0") 
#define STRING_CONVOLUTIONAL ("convolutional\0") 
#define STRING_AVGPOOL ("avgpool\0") 
#define STRING_UPSAMPLE ("upsample\0") 
 
#define LAYER_EVOLVE_WEIGHTS (1 << 0) 
#define LAYER_EVOLVE_NEURONS (1 << 1) 
#define LAYER_EVOLVE_FUNCTIONS (1 << 2) 
#define LAYER_SGD_WEIGHTS (1 << 3) 
#define LAYER_EVOLVE_ETA (1 << 4) 
#define LAYER_EVOLVE_CONNECT (1 << 5) 
 
#define NEURON_MIN (-100) 
#define NEURON_MAX (100) 
#define WEIGHT_MIN (-10) 
#define WEIGHT_MAX (10) 
#define N_WEIGHTS_MAX (20000000) 
#define N_INPUTS_MAX (2000000) 
#define N_OUTPUTS_MAX (2000000) 
 
#define WEIGHT_SD_INIT (0.1) 
#define WEIGHT_SD (0.1) 
#define WEIGHT_SD_RAND (1.0) 
 
struct Layer {
    int type; 
    double *state; 
    double *output; 
    uint32_t options; 
    double *weights; 
    bool *weight_active; 
    double *biases; 
    double *bias_updates; 
    double *weight_updates; 
    double *delta; 
    double *mu; 
    double eta; 
    double eta_max; 
    double eta_min; 
    double momentum; 
    double decay; 
    int n_inputs; 
    int n_outputs; 
    int max_outputs; 
    int max_neuron_grow; 
    int n_weights; 
    int n_biases; 
    int n_active; 
    int function; 
    double scale; 
    double probability; 
    struct LayerVtbl const *layer_vptr; 
    double *prev_state; 
    struct Layer *input_layer; 
    struct Layer *self_layer; 
    struct Layer *output_layer; 
    int recurrent_function; 
    struct Layer *uf; 
    struct Layer *ui; 
    struct Layer *ug; 
    struct Layer *uo; 
    struct Layer *wf; 
    struct Layer *wi; 
    struct Layer *wg; 
    struct Layer *wo; 
    double *cell; 
    double *prev_cell; 
    double *f; 
    double *i; 
    double *g; 
    double *o; 
    double *c; 
    double *h; 
    double *temp; 
    double *temp2; 
    double *temp3; 
    double *dc; 
    int height; 
    int width; 
    int channels; 
    int pad; 
    int out_w; 
    int out_h; 
    int out_c; 
    int size; 
    int stride; 
    int *indexes; 
    int n_filters; 
};
 
struct LayerVtbl {
    void (*layer_impl_init)(struct Layer *l, const struct ArgsLayer *args);
    bool (*layer_impl_mutate)(struct Layer *l);
    void (*layer_impl_resize)(struct Layer *l, const struct Layer *prev);
    struct Layer *(*layer_impl_copy)(const struct Layer *src);
    void (*layer_impl_free)(const struct Layer *l);
    void (*layer_impl_rand)(struct Layer *l);
    void (*layer_impl_print)(const struct Layer *l, const bool print_weights);
    void (*layer_impl_update)(const struct Layer *l);
    void (*layer_impl_backward)(const struct Layer *l, const struct Net *net,
                                const double *input, double *delta);
    void (*layer_impl_forward)(const struct Layer *l, const struct Net *net,
                               const double *input);
    double *(*layer_impl_output)(const struct Layer *l);
    size_t (*layer_impl_save)(const struct Layer *l, FILE *fp);
    size_t (*layer_impl_load)(struct Layer *l, FILE *fp);
    char *(*layer_impl_json_export)(const struct Layer *l,
                                    const bool return_weights);
};
 
static inline double *
layer_output(const struct Layer *l)
{
    return (*l->layer_vptr->layer_impl_output)(l);
}
 
static inline void
layer_forward(const struct Layer *l, const struct Net *net, const double *input)
{
    (*l->layer_vptr->layer_impl_forward)(l, net, input);
}
 
static inline void
layer_backward(const struct Layer *l, const struct Net *net,
               const double *input, double *delta)
{
    (*l->layer_vptr->layer_impl_backward)(l, net, input, delta);
}
 
static inline void
layer_update(const struct Layer *l)
{
    (*l->layer_vptr->layer_impl_update)(l);
}
 
static inline bool
layer_mutate(struct Layer *l)
{
    return (*l->layer_vptr->layer_impl_mutate)(l);
}
 
static inline void
layer_resize(struct Layer *l, const struct Layer *prev)
{
    (*l->layer_vptr->layer_impl_resize)(l, prev);
}
 
static inline struct Layer *
layer_copy(const struct Layer *src)
{
    return (*src->layer_vptr->layer_impl_copy)(src);
}
 
static inline void
layer_free(const struct Layer *l)
{
    (*l->layer_vptr->layer_impl_free)(l);
}
 
static inline void
layer_rand(struct Layer *l)
{
    (*l->layer_vptr->layer_impl_rand)(l);
}
 
static inline void
layer_print(const struct Layer *l, const bool print_weights)
{
    (*l->layer_vptr->layer_impl_print)(l, print_weights);
}
 
static inline char *
layer_json_export(const struct Layer *l, const bool return_weights)
{
    return (*l->layer_vptr->layer_impl_json_export)(l, return_weights);
}
 
bool
layer_mutate_connectivity(struct Layer *l, const double mu_enable,
                          const double mu_disable);
 
bool
layer_mutate_eta(struct Layer *l, const double mu);
 
bool
layer_mutate_functions(struct Layer *l, const double mu);
 
bool
layer_mutate_weights(struct Layer *l, const double mu);
 
int
layer_mutate_neurons(const struct Layer *l, const double mu);
 
void
layer_add_neurons(struct Layer *l, const int n);
 
void
layer_calc_n_active(struct Layer *l);
 
void
layer_defaults(struct Layer *l);
 
void
layer_init_eta(struct Layer *l);
 
void
layer_set_vptr(struct Layer *l);
 
void
layer_weight_clamp(const struct Layer *l);
 
void
layer_weight_print(const struct Layer *l, const bool print_weights);
 
char *
layer_weight_json(const struct Layer *l, const bool return_weights);
 
void
layer_weight_rand(struct Layer *l);
 
void
layer_ensure_input_represention(struct Layer *l);
 
const char *
layer_type_as_string(const int type);
 
int
layer_type_as_int(const char *type);
 
bool
layer_receives_images(const int type);
 
void
layer_guard_biases(const struct Layer *l);
 
void
layer_guard_outputs(const struct Layer *l);
 
void
layer_guard_weights(const struct Layer *l);
 
static inline struct Layer *
layer_init(const struct ArgsLayer *args)
{
    struct Layer *l = (struct Layer *) malloc(sizeof(struct Layer));
    layer_defaults(l);
    l->type = args->type;
    layer_set_vptr(l);
    (*l->layer_vptr->layer_impl_init)(l, args);
    return l;
}
 
static inline size_t
layer_save(const struct Layer *l, FILE *fp)
{
    size_t s = fwrite(&l->type, sizeof(int), 1, fp);
    s += (*l->layer_vptr->layer_impl_save)(l, fp);
    return s;
}
 
static inline size_t
layer_load(struct Layer *l, FILE *fp)
{
    layer_defaults(l);
    size_t s = fread(&l->type, sizeof(int), 1, fp);
    layer_set_vptr(l);
    s += (*l->layer_vptr->layer_impl_load)(l, fp);
    return s;
}