Matrix<double> Perceptron::calculate_Hessian(const Vector<double>& inputs) const { // Control sentence (if debug) #ifdef __OPENNN_DEBUG__ const size_t inputs_number = get_inputs_number(); const size_t inputs_size = inputs.size(); if(inputs_size != inputs_number) { std::ostringstream buffer; buffer << "OpenNN Exception: Perceptron class.\n" << "Matrix<double> calculate_Hessian(const Vector<double>&) const method.\n" << "Size of inputs must be equal to number of inputs.\n"; throw std::logic_error(buffer.str()); } #endif const double combination = calculate_combination(inputs); const double activation_second_derivative = calculate_activation_second_derivative(combination); return(synaptic_weights.direct(synaptic_weights)*activation_second_derivative); }
double Perceptron::calculate_output(const Vector<double>& inputs) const { // Control sentence (if debug) #ifdef __OPENNN_DEBUG__ const size_t size = inputs.size(); const size_t inputs_number = get_inputs_number(); if(size != inputs_number) { std::ostringstream buffer; buffer << "OpenNN Exception: Perceptron class.\n" << "double calculate_output(const Vector<double>&) const method.\n" << "Size must be equal to number of inputs.\n"; throw std::logic_error(buffer.str()); } #endif // Calculate outputs return(calculate_activation(calculate_combination(inputs))); }
Vector<double> Perceptron::calculate_gradient(const Vector<double>& inputs, const Vector<double>& parameters) const { const size_t inputs_number = get_inputs_number(); // Control sentence (if debug) #ifdef __OPENNN_DEBUG__ const size_t size = inputs.size(); if(size != inputs_number) { std::ostringstream buffer; buffer << "OpenNN Exception: Perceptron class.\n" << "double calculate_gradient(const Vector<double>&, const Vector<double>&) const method.\n" << "Size must be equal to number of inputs.\n"; throw std::logic_error(buffer.str()); } #endif // Calculate parameters gradient const double combination = calculate_combination(inputs, parameters); const double activation_derivative = calculate_activation_derivative(combination); Vector<double> gradient(1+inputs_number); // Bias gradient[0] = activation_derivative; // Synaptic weights for(size_t i = 1; i < 1+inputs_number; i++) { gradient[i] = inputs[i-1]*activation_derivative; } return(gradient); }
double Perceptron::calculate_output(const Vector<double>& inputs, const Vector<double>& parameters) const { // Control sentence (if debug) #ifdef __OPENNN_DEBUG__ const size_t inputs_size = inputs.size(); const size_t inputs_number = get_inputs_number(); if(inputs_size != inputs_number) { std::ostringstream buffer; buffer << "OpenNN Exception: Perceptron class.\n" << "double calculate_output(const Vector<double>&, const Vector<double>&) const method.\n" << "Size of inputs must be equal to number of inputs.\n"; throw std::logic_error(buffer.str()); } const size_t parameters_size = parameters.size(); const size_t parameters_number = count_parameters_number(); if(parameters_size != parameters_number) { std::ostringstream buffer; buffer << "OpenNN Exception: Perceptron class.\n" << "double calculate_output(const Vector<double>&, const Vector<double>&) const method.\n" << "Size of potential parameters (" << parameters_size << ") must be equal to number of parameters (" << parameters_number << ").\n"; throw std::logic_error(buffer.str()); } #endif return(calculate_activation(calculate_combination(inputs, parameters))); }
double Perceptron::calculate_output(const Vector<double>& input) { // Control sentence (if debug) #ifdef _DEBUG int size = input.get_size(); if(size != inputs_number) { std::cerr << "Flood Error: Perceptron class." << std::endl << "double calculate_output(const Vector<double>&) method." << std::endl << "Size must be equal to number of inputs." << std::endl; exit(1); } #endif // Calculate output return(calculate_activation(calculate_combination(input))); }
Matrix<double> Perceptron::calculate_Hessian(const Vector<double>& inputs, const Vector<double>& parameters) const { // Control sentence (if debug) #ifdef __OPENNN_DEBUG__ const size_t inputs_size = inputs.size(); const size_t inputs_number = get_inputs_number(); if(inputs_size != inputs_number) { std::ostringstream buffer; buffer << "OpenNN Exception: Perceptron class.\n" << "Matrix<double> calculate_Hessian(const Vector<double>&, const Vector<double>&) const method.\n" << "Size of inputs must be equal to number of inputs.\n"; throw std::logic_error(buffer.str()); } #endif const double combination = calculate_combination(inputs, parameters); const double activation_second_derivative = calculate_activation_second_derivative(combination); const size_t parameters_number = count_parameters_number(); Matrix<double> Hessian(parameters_number, parameters_number); // Bias - bias derivative Hessian(0,0) = activation_second_derivative; // Bias - synaptic weight derivative for(size_t i = 1; i < parameters_number; i++) { Hessian(0,i) = activation_second_derivative*inputs[i-1]; } // Synaptic weight -synaptic weight derivative for(size_t i = 1; i < parameters_number; i++) { for(size_t j = 1; j < parameters_number; j++) { Hessian(i,j) = activation_second_derivative*inputs[i-1]*inputs[j-1]; } } // Hessian symmetry for(size_t i = 0; i < parameters_number; i++) { for(size_t j = 0; j < i; j++) { Hessian(i,j) = Hessian(j,i); } } return(Hessian); }