fmll_svm_net * fmll_svm_net_init(const unsigned num, const unsigned dim, double (** K)(const double *, const double *, const unsigned)) { unsigned u; fmll_svm ** svm; fmll_svm_net * svm_net = NULL; fmll_try; fmll_throw_null(svm_net = fmll_alloc(sizeof(fmll_svm_net), 1, 1)); fmll_throw_null(svm = svm_net->svm = (fmll_svm **) fmll_alloc(sizeof(fmll_svm *), 1, num)); svm_net->num = num; for(u = 0; u < num; u++) svm[u] = NULL; for(u = 0; u < num; u++) fmll_throw_null(svm[u] = fmll_svm_init(dim, K[u])); fmll_catch; fmll_svm_net_destroy(svm_net); svm_net = NULL; fmll_finally; return svm_net; }
fmll_pca * fmll_pca_init(const unsigned dim, const unsigned num) { double ** w; unsigned u, v; fmll_pca * pca = NULL; fmll_try; fmll_throw_if(! dim || ! num || dim < num); fmll_throw_null(pca = fmll_alloc(sizeof(fmll_pca), 1, 1)); pca->w = NULL; pca->y = NULL; pca->dim = dim; pca->num = num; fmll_throw_null(w = pca->w = (double **) fmll_alloc(sizeof(double), 2, num, dim)); fmll_throw_null(pca->y = (double *) fmll_alloc(sizeof(double), 1, num)); fmll_throw_if(fmll_math_matrix_init_fill(w, 0, num, dim)); fmll_catch; fmll_pca_destroy(pca); pca = NULL; fmll_finally; return pca; }
fmll_som * fmll_som_init(const unsigned * N, const unsigned map_dim, const unsigned dim, double (* distance_w)(const double *, const double *, const unsigned), double (* distance)(const double *, const double *, const unsigned)) { int v; unsigned u, num, * tN; double ** w, ** coord; fmll_som * som = NULL; fmll_try; fmll_throw_null(som = fmll_alloc(sizeof(fmll_som), 1, 1)); som->w = som->coord = NULL; som->N = NULL; for(u = 0, num = 1; u < map_dim; u++) num *= N[u]; fmll_throw_if(! num); fmll_throw_null(w = som->w = (double **) fmll_alloc(sizeof(double), 2, num, dim)); fmll_throw_null(coord = som->coord = (double **) fmll_alloc(sizeof(double), 2, num, map_dim)); fmll_throw_null(tN = som->N = fmll_alloc(sizeof(unsigned), 1, map_dim)); som->num = num; som->map_dim = map_dim; som->dim = dim; som->distance_w = distance_w; som->distance = distance; memset(tN, 0, map_dim * sizeof(unsigned)); fmll_throw_if(fmll_math_matrix_init_fill(w, 0, num, dim)); for(u = 0; u < num; u++) { for(v = 0; v < map_dim; v++) coord[u][v] = tN[v]; for(v = map_dim - 1; v >= 0; v--) { if(++ tN[v] < N[v]) break; tN[v] = 0; } } memcpy(tN, N, map_dim * sizeof(unsigned)); fmll_catch; fmll_som_destroy(som); som = NULL; fmll_finally; return som; }
int fmll_centering(double ** vec, const unsigned vec_num, const unsigned dim) { int ret = 0; unsigned u, v; double * mean = NULL; fmll_try; fmll_throw_null(mean = fmll_alloc(sizeof(double), 1, dim)); for(v = 0; v < dim; v++) mean[v] = 0; for(u = 0; u < vec_num; u++) for(v = 0; v < dim; v++) mean[v] += vec[u][v] / vec_num; for(u = 0; u < vec_num; u++) for(v = 0; v < dim; v++) vec[u][v] -= mean[v]; fmll_catch; ret = -1; fmll_finally; fmll_free(mean); return ret; }
fmll_som * fmll_som_load(const char * fname_prefix, double (* distance_w)(const double *, const double *, const unsigned), double (* distance)(const double *, const double *, const unsigned)) { char node_name[4096]; int map_dim, dim; unsigned u, v, num, * N = NULL; double ** w; fmll_som * som = NULL; mxml_node_t * sub_sub_node, * sub_node, * node, * content_node, * main_node = NULL; fmll_try; fmll_throw_if(xml_load(fname_prefix, TYPE_SOM, & main_node, & content_node)); fmll_throw_if(xml_get_int(content_node, "map_dim", & map_dim)); fmll_throw_if(xml_get_int(content_node, "dim", & dim)); fmll_throw_null(N = fmll_alloc(sizeof(unsigned), 1, map_dim)); fmll_throw_null(node = mxmlFindElement(content_node, content_node, "N", NULL, NULL, MXML_DESCEND_FIRST)); for(u = 0, sub_node = mxmlFindElement(node, node, NULL, NULL, NULL, MXML_DESCEND_FIRST); u < map_dim; u++) { fmll_throw_null(sub_node); N[u] = sub_node->child->value.integer; sub_node = mxmlFindElement(sub_node, node, NULL, NULL, NULL, MXML_DESCEND); } fmll_throw_null(som = fmll_som_init(N, map_dim, dim, distance_w, distance)); fmll_throw_null(node = mxmlFindElement(content_node, content_node, "W", NULL, NULL, MXML_DESCEND_FIRST)); w = som->w; num = som->num; for(u = 0; u < num; u++) { sprintf(node_name, "w_%u", u); fmll_throw_null(sub_node = mxmlFindElement(node, node, node_name, NULL, NULL, MXML_DESCEND_FIRST)); for(v = 0, sub_sub_node = mxmlFindElement(sub_node, sub_node, NULL, NULL, NULL, MXML_DESCEND_FIRST); v < dim; v++) { w[u][v] = sub_sub_node->child->value.real; sub_sub_node = mxmlFindElement(sub_sub_node, sub_node, NULL, NULL, NULL, MXML_DESCEND); } } fmll_catch; fmll_som_destroy(som); som = NULL; fmll_finally; fmll_free(N); xml_destroy(main_node); return som; }
fmll_svm_net * fmll_svm_net_load(const char * fname_prefix, double (** K)(const double *, const double *, const unsigned)) { int num; unsigned u; char node_name[4096]; fmll_svm ** svm = NULL; fmll_svm_net * svm_net = NULL; mxml_node_t * sub_node, * node, * content_node, * main_node = NULL; fmll_try; fmll_throw_null(svm_net = fmll_alloc(sizeof(fmll_svm_net), 1, 1)); fmll_throw_if(xml_load(fname_prefix, TYPE_SVM_NET, & main_node, & content_node)); fmll_throw_if(xml_get_int(content_node, "num", & num)); svm_net->num = num; fmll_throw_null(svm = svm_net->svm = (fmll_svm **) fmll_alloc(sizeof(fmll_svm *), 1, num)); fmll_throw_null(node = mxmlFindElement(content_node, content_node, "SVM", NULL, NULL, MXML_DESCEND_FIRST)); for(u = 0; u < num; u++) svm[u] = NULL; for(u = 0; u < num; u++) { sprintf(node_name, "svm_%u", u); fmll_throw_null(sub_node = mxmlFindElement(node, node, node_name, NULL, NULL, MXML_DESCEND_FIRST)); fmll_throw_null(svm[u] = fmll_svm_load_main(sub_node, K[u])); } fmll_catch; fmll_svm_net_destroy(svm_net); svm_net = NULL; fmll_finally; xml_destroy(main_node); return svm_net; }
int fmll_svm_net_teach_smo(fmll_svm_net * svm_net, const double ** vec, const unsigned * d, const unsigned vec_num, const double * C, const double * tau, int (** selector)(const fmll_svm *, const double **, const char *, const unsigned, int *, int *, const double, const double, const double, const double *, const double *, const double **), const unsigned * max_iter, const double * epsilon) { int ret = 0; const unsigned num = svm_net->num, t_num = omp_get_max_threads(); unsigned u, v, t_ind; char * t_rd, ** rd; fmll_svm ** svm = svm_net->svm; fmll_try; fmll_throw_null(rd = (char **) fmll_alloc(sizeof(char), 2, t_num, vec_num)); #pragma omp parallel private(u, v, t_ind, t_rd) default(shared) { t_ind = omp_get_thread_num(); t_rd = rd[t_ind]; for(u = t_ind; u < num; u += t_num) { for(v = 0; v < vec_num; v++) { if(d[v] == u) t_rd[v] = 1; else t_rd[v] = -1; } fmll_print("\nSupport vector machine: %u from %u (%.5f %%)\n", u + 1, num, (100 * (u + 1.0)) / num); fmll_svm_teach_smo(svm[u], (const double **) vec, t_rd, vec_num, C[u], tau[u], selector[u], max_iter[u], epsilon[u]); } } fmll_catch; ret = -1; fmll_finally; fmll_free(rd); return ret; }
int image_analysis(const int argc, const char * argv[]) { #define NUM 5 char fname[4096]; unsigned u, v, q, vec_per_class, vec_num, cl_ind, yes, res, vec_class[5], max_iter[NUM], * d, * test_d; double C[NUM], tau[NUM], epsilon[NUM], ** x, ** test_x; double (* K[NUM])(const double *, const double *, unsigned); int (* selector[NUM])(const fmll_svm *, const double **, const char *, const unsigned, int *, int *, const double, const double, const double, const double *, const double *, const double **); IplImage * src_teach, * src_test, * dst; CvSize size_teach, size_test; CvScalar pixel, pixel_white, pixel_red, pixel_green, pixel_blue, pixel_violet, pixel_black, pixel_yellow; fmll_svm_net * svm_net; /* ############################################################################ */ if(argc != 3) { /* У C90 "проблемы" с максимальной длиной строки кода */ printf("\nДемонстрация нейронной сети, состоящей из нескольких машин опорных векторов.\n\n"); printf("Запуск программы:\n\n"); printf("ex_svm_net DIR IMAGE_1\n\n"); printf("Где:\n\n"); printf("\tDIR - путь и имя каталога, в котором должны содержаться следующие файлы:\n\n"); printf("\t\tteach.png - файл с изображением, на основании которого будет составлена обучающая выборка;\n"); printf("\t\ttest.png - файл с изображением, классификация пикселей которого будет выполнена;\n\n"); printf("\tIMAGE_1 - путь и имя файла, в который будет сохранено результирующее изображение "); printf("(белый, красный, зеленый, синий, фиолетовый - правильно классифицированные пиксели; черный - неправильно классифицированные пиксели; "); printf("желтый - неклассифицированные пиксели).\n\n"); return -1; } /* ############################################################################ */ memset(vec_class, 0, sizeof(unsigned) * 5); sprintf(fname, "%s/teach.png", argv[1]); src_teach = cvLoadImage(fname, CV_LOAD_IMAGE_COLOR); size_teach = cvGetSize(src_teach); sprintf(fname, "%s/test.png", argv[1]); src_test = cvLoadImage(fname, CV_LOAD_IMAGE_COLOR); size_test = cvGetSize(src_test); dst = cvCreateImage(size_test, IPL_DEPTH_8U, 3); pixel_white.val[0] = 255; pixel_white.val[1] = 255; pixel_white.val[2] = 255; pixel_white.val[3] = 0; pixel_red.val[0] = 0; pixel_red.val[1] = 0; pixel_red.val[2] = 255; pixel_red.val[3] = 0; pixel_green.val[0] = 0; pixel_green.val[1] = 255; pixel_green.val[2] = 0; pixel_green.val[3] = 0; pixel_black.val[0] = 0; pixel_black.val[1] = 0; pixel_black.val[2] = 0; pixel_black.val[3] = 0; pixel_blue.val[0] = 255; pixel_blue.val[1] = 0; pixel_blue.val[2] = 0; pixel_blue.val[3] = 0; pixel_violet.val[0] = 255; pixel_violet.val[1] = 0; pixel_violet.val[2] = 255; pixel_violet.val[3] = 0; pixel_yellow.val[0] = 0; pixel_yellow.val[1] = 255; pixel_yellow.val[2] = 255; pixel_yellow.val[3] = 0; vec_per_class = size_teach.height * size_teach.width / 2000; vec_num = vec_per_class * 5; x = (double **) fmll_alloc(sizeof(double), 2, vec_num, 3); d = fmll_alloc(sizeof(unsigned), 1, vec_num); test_x = (double **) fmll_alloc(sizeof(double), 2, size_test.height * size_test.width, 3); test_d = fmll_alloc(sizeof(unsigned), 1, size_test.height * size_test.width); for(v = 0, q = 0; v < size_teach.height; v++) for(u = 0; u < size_teach.width; u++) { pixel = cvGet2D(src_teach, v, u); if(pixel.val[0] == 0 && pixel.val[1] == 237 && pixel.val[2] == 95) cl_ind = 0; else if(pixel.val[0] == 10 && pixel.val[1] == 169 && pixel.val[2] == 203) cl_ind = 1; else if(pixel.val[0] == 0 && pixel.val[1] == 255 && pixel.val[2] == 255) cl_ind = 2; else if(pixel.val[0] == 255 && pixel.val[1] == 0 && pixel.val[2] == 12) cl_ind = 3; else cl_ind = 4; if(vec_class[cl_ind] < vec_per_class) { x[q][0] = pixel.val[0]; x[q][1] = pixel.val[1]; x[q][2] = pixel.val[2]; d[q] = cl_ind; vec_class[cl_ind]++; q++; } } for(v = 0, q = 0; v < size_test.height; v++) for(u = 0; u < size_test.width; u++, q++) { pixel = cvGet2D(src_test, v, u); if(pixel.val[0] == 0 && pixel.val[1] == 237 && pixel.val[2] == 95) test_d[q] = 0; else if(pixel.val[0] == 10 && pixel.val[1] == 169 && pixel.val[2] == 203) test_d[q] = 1; else if(pixel.val[0] == 0 && pixel.val[1] == 255 && pixel.val[2] == 255) test_d[q] = 2; else if(pixel.val[0] == 255 && pixel.val[1] == 0 && pixel.val[2] == 12) test_d[q] = 3; else test_d[q] = 4; test_x[q][0] = pixel.val[0]; test_x[q][1] = pixel.val[1]; test_x[q][2] = pixel.val[2]; } cvReleaseImage(& src_teach); cvReleaseImage(& src_test); /* ############################################################################ */ for(u = 0; u < NUM; u++) K[u] = & fmll_kernel_radial; svm_net = fmll_svm_net_init(NUM, 3, K); /* ############################################################################ */ for(u = 0; u < NUM; u++) { C[u] = 1; tau[u] = 1E-12; selector[u] = & fmll_svm_teach_smo_selector_fan_chen_lin; max_iter[u] = 10000; epsilon[u] = 1E-3; } fmll_svm_net_teach_smo(svm_net, (const double **) x, d, vec_num, C, tau, selector, max_iter, epsilon); /* ############################################################################ */ yes = fmll_svm_net_test(svm_net, (const double **) test_x, test_d, size_test.width * size_test.height, NULL, NULL); printf("\nВерно классифицированных пикселей: %u из %u (%.7f %%)\n", yes, (size_test.width * size_test.height), (100.0 * yes) / (size_test.width * size_test.height)); /* ############################################################################ */ fmll_svm_net_save(svm_net, "svm_net"); fmll_svm_net_destroy(svm_net); svm_net = fmll_svm_net_load("svm_net", K); for(v = 0, q = 0, yes = 0; v < size_test.height; v++) for(u = 0; u < size_test.width; u++, q++) { res = fmll_svm_net_run(svm_net, test_x[q], NULL); if(res >= 0) { if(res == test_d[q]) { yes++; switch(res) { case 0: { cvSet2D(dst, v, u, pixel_white); break; } case 1: { cvSet2D(dst, v, u, pixel_red); break; } case 2: { cvSet2D(dst, v, u, pixel_green); break; } case 3: { cvSet2D(dst, v, u, pixel_blue); break; } case 4: { cvSet2D(dst, v, u, pixel_violet); break; } } } else cvSet2D(dst, v, u, pixel_black); } else if(res == -1) cvSet2D(dst, v, u, pixel_yellow); else cvSet2D(dst, v, u, pixel_black); } printf("Верно классифицированных пикселей: %u из %u (%.7f %%)\n", yes, (size_test.width * size_test.height), (100.0 * yes) / (size_test.width * size_test.height)); /* ############################################################################ */ fmll_free(x); fmll_free(d); fmll_free(test_x); fmll_free(test_d); fmll_svm_net_destroy(svm_net); cvSaveImage(argv[2], dst, NULL); cvReleaseImage(& dst); return 0; }
int main(const int argc, const char * argv[]) { const unsigned base = 256 * 256 * 256; unsigned u, v, q, cur, index_winner, N[4]; double param[2], ** vec; IplImage * src, * dst_1, * dst_2, * dst_3, * dst_4; CvSize size; CvScalar pixel; fmll_random * rnd; fmll_som * som; /* ############################################################################ */ if(argc != 6) { /* У C90 "проблемы" с максимальной длиной строки кода */ printf("\nДемонстрация самоорганизующейся карты.\n\n"); printf("Запуск программы:\n\n"); printf("ex_som IMAGE_SRC IMAGE_1 IMAGE_2 IMAGE_3 IMAGE_4\n\n"); printf("Где:\n\n"); printf("\tIMAGE_SRC - путь и имя файла с исходным изображением;\n"); printf("\tIMAGE_1 - путь и имя файла, в который будет сохранено первое результирующее изображение;\n"); printf("\tIMAGE_2 - путь и имя файла, в который будет сохранено второе результирующее изображение;\n"); printf("\tIMAGE_3 - путь и имя файла, в который будет сохранено третье результирующее изображение;\n"); printf("\tIMAGE_4 - путь и имя файла, в который будет сохранено четвертое результирующее изображение.\n\n"); return -1; } /* ############################################################################ */ src = cvLoadImage(argv[1], CV_LOAD_IMAGE_COLOR); size = cvGetSize(src); dst_1 = cvCreateImage(size, IPL_DEPTH_8U, 3); dst_2 = cvCreateImage(size, IPL_DEPTH_8U, 3); dst_3 = cvCreateImage(size, IPL_DEPTH_8U, 3); dst_4 = cvCreateImage(size, IPL_DEPTH_8U, 3); /* N[0] = 5; N[1] = 5; N[2] = 5; N[3] = 5; */ N[0] = 4; N[1] = 3; N[2] = 3; N[3] = 3; vec = (double **) fmll_alloc(sizeof(double), 2, size.height * size.width, 3); for(v = 0, q = 0; v < size.height; v++) for(u = 0; u < size.width; u++, q++) { pixel = cvGet2D(src, v, u); vec[q][0] = pixel.val[0]; vec[q][1] = pixel.val[1]; vec[q][2] = pixel.val[2]; } param[0] = 0; param[1] = 256; rnd = fmll_random_init(FMLL_RANDOM_ALGORITHM_LCG, FMLL_RANDOM_DISTRIBUTION_UNIFORM, param, time(NULL)); som = fmll_som_init(N, 4, 3, & fmll_distance_euclid, & fmll_distance_square_euclid); fmll_som_weight_init_random(som, rnd); fmll_som_so_kohonen(som, (const double **) vec, size.height * size.width, 0, & fmll_timing_next_beta_step_plus_0_1, 0.8, 0.002, & fmll_som_neighbor_wta); for(v = 0; v < som->num; v++) printf("%u = [%f, %f, %f]\n", v, som->w[v][0], som->w[v][1], som->w[v][2]); for(v = 0, q = 0; v < size.height; v++) for(u = 0; u < size.width; u++, q++) { index_winner = fmll_som_run(som, vec[q]); pixel.val[0] = som->w[index_winner][0]; pixel.val[1] = som->w[index_winner][1]; pixel.val[2] = som->w[index_winner][2]; cvSet2D(dst_1, v, u, pixel); cur = (base / ((double) som->num + 7)) * index_winner; pixel.val[0] = (cur & 0xFF0000) >> 16; pixel.val[1] = (cur & 0xFF00) >> 8; pixel.val[2] = cur & 0xFF; cvSet2D(dst_2, v, u, pixel); } fmll_som_save(som, "som"); fmll_som_destroy(som); som = NULL; if( (som = fmll_som_load("som", & fmll_distance_euclid, & fmll_distance_euclid)) != NULL ) { fmll_som_save(som, "som_2"); for(v = 0, q = 0; v < size.height; v++) for(u = 0; u < size.width; u++, q++) { index_winner = fmll_som_run(som, vec[q]); pixel.val[0] = som->w[index_winner][0]; pixel.val[1] = som->w[index_winner][1]; pixel.val[2] = som->w[index_winner][2]; cvSet2D(dst_3, v, u, pixel); cur = (base / (double) som->num) * index_winner; pixel.val[0] = (cur & 0xFF0000) >> 16; pixel.val[1] = (cur & 0xFF00) >> 8; pixel.val[2] = cur & 0xFF; cvSet2D(dst_4, v, u, pixel); } }
int fmll_som_so_kohonen_penalty(fmll_som * som, const double ** vec, const unsigned vec_num, const double beta_0, double (* next_beta)(const double), const double gamma_mult, const double gamma_add, double (* neighbor)(const fmll_som *, const double, const double, const unsigned, const unsigned), const unsigned max_win, const unsigned penalty) { int ret = 0,* wn = NULL; const unsigned num = som->num, dim = som->dim; unsigned u, v, q, index_winner; double min, d, beta_gamma, beta = beta_0, ** w = som->w; double (* distance)(const double *, const double *, unsigned) = som->distance; fmll_try; fmll_throw_if(beta_0 < 0 || beta_0 > 1); fmll_throw_if(neighbor == & fmll_som_neighbor_radial && (gamma_mult < 0 || gamma_mult > 1)); fmll_throw_if(neighbor == & fmll_som_neighbor_radial && (gamma_add < 0)); fmll_throw_null(wn = fmll_alloc(sizeof(int), 1, num)); memset(wn, 0, num * sizeof(int)); while(beta < 1.0000001) { fmll_print("Self - organization: beta == %.7lf\n", beta); for(u = 0, min = DBL_MAX; u < vec_num; u++) { for(v = 0; v < num; v++) { d = (* distance)(w[v], vec[u], dim); if(wn[v] < 0) wn[v]++; else if(d < min) { min = d; index_winner = v; } } if(++ wn[index_winner] == max_win) wn[index_winner] = - ((int) penalty); if(neighbor == & fmll_som_neighbor_wta) for(q = 0; q < dim; q++) w[index_winner][q] += beta * (vec[u][q] - w[index_winner][q]); else for(v = 0; v < num; v++) { beta_gamma = beta * neighbor(som, gamma_mult, gamma_add, index_winner, v); for(q = 0; q < dim; q++) w[v][q] += beta_gamma * (vec[u][q] - w[v][q]); } } beta = (* next_beta)(beta); } fmll_catch; ret = -1; fmll_finally; fmll_free(wn); return ret; }
Mat Kohonen::getFrame(Mat parFrame) { int map_dim=2;//размерность карты unsigned N[map_dim]; unsigned u, v, q, index_winner; N[0] = 7;//количество нейронов в каждом слое N[1] = 7; //определение константы для вывода каждого класса определенным цветом uint32_t A=1; for (int i=0;i<map_dim; i++) { A*=N[i];//подсчет общего числа нейрнов } A=0xFFFFFF/A; fmll_som * som; Mat resultFrame; resultFrame.create(parFrame.rows, parFrame.cols,CV_8UC3); Mat frameFromUnsigned; frameFromUnsigned.create(parFrame.rows, parFrame.cols,CV_32S); Vec3b pixel; double ** vec; //инициализация векторного пространства значениями яркости изображения vec = (double **) fmll_alloc(sizeof(double), 2, parFrame.rows * parFrame.cols, 3); som = fmll_som_load(somFilename.c_str(),& fmll_distance_euclid, & fmll_distance_euclid); for(v = 0, q = 0; v < parFrame.rows; v++) for(u = 0; u < parFrame.cols; u++, q++) { pixel=parFrame.at<Vec3b>(v,u); vec[q][0] = pixel[0] / 255.; vec[q][1] = pixel[1] / 255.; vec[q][2] = pixel[2] / 255.; } //загрузка карты из xml if(som == NULL) { fmll_random * rnd; double param[2]; param[0] = 0; param[1] = 0.01; //инициализация датчика случайных чисел rnd = fmll_random_init(FMLL_RANDOM_ALGORITHM_LCG, FMLL_RANDOM_DISTRIBUTION_UNIFORM, param, time(NULL)); //иницилизация нейронной карты som = fmll_som_init(N, map_dim, 3, & fmll_distance_euclid, & fmll_distance_euclid);//(1)расстояние между векторами, 2)расстояние между нейронами.(2)не исп.,т.к. алгоритм WTA) //иницилизация весов синапсов нейронов карты случайными числами fmll_som_weight_init_random(som, rnd); cout<<"don't load"<<endl; //обучение нейронной карты fmll_som_so_kohonen(som, (const double **) vec, parFrame.rows * parFrame.cols, 0.3, & fmll_timing_next_beta_step_plus_0_1, 0.8, 0.002, & fmll_som_neighbor_wta); if (fmll_som_save(som,somFilename.c_str())!=0) { cout<<"Ошибка сохранения Som в Xml"<<endl; } fmll_random_destroy(rnd); } for(v = 0, q = 0; v < parFrame.rows; v++) { for(u = 0; u < parFrame.cols; u++, q++) { index_winner = fmll_som_run(som, vec[q]); uint32_t color=A*index_winner; pixel[0]=0x0000FF&color; pixel[1]=(0x00FF00&color)>>8; pixel[2]=(0xFF0000&color)>>16; //pixel[0] = som->w[index_winner][0]; //pixel[1] = som->w[index_winner][1]; //pixel[2] = som->w[index_winner][2]; resultFrame.at<Vec3b>(v,u)=pixel; frameFromUnsigned.at<uint32_t>(v,u)=color; //cout<<color<<" "; } //cout<<endl; } fmll_free(vec); imshow( "kohonen", resultFrame ); fmll_som_destroy(som); return frameFromUnsigned; }
int fmll_pca_so(fmll_pca * pca, const double ** vec, const unsigned vec_num, const double beta_0, double (* next_beta)(const double), const double max_d, double * eigen) { int ret = 0; const unsigned dim = pca->dim, num = pca->num; unsigned t, u, v, q, iter = 0; double d, sum, beta, max = 0, * y = pca->y, ** fcrow = NULL, ** w = pca->w, * pw = NULL, * yy = NULL, * yy_w = NULL; fmll_try; fmll_throw_if(beta_0 < 0 || beta_0 > 1); fmll_throw_null(pw = (double *) fmll_alloc(sizeof(double), 1, dim)); fmll_throw_null(yy = (double *) fmll_alloc(sizeof(double), 1, num)); fmll_throw_null(yy_w = (double *) fmll_alloc(sizeof(double), 1, dim)); for(u = 0; u < num; u++) { beta = beta_0; do { fmll_print("Iteration = %u, component = %u, beta = %.7lf, max = %.7lf\n", iter, u + 1, beta, max); beta = (* next_beta)(beta); memcpy((void *) pw, (void *) w[u], dim * sizeof(double)); for(t = 0; t < vec_num; t ++) { fmll_pca_run(pca, vec[t]); for(v = 0; v < dim; v ++) { for(q = 0, sum = 0; q <= u; q ++) sum += y[q] * w[q][v]; yy_w[v] = sum; } for(v = 0; v < dim; v ++) w[u][v] += beta * y[u] * (vec[t][v] - yy_w[v]); } for(v = 0, max = 0; v < dim; v ++) if(max < (d = fabs(w[u][v] - pw[v]))) max = d; iter ++; } while(max > max_d && beta > 0); } if(eigen != NULL) { fmll_throw_null(fcrow = (double **) fmll_alloc(sizeof(double), 2, dim, dim)); for(v = 0; v < dim; v++) for(u = 0; u < dim; u++) fcrow[v][u] = 0; for(v = 0; v < vec_num; v++) for(t = 0; t < dim; t++) { fcrow[t][t] += vec[v][t] * vec[v][t]; for(q = t + 1; q < dim; q++) { d = vec[v][t] * vec[v][q]; fcrow[t][q] += d; fcrow[q][t] += d; } } for(v = 0; v < dim; v++) for(u = 0; u < dim; u++) fcrow[v][u] /= vec_num; for(t = 0; t < num; t++) { eigen[t] = 0; for(u = 0; u < dim; u++) { for(v = 0, sum = 0; v < dim; v++) sum += w[t][v] * fcrow[u][v]; eigen[t] += sum * sum; } eigen[t] = sqrt(eigen[t]); } } fmll_catch; ret = -1; fmll_finally; fmll_free(fcrow); fmll_free(pw); fmll_free(yy); fmll_free(yy_w); return ret; }