output fc_rnn::execute(input const& in)
{
// Set activation of input neurons
auto const num_input = in.size();
for(size_t n = 0; n < num_input; ++n)
{
vInput[n] = in[n];
}
// Summation for hidden neurons
Eigen::VectorXd vHiddenSums =
wmInput * vInput +
wmHidden * vHidden;
// Transfer function
vHidden =
evaluate(af_hidden, vHiddenSums.array());
// TODO: Maybe should just store as a single vector?
Eigen::VectorXd joined(input_layer_count() + hidden_count());
joined << vInput, vHidden;
Eigen::VectorXd vOutputSums =
wmOutput * joined;
Eigen::VectorXd vOutput =
evaluate(af_output, vOutputSums.array());
// Return the output values
output out{ output_count() };
std::copy(vOutput.data(), vOutput.data() + output_count(), out.begin());
return out;
}
void fc_rnn::initialize_connection_map()
{
connection_id id = 0;
// Input->Hidden
for(neuron_id in = 0; in < input_layer_count(); ++in)
{
for(neuron_id hid = 0; hid < hidden_count(); ++hid)
{
m_connections.insert({ id, std::make_pair(input_offset() + in, hidden_offset() + hid) });
++id;
}
}
// Hidden->Hidden
for(neuron_id hid1 = 0; hid1 < hidden_count(); ++hid1)
{
for(neuron_id hid2 = 0; hid2 < hidden_count(); ++hid2)
{
m_connections.insert({ id, std::make_pair(hidden_offset() + hid1, hidden_offset() + hid2) });
++id;
}
}
// Input,Hidden->Output
for(neuron_id ih = 0; ih < input_layer_count() + hidden_count(); ++ih)
{
for(neuron_id out = 0; out < output_count(); ++out)
{
m_connections.insert({ id, std::make_pair(input_offset() + ih, output_offset() + out) });
++id;
}
}
}
size_t fc_rnn::calculate_connection_count() const
{
return
input_layer_count() * hidden_count() +
hidden_count() * hidden_count() +
(input_layer_count() + hidden_count()) * output_count()
;
}
// todo: option to exclude bias
size_t fc_rnn::layer_count(LayerType ly) const
{
switch(ly)
{
case LayerType::Input: return input_layer_count();
case LayerType::Hidden: return hidden_count();
case LayerType::Output: return output_count();
default: throw std::runtime_error("invalid layer type");
}
}
int main()
{
unsigned long long int count[X*X][X*X]={{0}};
int ms[X*X];
int i;
char str[0xffff];
while(!feof(stdin)){
fgets(str, 0xffff, stdin);
str_to_tale(ms, str);
for(i=0; i<X*X; i++)
count[i][ms[i]-1]++;
}
output_count(count);
return 0;
}
layer_data fc_rnn::neuron_layer(neuron_id id) const
{
if(id < input_layer_count())
{
return layer_data{ LayerType::Input };
}
id -= input_layer_count();
if(id < hidden_count())
{
return layer_data{ LayerType::Hidden };
}
id -= hidden_count();
if(id < output_count())
{
return layer_data{ LayerType::Output };
}
throw std::runtime_error("invalid neuron id");
}
size_t fc_rnn::neuron_count() const
{
return input_layer_count() + hidden_count() + output_count();
}
