int main(int argc, char* argv[])
{
int input_size = 10;
int dense_size1 = 5;
int dense_size2 = 3;
Container model;
model.add(Dense(dense_size1, input_size));
model.add(Dense(dense_size2));
auto layer = model.get_layer();
for (unsigned int i = 0; i < layer.size(); ++i) {
auto dense = layer[i];
printf("layer : %d\tdense_size : %d\t prev_dense_size : %d\n", i, dense.dense_size(), dense.get_cell(0).edge_size());
for(unsigned int j = 0; j < dense.dense_size(); ++j) {
auto cell = dense.get_cell(j);
auto weight = cell.get_weight();
auto bias = cell.get_bias();
for(unsigned int k = 0; k < weight.size(); ++k) {
printf("(%d,%d) : %lf\t%lf\n", j, k, weight[k], bias);
}
}
}
return 0;
}
NeuralNetwork* Phenotype::get_network(Individual* individual) {
NeuralNetwork* network = new NeuralNetwork();
// Locate markers
vector< pair<int, int> > raw_markers = get_markers(individual);
vector< pair<int, int> > markers;
for (int i = 0; i < raw_markers.size(); i++) {
if (get_slice_size(individual, raw_markers[i]) >= 7) {
markers.push_back(raw_markers[i]);
}
}
// Create input neurons
for (int i = 0; i < individual->input_units_; i++) {
Neuron neuron;
neuron.label_ = i;
network->input_neurons_.push_back(neuron);
}
// Create hidden neurons
for (int i = 0; i < markers.size(); i++) {
Neuron neuron;
neuron.label_ = get_label(individual, markers[i]);
neuron.bias_ = get_bias(individual, markers[i]);
neuron.output_ = neuron.bias_;
network->hidden_neurons_.push_back(neuron);
}
// Create output neurons
for (int i = 0; i < individual->output_units_; i++) {
Neuron neuron;
neuron.label_ = i;
neuron.bias_ = individual->genes_[(individual->genes_.size()-individual->output_units_) + i];
network->output_neurons_.push_back(neuron);
}
// Create links
for (int i = 0; i < markers.size(); i++) {
Neuron& neuron = network->hidden_neurons_[i];
int connections = (get_slice_size(individual, markers[i]) - 2) / 3;
for (int j = 0; j < connections; j++) {
signed char key = get_nth_key(individual, markers[i], j);
int label = get_nth_label(individual, markers[i], j);
signed char weight = get_nth_weight(individual, markers[i], j);
// Link to input/output layer
if (key > 0) {
// Input
if (label > 0) {
Neuron& input = network->input_neurons_[label % network->input_neurons_.size()];
input.outputs_.push_back(&neuron);
neuron.inputs_.push_back(pair<signed char, Neuron*>(weight, &input));
}
// Output
else {
Neuron& output = network->output_neurons_[abs(label) % network->output_neurons_.size()];
neuron.outputs_.push_back(&output);
output.inputs_.push_back(pair<signed char, Neuron*>(weight, &neuron));
}
}
// Link to hidden layer
else {
int hidden_label = get_hidden_label(individual, label);
Neuron* hidden = get_closest_neuron(hidden_label, network->hidden_neurons_);
hidden->outputs_.push_back(&neuron);
neuron.inputs_.push_back(pair<signed char, Neuron*>(weight, hidden));
}
}
}
return network;
}
void enc_alloc(jxr_t *p)
{
int n, k;
n = p->color.num_comp;
p->mb_buf = (int**)malloc(sizeof(int*) * n);
p->mb = (int**)malloc(sizeof(int*) * n);
p->mb_dclp_buf = (int**)malloc(sizeof(int*) * n);
p->mb_dclp = (int**)malloc(sizeof(int*) * n);
p->pred_dclp = (int**)malloc(sizeof(int*) * n);
p->hp = (int***)malloc(sizeof(int**) * n);
p->dclp_buf = (ringbuf_t*)malloc(sizeof(ringbuf_t) * n);
p->cbphp_buf = (ringbuf_t*)malloc(sizeof(ringbuf_t) * n);
p->lpqp_idx_buf.buf = (int*)malloc(sizeof(int) * (p->param.mb_width + 1));
p->lpqp_idx_buf.p = p->lpqp_idx_buf.buf;
p->lpqp_idx_buf.size = p->param.mb_width + 1;
p->lpqp_idx_buf.step = 1;
for (n = 0; n < p->color.num_comp; n++) {
int w = n > 0 && p->color.is_yuv42x ? 2 : 4;
int h = n > 0 && p->color.is_yuv420 ? 2 : 4;
p->mb_buf[n] = (int*)malloc(sizeof(int) * BW * BH);
p->mb[n] = p->mb_buf[n] + 4 + BW * 4;
p->mb_dclp_buf[n] = (int*)malloc(sizeof(int) * DCLPW * DCLPH);
p->mb_dclp[n] = p->mb_dclp_buf[n];
p->pred_dclp[n] = (int*)malloc(sizeof(int) * w * h);
p->hp[n] = (int**)malloc(sizeof(int*) * w * h);
for (k = 0; k < w * h; k++) {
p->hp[n][k] = (int*)malloc(sizeof(int) * 4 * 4);
}
p->dclp_buf[n].buf = (int*)malloc(sizeof(int) * w * h * (p->param.mb_width + 2));
p->dclp_buf[n].p = p->dclp_buf[n].buf;
p->dclp_buf[n].size = (p->param.mb_width + 2) * w;
p->dclp_buf[n].step = w;
p->cbphp_buf[n].buf = (int*)malloc(sizeof(int) * (p->param.mb_width + 1));
p->cbphp_buf[n].p = p->cbphp_buf[n].buf;
p->cbphp_buf[n].size = p->param.mb_width + 1;
p->cbphp_buf[n].step = 1;
}
if (!get_flag(p->param.flags, FREQUENCY_MODE_CODESTREAM_FLAG)) {
p->out = (bitbuf_t*)malloc(sizeof(bitbuf_t));
p->out[0].buf = (uint32_t*)malloc(sizeof(uint32_t) * p->param.width * p->param.height);
p->out[0].p = p->out[0].buf;
p->out[0].left = 32;
//p->out[0].length = p->param.width * p->param.height * p->color.num_comp;
} else {
p->out = (bitbuf_t*)malloc(sizeof(bitbuf_t) * 4);
for (k = 0; k < 4; k++) {
p->out[k].buf = (uint32_t*)malloc(sizeof(uint32_t) * p->param.width * p->param.height);
p->out[k].p = p->out[k].buf;
p->out[k].left = 32;
//p->out[k].length = p->param.width * p->param.height * p->color.num_comp;
}
}
p->color.conv_idx = get_color_conv_idx(p->param.ex_color_format,
p->param.ex_bitdepth,
p->param.in_color_format);
p->color.bias = get_bias(p->param.ex_bitdepth);
if (!get_flag(p->param.flags, TILING_FLAG)) {
p->param.num_ver_tiles = 1;
p->param.num_hor_tiles = 1;
p->param.tile_width_in_mb = (uint16_t*)malloc(sizeof(uint16_t));
p->param.tile_height_in_mb = (uint16_t*)malloc(sizeof(uint16_t));
p->param.tile_width_in_mb[0] = p->param.mb_width;
p->param.tile_height_in_mb[0] = p->param.mb_height;
}
p->step = p->param.width * n;
//enc_image_header(p->out, &p->param);
//enc_image_plane_header(p->out, &p->param);
p->is_ready = 1;
}
