// Construct from initializer list of layer sizes multilayer_perceptron(std::initializer_list<size_t> l) : size_layers_(l) { // Check that there are at least two layers if (count_layers() < 2) throw std::invalid_argument("Number of layers to multilayer_perceptron must be greater than 1."); // Fill out weights and bias offsets, and calculate number of parameters count_parameters_ = 0; weight_offsets.resize(count_weights_layers()); bias_offsets.resize(count_weights_layers()); for (unsigned int i = 0; i < count_layers() - 1; i++) { weight_offsets[i] = count_parameters_; count_parameters_ += size_layers_[i] * size_layers_[i + 1]; bias_offsets[i] = count_parameters_; count_parameters_ += size_layers_[i + 1]; } // Allocate memory for hidden layers activations_.reserve(count_weights_layers()); deltas_.reserve(count_weights_layers()); for (unsigned int i = 1; i < count_weights_layers(); i++) { activations_.emplace_back(size_layers_[i]); deltas_.emplace_back(size_layers_[i]); } // Temporary variable used for storing output result outputs_.resize(count_outputs()); temp_.resize(count_outputs()); temp2_.resize(count_outputs()); temp3_.resize(count_outputs()); temp_gradient_.resize(count_parameters()); }
// Get the maximum entry of an output size_t get_nonzero_idx(const Eigen::VectorXd& inputs) { // TODO: Can this be replaced by a standard library algorithm? Iterate over vector for (size_t idx = 0; idx < count_outputs(); idx++) { if (inputs[idx] != 0) return idx; } return 0; }
static void setup_from_config (MateRRLabeler *labeler) { labeler->priv->num_outputs = count_outputs (labeler->priv->config); make_palette (labeler); create_label_windows (labeler); }
static void setup_from_config (CcRRLabeler *labeler) { labeler->priv->num_outputs = count_outputs (labeler->priv->config); make_palette (labeler); cc_rr_labeler_show (labeler); }
// Get the maximum entry of an output double get_maximum(const Eigen::VectorXd& inputs) { // Find the maximum element, which denotes the class with the highest probability // TODO: Can this be replaced by a standard library algorithm? Iterate over vector double class_idx = 0, class_probability = 0; for (size_t idx = 0; idx < count_outputs(); idx++) { if (inputs[idx] > class_probability) { class_probability = inputs[idx]; class_idx = idx; } } return class_idx; }
/** * Render using the program and verify that it outputs the proper data * to the transform feedback buffer. * * The program should already be linked and stored in the global \c * prog. */ static enum piglit_result test_xfb(bool use_rasterizer_discard) { GLuint buf; void *initial_data; const void *readback; unsigned expected_num_outputs = count_outputs(); unsigned buf_size = expected_num_outputs * NUM_VERTICES * sizeof(float); bool pass = true; /* Create transform feedback buffer and pre-load it with * garbage. */ glGenBuffers(1, &buf); initial_data = malloc(buf_size); memset(initial_data, 0xcc, buf_size); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, buf_size, initial_data, GL_STREAM_READ); free(initial_data); /* Draw a quad filling the window, with transform feedback * enabled. */ glUseProgram(prog); glBeginTransformFeedback(GL_TRIANGLES); if (use_rasterizer_discard) glEnable(GL_RASTERIZER_DISCARD); draw_rect(-1, -1, 2, 2); if (use_rasterizer_discard) glDisable(GL_RASTERIZER_DISCARD); glEndTransformFeedback(); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; /* Inspect transform feedback output. */ readback = glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf_size, GL_MAP_READ_BIT); pass = check_outputs(readback) && pass; glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); glDeleteBuffers(1, &buf); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }