int main(int argc, char **argv) { int i; int errors; DataSet *train_set; DataSet *test_set; Network *adultnn = create_network(14); double e; double acc; Class predicted, desired; // training train_set = read_dataset("adult.train"); if (train_set == NULL) { fprintf(stderr, "Error reading training set\n"); exit(1); } add_layer(adultnn, 28); // hidden layer add_layer(adultnn, 2); // output layer initialize_weights(adultnn, SEED); print_network_structure(adultnn); printf("Training network with %d epochs...\n", EPOCHS); e = batch_train(adultnn, train_set, LEARNING_RATE, EPOCHS, sigmoid, dsigmoid); printf("Training finished, approximate final SSE: %f\n", e); print_network_structure(adultnn); // testing test_set = read_dataset("adult.test"); if (test_set == NULL) { fprintf(stderr, "Error reading test set\n"); exit(1); } errors = 0; printf("Testing with %d cases...\n", test_set->n_cases); for (i = 0; i < test_set->n_cases; ++i) { predicted = predict_class(adultnn, test_set->input[i]); desired = output_to_class(test_set->output[i]); if (predicted != desired) ++errors; printf("Case %d | predicted: %s, desired: %s, outputs: %4.3f %4.3f \n", i, class_to_string(predicted), class_to_string(desired), adultnn->output_layer->y[0], adultnn->output_layer->y[1]); } acc = 100.0 - (100.0 * errors / test_set->n_cases); printf("Testing accuracy: %f\n", acc); printf("Total classificarion errors: %d\n", errors); destroy_dataset(train_set); destroy_dataset(test_set); return 0; }
H5Converter::H5Converter(const std::string& h5_fname, const std::string& out_dir) : out_dir_(out_dir) { file_id_ = H5Fopen(h5_fname.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT); root_ = H5Gopen(file_id_, "/", H5P_DEFAULT); aux_ = H5Gopen(file_id_, "/aux", H5P_DEFAULT); // <aux info> // read target ids read_dataset(aux_, "ids", targ_ids_); std::cerr << "[h5dump] number of targets: " << targ_ids_.size() << std::endl; n_targs_ = targ_ids_.size(); read_dataset(aux_, "lengths", lengths_); assert( n_targs_ == lengths_.size() ); read_dataset(aux_, "eff_lengths", eff_lengths_); assert( n_targs_ == eff_lengths_.size() ); // read bootstrap info std::vector<int> n_bs_vec; read_dataset(aux_, "num_bootstrap", n_bs_vec); n_bs_ = n_bs_vec[0]; std::cerr << "[h5dump] number of bootstraps: " << n_bs_ << std::endl; // </aux info> if (n_bs_ > 0) { bs_ = H5Gopen(file_id_, "/bootstrap", H5P_DEFAULT); } std::vector<std::string> tmp; read_dataset(aux_, "kallisto_version", tmp); kal_version_ = tmp[0]; tmp.clear(); std::cerr << "[h5dump] kallisto version: " << kal_version_ << std::endl; std::vector<int> idx_version; read_dataset(aux_, "index_version", idx_version); idx_version_ = static_cast<size_t>(idx_version[0]); std::cerr << "[h5dump] index version: " << idx_version_ << std::endl; read_dataset(aux_, "start_time", tmp); start_time_ = tmp[0]; tmp.clear(); std::cerr << "[h5dump] start time: " << start_time_ << std::endl; read_dataset(aux_, "call", tmp); call_ = tmp[0]; tmp.clear(); std::cerr << "[h5dump] shell call: " << call_ << std::endl; alpha_buf_.resize( n_targs_, 0.0 ); assert( n_targs_ == alpha_buf_.size() ); tpm_buf_.resize( n_targs_, 0.0 ); assert( n_targs_ == tpm_buf_.size() ); }
typename boost::enable_if<is_multi_array<T>, void>::type read_dataset(dataset & data_set, T & array, slice const& file_slice) { // --- create memory dataspace for the complete input array h5xx::dataspace memspace = h5xx::create_dataspace(array); // --- create file dataspace and select the slice (hyperslab) from it h5xx::dataspace filespace(data_set); filespace.select(file_slice); // --- read_dataset(data_set, array, memspace, filespace); }
static int read_sensor_altitude(void *user_data, harp_array data) { ingest_info *info = (ingest_info *)user_data; if (read_dataset(info->geo_data_cursor, "satellite_altitude", info->num_scanlines, data) != 0) { return -1; } broadcast_array_float(info->num_scanlines, info->num_pixels, data.float_data); return 0; }
floatingtype_t read_floatingtype(hid_t loc_id, const char *path) { floatingtype_t ft; ft.floatingtype = get_type_ft(loc_id, path); if (ft.floatingtype == E_SINGLE_REAL) ft.singlereal = read_singlereal(loc_id, path); else if (ft.floatingtype == E_SINGLE_COMPLEX) ft.singlecomplex = read_singlecomplex(loc_id, path); else if (ft.floatingtype == E_VECTOR) ft.vector = read_vector(loc_id, path); else if (ft.floatingtype == E_DATA_SET) ft.dataset = read_dataset(loc_id, path); else if (ft.floatingtype == E_ARRAY_SET) ft.arrayset = read_arrayset(loc_id, path); return ft; }
/* * This recursive function opens all the groups in vertical direction and * checks the data. */ void recursive_read_group(hid_t memspace, hid_t filespace, hid_t gid, int counter) { hid_t child_gid; int mpi_rank, err_num=0; char gname[64]; MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank); #ifdef BARRIER_CHECKS if((counter+1) % 10) MPI_Barrier(MPI_COMM_WORLD); #endif /* BARRIER_CHECKS */ if( (err_num = read_dataset(memspace, filespace, gid)) ) nerrors += err_num; if( counter < GROUP_DEPTH ) { sprintf(gname, "%dth_child_group", counter+1); child_gid = H5Gopen(gid, gname); VRFY((child_gid>0), gname); recursive_read_group(memspace, filespace, child_gid, counter+1); H5Gclose(child_gid); } }
void H5Converter::rw_from_counts(hid_t group_id, const std::string& count_name, const std::string& out_fname) { std::vector<double> alpha; read_dataset(group_id, count_name.c_str(), alpha); plaintext_writer(out_fname, targ_ids_, alpha, eff_lengths_, lengths_); }
typename boost::enable_if<is_multi_array<T>, void>::type read_dataset(h5xxObject const& object, std::string const& name, T & array, slice const& file_slice) { dataset data_set(object, name); read_dataset(data_set, array, file_slice); }
static int read_viewing_zenith_angle(void *user_data, harp_array data) { ingest_info *info = (ingest_info *)user_data; return read_dataset(info->geo_data_cursor, "viewing_zenith_angle", info->num_scanlines * info->num_pixels, data); }
static int read_latitude_bounds(void *user_data, harp_array data) { ingest_info *info = (ingest_info *)user_data; return read_dataset(info->geo_data_cursor, "latitude_bounds", info->num_scanlines * info->num_pixels * 4, data); }
static int read_longitude(void *user_data, harp_array data) { ingest_info *info = (ingest_info *)user_data; return read_dataset(info->geo_data_cursor, "longitude", info->num_scanlines * info->num_pixels, data); }
/* * This function is to verify the data from multiple group testing. It opens * every dataset in every group and check their correctness. * * Changes: Updated function to use a dynamically calculated size, * instead of the old SIZE #define. This should allow it * to function with an arbitrary number of processors. * * JRM - 8/11/04 */ void multiple_group_read(void) { int mpi_rank, mpi_size, error_num, size; int m; hbool_t use_gpfs = FALSE; char gname[64]; hid_t plist, fid, gid, memspace, filespace; hsize_t chunk_origin[DIM]; hsize_t chunk_dims[DIM], file_dims[DIM], count[DIM]; const H5Ptest_param_t *pt; char *filename; int ngroups; pt = GetTestParameters(); filename = pt->name; ngroups = pt->count; MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank); MPI_Comm_size(MPI_COMM_WORLD, &mpi_size); size = get_size(); plist = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type, use_gpfs); fid = H5Fopen(filename, H5F_ACC_RDONLY, plist); H5Pclose(plist); /* decide hyperslab for each process */ get_slab(chunk_origin, chunk_dims, count, file_dims, size); /* select hyperslab for memory and file space */ memspace = H5Screate_simple(DIM, file_dims, NULL); H5Sselect_hyperslab(memspace, H5S_SELECT_SET, chunk_origin, chunk_dims, count, chunk_dims); filespace = H5Screate_simple(DIM, file_dims, NULL); H5Sselect_hyperslab(filespace, H5S_SELECT_SET, chunk_origin, chunk_dims, count, chunk_dims); /* open every group under root group. */ for(m=0; m<ngroups; m++) { sprintf(gname, "group%d", m); gid = H5Gopen(fid, gname); VRFY((gid > 0), gname); /* check the data. */ if(m != 0) if( (error_num = read_dataset(memspace, filespace, gid))>0) nerrors += error_num; /* check attribute.*/ error_num = 0; if( (error_num = read_attribute(gid, is_group, m))>0 ) nerrors += error_num; H5Gclose(gid); #ifdef BARRIER_CHECKS if(!((m+1)%10)) MPI_Barrier(MPI_COMM_WORLD); #endif /* BARRIER_CHECKS */ } /* open all the groups in vertical direction. */ gid = H5Gopen(fid, "group0"); VRFY((gid>0), "group0"); recursive_read_group(memspace, filespace, gid, 0); H5Gclose(gid); H5Sclose(filespace); H5Sclose(memspace); H5Fclose(fid); }