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