bool is_learned(double teacher[][IN_SIZE], double *in, double *out, double weights[][OUT_SIZE])
{
for (int j = 0; j < MAX_TEACHERS; j++) {
for (int k = 0; k < IN_SIZE - 1; k++) {
in[k] = teacher[j][k];
}
for (int k = 0; k < OUT_SIZE; k++) {
// calculating the current output
double o = 0;
for (int l = 0; l < IN_SIZE; l++) {
o += weights[l][k] * in[l];
}
if (teacher[j][IN_SIZE-1] != step_func(o)) {
return false;
}
}
}
return true;
}
int main(int argc, char *argv[])
{
if (argc != 2) {
std::cerr << "usage: " << argv[0] << " inputfile" << std::endl;
exit(1);
}
double teacher[MAX_TEACHERS][IN_SIZE];
if (!read_teacher(argv[1], teacher)) {
std::cerr << "read_teacher failed" << std::endl;
exit(1);
}
double in[IN_SIZE], out[OUT_SIZE];
double weights[IN_SIZE][OUT_SIZE];
// initialize weights
for (int i = 0; i < IN_SIZE; i++) {
for (int j = 0; j < OUT_SIZE; j++) {
weights[i][j] = 0; // works only for perceptron ? (should be random numbers)
}
}
// learning
bool is_learning = true;
int num_loops = 0;
while (is_learning) {
for (int j = 0; j < MAX_TEACHERS; j++) {
for (int k = 0; k < IN_SIZE - 1; k++) {
in[k] = teacher[j][k];
}
in[IN_SIZE-1] = 1;
for (int k = 0; k < OUT_SIZE; k++) {
// calculating the current output
double o = 0;
for (int l = 0; l < IN_SIZE; l++) {
o += weights[l][k] * in[l];
}
// check if it fires or not
out[k] = step_func(o);
}
if (is_learned(teacher, in, out, weights)) {
is_learning = false;
break;
}
// update weights
for (int k = 0; k < OUT_SIZE; k++) {
for (int l = 0; l < IN_SIZE; l++) {
weights[l][k] += ETA * (teacher[j][IN_SIZE-1] - out[k]) * in[l];
}
}
}
if (++num_loops == MAX_LOOPS) {
std::cout << "not solved" << std::endl;
break;
}
}
std::cout << "num_loops: " << num_loops << std::endl;
for (int k = 0; k < OUT_SIZE; k++) {
for (int l = 0; l < IN_SIZE; l++) {
std::cout << weights[l][k] << " ";
}
std::cout << std::endl;
}
// check if learning works
for (int j = 0; j < MAX_TEACHERS; j++) {
for (int k = 0; k < IN_SIZE - 1; k++) {
in[k] = teacher[j][k];
}
for (int k = 0; k < OUT_SIZE; k++) {
// calculating the current output
double o = 0;
for (int l = 0; l < IN_SIZE; l++) {
o += weights[l][k] * in[l];
}
std::cout << "in: " << in[0] << ", " << in[1] << " - o: " << o << std::endl;
}
}
return 0;
}
connector_status_t connector_step(connector_handle_t const handle)
{
connector_status_t result = connector_init_error;
connector_data_t * const connector_ptr = handle;
ASSERT_GOTO(handle != NULL, done);
if (connector_ptr->signature != connector_signature) goto done;
switch (connector_ptr->stop.state)
{
case connector_state_running:
break;
case connector_state_stop_by_initiate_action:
if (is_connector_stopped(connector_ptr, connector_close_status_device_stopped))
{
result = connector_stop_callback(connector_ptr, connector_transport_all, connector_ptr->stop.user_context);
if (result == connector_abort)
{
goto error;
}
else if (result == connector_working)
{
connector_ptr->stop.state = connector_state_running;
}
}
break;
case connector_state_abort_by_callback:
case connector_state_terminate_by_initiate_action:
if (is_connector_stopped(connector_ptr, connector_close_status_device_terminated))
{
connector_ptr->connector_got_device_id = connector_false; /* TODO, Probably this should not be done with provisioning! */
connector_ptr->signature = NULL;
result = (connector_ptr->stop.state == connector_state_terminate_by_initiate_action) ? connector_device_terminated : connector_abort; /* ETHERIOS-EGEAR-MOD */
free_data_buffer(connector_ptr, named_buffer_id(connector_data), connector_ptr);
connector_debug_printf("connector_step: free Cloud Connector\n");
goto done;
}
break;
default:
break;
}
#if (CONNECTOR_TRANSPORT_COUNT == 1)
#if (defined CONNECTOR_TRANSPORT_TCP)
result = connector_edp_step(connector_ptr);
#endif
#if (defined CONNECTOR_TRANSPORT_UDP)
result = connector_udp_step(connector_ptr);
#endif
#if (defined CONNECTOR_TRANSPORT_SMS)
result = connector_sms_step(connector_ptr);
#endif
#else
{
#define next_network(current_network) (((current_network) == last_network_index) ? first_network_index : (connector_network_type_t) ((current_network) + 1))
connector_network_type_t const first_network_index = (connector_network_type_t) 0;
connector_network_type_t const last_network_index = (connector_network_type_t) (connector_network_count - 1);
connector_network_type_t const first_network_checked = connector_ptr->first_running_network;
connector_network_type_t current_network = first_network_checked;
do
{
connector_status_t (*step_func)(connector_data_t * const connector_ptr);
switch (current_network)
{
#if (defined CONNECTOR_TRANSPORT_TCP)
case connector_network_tcp: step_func = connector_edp_step; break;
#endif
#if (defined CONNECTOR_TRANSPORT_UDP)
case connector_network_udp: step_func = connector_udp_step; break;
#endif
#if (defined CONNECTOR_TRANSPORT_SMS)
case connector_network_sms: step_func = connector_sms_step; break;
#endif
default:
ASSERT(connector_false);
result = connector_abort;
goto error; break;
}
result = step_func(connector_ptr);
current_network = next_network(current_network);
} while ((current_network != first_network_checked) && (result == connector_idle));
connector_ptr->first_running_network = (result == connector_idle) ? next_network(first_network_checked): current_network;
#undef next_network
}
#endif
error:
switch (result)
{
case connector_abort:
abort_connector(connector_ptr);
/* no break; */
case connector_device_terminated:
result = connector_working;
break;
default:
break;
}
done:
return result;
}
