void Perceptron::set_parameters(const Vector<double>& new_parameters)
{
const size_t inputs_number = get_inputs_number();
// Control sentence (if debug)
#ifdef __OPENNN_DEBUG__
const size_t size = new_parameters.size();
if(size != 1+inputs_number)
{
std::ostringstream buffer;
buffer << "OpenNN Exception: Perceptron class.\n"
<< "void set_parameters(const Vector<double>&) method.\n"
<< "Size must be equal to one plus number of inputs.\n";
throw std::logic_error(buffer.str());
}
#endif
bias = new_parameters[0];
for(size_t i = 0; i < inputs_number; i++)
{
synaptic_weights[i] = new_parameters[i+1];
}
}
void Perceptron::set_synaptic_weights(const Vector<double>& new_synaptic_weights)
{
// Control sentence (if debug)
#ifdef __OPENNN_DEBUG__
const size_t inputs_number = get_inputs_number();
if(new_synaptic_weights.size() != inputs_number)
{
std::ostringstream buffer;
buffer << "OpenNN Exception: Perceptron class.\n"
<< "void set_synaptic_weights(const Vector<double>&) method.\n"
<< "Size of synaptic weights vector must be equal to number of inputs.\n";
throw std::logic_error(buffer.str());
}
#endif
// Set synaptic weights
synaptic_weights = new_synaptic_weights;
}
void Perceptron::set_synaptic_weight(const size_t& synaptic_weight_index, const double& new_synaptic_weight)
{
// Control sentence (if debug)
#ifdef __OPENNN_DEBUG__
const size_t inputs_number = get_inputs_number();
if(synaptic_weight_index >= inputs_number)
{
std::ostringstream buffer;
buffer << "OpenNN Exception: Perceptron class.\n"
<< "void set_synaptic_weight(const size_t&, const double&) method.\n"
<< "Index of synaptic weight must be less than number of inputs.\n";
throw std::logic_error(buffer.str());
}
#endif
// Set single synaptic weight
synaptic_weights[synaptic_weight_index] = new_synaptic_weight;
}
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);
}
std::string Perceptron::write_expression(const Vector<std::string>& inputs_name, const std::string& output_name) const
{
const size_t inputs_number = get_inputs_number();
std::string activation_function_name = write_activation_function();
std::ostringstream buffer;
buffer << output_name << "=" << activation_function_name << "("
<< bias << "\n";
for(size_t i = 0; i < inputs_number; i++)
{
if(synaptic_weights[i] >= 0)
{
buffer << "+";
}
buffer << synaptic_weights[i] << "*" << inputs_name[i];
if(i != 0 && i%4 == 0 && i != inputs_number-1)
{
buffer << "\n";
}
}
buffer << ");\n";
return(buffer.str());
}
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)));
}
Matrix<double> Perceptron::calculate_combination_Hessian(const Vector<double>&) const
{
const size_t inputs_number = get_inputs_number();
const Matrix<double> combination_Hessian(inputs_number, inputs_number, 0.0);
return(combination_Hessian);
}
double Perceptron::calculate_combination(const Vector<double>& inputs, const Vector<double>& parameters) const
{
const size_t inputs_number = get_inputs_number();
// Control sentence (if debug)
#ifdef __OPENNN_DEBUG__
std::ostringstream buffer;
const size_t inputs_size = inputs.size();
if(inputs_size != inputs_number)
{
buffer << "OpenNN Exception: Perceptron class.\n"
<< "double calculate_combination(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)
{
buffer << "OpenNN Exception: Perceptron class.\n"
<< "double calculate_combination(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
// Modified for performance.
double combination = parameters[0];
for(size_t i = 0; i < inputs_number; i++)
{
combination += parameters[i+1]*inputs[i];
}
return(combination);
}
Vector<double> Perceptron::arrange_parameters(void) const
{
const size_t parameters_number = count_parameters_number();
Vector<double> parameters(parameters_number);
parameters[0] = bias;
const size_t inputs_number = get_inputs_number();
for(size_t i = 0; i < inputs_number; i++)
{
parameters[(size_t)1+i] = synaptic_weights[i];
}
return(parameters);
}
double Perceptron::calculate_combination(const Vector<double>& inputs) const
{
const size_t inputs_number = get_inputs_number();
// Control sentence (if debug)
#ifdef __OPENNN_DEBUG__
if(inputs_number == 0)
{
std::ostringstream buffer;
buffer << "OpenNN Exception: Perceptron class.\n"
<< "calculate_combination(const Vector<double>&) method.\n"
<< "Number of inputs must be greater than zero.\n";
throw std::logic_error(buffer.str());
}
const size_t inputs_size = inputs.size();
if(inputs_size != inputs_number)
{
std::ostringstream buffer;
buffer << "OpenNN Exception: Perceptron class.\n"
<< "double calculate_combination(const Vector<double>&) method.\n"
<< "Size of inputs (" << inputs_size << ") must be equal to number of inputs (" << inputs_number << ").\n";
throw std::logic_error(buffer.str());
}
#endif
// Calculate combination
double combination = bias;
for(size_t i = 0; i < inputs_number; i++)
{
combination += synaptic_weights[i]*inputs[i];
}
return(combination);
}
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)));
}
void Perceptron::prune_input(const size_t& index)
{
// Control sentence (if debug)
#ifdef __OPENNN_DEBUG__
const size_t inputs_number = get_inputs_number();
if(index >= inputs_number)
{
std::ostringstream buffer;
buffer << "OpenNN Exception: Perceptron class.\n"
<< "void prune_input(const size_t&) method.\n"
<< "Index of input is equal or greater than number of inputs.\n";
throw std::logic_error(buffer.str());
}
#endif
synaptic_weights.erase(synaptic_weights.begin()+index);
}
size_t Perceptron::count_parameters_number(void) const
{
const size_t inputs_number = get_inputs_number();
return(1 + inputs_number);
}
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);
}