int main(int argc, char** argv) { BrainInt result = EXIT_SUCCESS; BrainNetwork original_network = new_network_from_context(TEST_CREATE_NETWORK); BrainNetwork loaded_network = new_network_from_context(TEST_CREATE_NETWORK); if ((original_network != NULL) && (loaded_network != NULL)) { // first serialize this network serialize_network(original_network, TEST_SERIALIZE_NETWORK_PATH); // then deserialize it deserialize_network(loaded_network, TEST_SERIALIZE_NETWORK_PATH); result = compare_networks(original_network, loaded_network); // free all memory delete_network(loaded_network); delete_network(original_network); } return result; }
/** * @brief Signal handler for qmi disconnect signal from qmi-dbus. * * Will be called, if qmi-dbus stopped. */ static void on_handle_qmi_disconnect(DBusConnection *conn, gpointer unused) { GHashTableIter iter; gpointer key, value; DBG(""); /* qmi-dbus was stopped */ qmi_service_connected = FALSE; g_hash_table_iter_init(&iter, qmi_hash); while(g_hash_table_iter_next(&iter, &key, &value) == TRUE) { /* Set all parameter to default */ struct qmi_data *qmi = (struct qmi_data *)value; if(qmi->network) connman_network_set_connected(qmi->network, FALSE); qmi->modem_opened = FALSE; qmi->modem_opening = FALSE; qmi->modem_connected = FALSE; /* Delete connman network */ delete_network(qmi); } /* Required for terminating init thread */ sem_post(&new_device_sem); pthread_join(init_modems_id, NULL); }
/** * @brief Disable qmi device and delete the associated network */ static int qmi_disable(struct connman_device *device) { int err = 0; struct qmi_data *qmi = NULL; DBG("device %p", device); g_return_val_if_fail(device, -ENODEV); qmi = connman_device_get_data(device); if(!qmi) { connman_error("Could not get device data"); return -ENODEV; } DBG("device %p data %p", device, qmi); /* Remove qmi network interface */ err = connman_inet_ifdown(qmi->index); if(err < 0) { connman_error("QMI device could not getting down with ifdown"); return err; } /* Delete associated qmi network */ delete_network(qmi); return 0; }
static int mk3_disable(struct connman_device *device) { int err = 0; struct mk3_data *mk3 = NULL; DBG("device %p", device); g_return_val_if_fail(device, -ENODEV); mk3 = connman_device_get_data(device); if(!mk3) { connman_error("Could not get device data"); return -ENODEV; } DBG("device %p data %p", device, mk3); err = connman_inet_ifdown(mk3->index); if(err < 0) { connman_error("QMI device could not getting down with ifdown"); return err; } delete_network(mk3); return 0; }
static void mk3_remove(struct connman_device *device) { struct mk3_data *mk3 = NULL; DBG("device %p", device); g_return_if_fail(device); mk3 = connman_device_get_data(device); if(!mk3) { connman_error("Could not get device data"); return; } DBG("device %p data %p", device, mk3); delete_network(mk3); connman_device_set_data(device, NULL); connman_device_unref(mk3->device); g_free(mk3->devname); g_free(mk3->group); g_free(mk3->name); g_free(mk3->ident); g_free(mk3); }
/** * @brief Remove connman network */ static void network_remove(struct connman_network *network) { struct qmi_data *qmi = NULL; DBG("network %p", network); g_return_if_fail(network); qmi = connman_network_get_data(network); if(!qmi) { connman_error("No device data available."); return; } DBG("network %p data %p", network, qmi); delete_network(qmi); }
static void network_remove(struct connman_network *network) { struct mk3_data *mk3 = NULL; DBG("network %p", network); g_return_if_fail(network); mk3 = connman_network_get_data(network); if(!mk3) { connman_error("No device data available."); return; } DBG("network %p data %p", network, mk3); delete_network(mk3); }
// ------------------- MAIN ----------------- // // ------------------------------------------ // int main(){ srand((unsigned int)time(NULL)); Vector* training_data[MAX_INPUT_LENGHT]; Vector* teaching_data[MAX_INPUT_LENGHT]; for (int i = 0; i < MAX_INPUT_LENGHT; i++) { training_data[i] = new_vec(DIMENSION_INPUT+1); teaching_data[i] = new_vec(DIMENSION_OUTPUT); } size_t TRAINING_SET_SIZE = 0; TRAINING_SET_SIZE = read_input(training_data, teaching_data); // in_layer, out_layer, hid_layer_count, hid_layers Network* network = new_network(DIMENSION_INPUT, DIMENSION_OUTPUT, 2, 4, 4); // print_network(network); Vector*** best_weights = malloc((network->hidden_layers_count+1) * sizeof(Vector**)); for (size_t layer = 0; layer < network->hidden_layers_count; layer++) { best_weights[layer] = malloc(network->hidden_layers[layer]->size * sizeof(Vector*)); for (size_t neuron_id = 0; neuron_id < network->hidden_layers[layer]->size; neuron_id++) { best_weights[layer][neuron_id] = new_vec(network->hidden_layers[layer]->neurons[neuron_id]->weights->length); } } best_weights[network->hidden_layers_count] = malloc(network->output_layer->size * sizeof(Vector*)); for (size_t neuron_id = 0; neuron_id < network->output_layer->size; neuron_id++) { best_weights[network->hidden_layers_count][neuron_id] = new_vec(network->output_layer->neurons[neuron_id]->weights->length); } time_t time_at_beginning = time(0); double total_error_old = FLOAT_MAX; double total_error = 1.0; double minimum_error_achieved = FLOAT_MAX; double epsilon = 0.0001; size_t epoch_count = 0; while ((time(0) - time_at_beginning) < 30 && (total_error = error_total(network, training_data, teaching_data, TRAINING_SET_SIZE)) > epsilon) { if (minimum_error_achieved > total_error) { minimum_error_achieved = total_error; dump_weights(network, best_weights); // print_detailed_layer(network->hidden_layers[1]); } for (size_t i = 0; i < TRAINING_SET_SIZE; i++) { train_network_with_backprop(network, training_data[i], teaching_data[i]); } if (epoch_count % 1000 == 0) { // printf("Epochs count: %ld\n",epoch_count); if (fabs(total_error - total_error_old) < 0.001) { // printf("Shaking Weights!\n"); shake_weights(network); } total_error_old = total_error; // printf("Total error: %.15lf\n", total_error); } update_learning_rate(network, ++epoch_count); scramble_data(training_data, teaching_data, TRAINING_SET_SIZE); } // printf("Network training finished with a total error: %.15lf\n", total_error); // printf("Network training achieved a minimum total error: %.15lf\n", minimum_error_achieved); // print_detailed_layer(network->hidden_layers[1]); load_weights(network, best_weights); // print_detailed_layer(network->input_layer); // print_detailed_layer(network->hidden_layers[0]); // print_detailed_layer(network->hidden_layers[1]); // print_detailed_layer(network->output_layer); test_network(network); for (size_t layer = 0; layer < network->hidden_layers_count; layer++) { for (size_t neuron_id = 0; neuron_id < network->hidden_layers[layer]->size; neuron_id++) { delete_vec(best_weights[layer][neuron_id]); } } for (size_t neuron_id = 0; neuron_id < network->output_layer->size; neuron_id++) { delete_vec(best_weights[network->hidden_layers_count][neuron_id]); } delete_network(network); for (int i = 0; i < MAX_INPUT_LENGHT; i++) { delete_vec(training_data[i]); delete_vec(teaching_data[i]); } return EXIT_SUCCESS; }
void DataStorage::update_networks(GList *a_list_networks_update, GList *a_list_object_paths_invalid) { guint length = 0, i; GList *item = NULL; INetwork *network = NULL; gchar *help; DBG3(); g_static_rw_lock_writer_lock(&networks_lock); /* delete all invalid networks from the list */ if(a_list_object_paths_invalid != NULL) { length = g_list_length(a_list_object_paths_invalid); DBG("INVALID NETWORKS '%u'", length); for(i = 0; i < length; i++) { help = (gchar *)g_list_nth_data(a_list_object_paths_invalid, i); DBG2("delete invalid network '%s'.", help); delete_network(help); g_free(help); } m_list_networks = g_list_sort(m_list_networks, sort_networks); } /* update networks and sort them */ if(a_list_networks_update != NULL) { length = g_list_length(a_list_networks_update); DBG("UPDATE NETWORKS '%u'", length); for(i = 0; i < length; i++) { network = (INetwork *)g_list_nth_data(a_list_networks_update, i); DBG2("rat '%s', strength '%u', average '%u', name'%s'.", rat2String(network->get_rat()), network->get_strength(), network->get_strength_average(), network->get_name()); item = lookup_network(network->get_object_path()); if(item != NULL) { /* network already available, just update the old one and delete the new */ INetwork *old = (INetwork *)item->data; old->update(network); delete network; } else { /* network not yet available, add new one */ m_list_networks = g_list_insert_sorted(m_list_networks, network, sort_networks); } } m_list_networks = g_list_sort(m_list_networks, sort_networks); } g_static_rw_lock_writer_unlock(&networks_lock); g_list_foreach(m_list_networks, (GFunc)print_networks, NULL); }