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);
}
