def plot_nmi_max(labels, pos, savepath): """ plot nmi_max distribution of given library Parameters ---------- :param labels: :param pos: :param savepath: """ texts = [] colors = [] plot_labels = [None] * (len(labels) - _ADDITIONAL_RANGE) markers = ['o'] * (len(labels) - _ADDITIONAL_RANGE) for label in labels[0:-1]: cons = Metrics.normalized_max_mutual_info_score(label, labels[-1]) texts.append(cons) cNorm = colors2.Normalize(vmin=min(texts[0:-_ADDITIONAL_RANGE+1]), vmax=max(texts[0:-_ADDITIONAL_RANGE+1])) scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=plt.get_cmap('CMRmap')) plot_labels.extend(_ADDITIONAL_NAMES) for text in texts[0:-_ADDITIONAL_RANGE+1]: colors.append(scalarMap.to_rgba(text)) texts = map(_round_digits, texts) texts.extend(_ADDITIONAL_NAMES[-1:]) colors.extend(_ADDITIONAL_COLORS) markers.extend(_ADDITIONAL_MARKERS) title = 'NMI distribution, ' + 'Max val = ' + str(max(texts[0:-_ADDITIONAL_RANGE])) +\ ' ,Min k = ' + str(min(texts[0:-_ADDITIONAL_RANGE])) _plot_generalized_scatter(pos, colors, texts, markers, plot_labels, savepath, title=title) return
def comparison_ensemble_methods(dataset_name, library_name, eval_method=None): """ get the performance of comparison methods (ensemble) :param dataset_name: :param library_name: :param eval_method: :return: """ filename = _default_eval_path + dataset_name + '_ensemble_eval_' + time.strftime( '%Y-%m-%d_%H_%M_%S', time.localtime(time.time())) + '.csv' lib = np.loadtxt(_default_library_path + dataset_name + '/' + library_name + '.res', delimiter=',') with open(filename, 'wb') as f: writer = csv.writer(f) writer.writerow(library_name) data, targets = exd.dataset[dataset_name]['data']() k = exd.dataset[dataset_name]['k'] eval_methods = _default_ensemble_eval_methods if eval_method is None else eval_method print '[Ensemble Comparison]: Dataset: ' + str(dataset_name) print '[Ensemble Comparison]: Library: ' + str(library_name) print '[Ensemble Comparison]: Comparison Methods: ' + str(eval_methods) print '[Ensemble Comparison]: Real k is ' + str(k) for method in eval_methods: ensemble_label = _ensemble_methods[method](lib, N_clusters_max=k) performance = metrics.normalized_max_mutual_info_score( targets, ensemble_label) writer.writerow([method, str(performance)]) return
def expected_consistency_selection_ensemble( labels, class_num, target, mlset, nlset, cons_type='must', ensemble_methods=_default_ensemble_methods, ease_factor=1): selected_labels = _expected_consistency_selection(labels, mlset, nlset, cons_type=cons_type, ease_factor=ease_factor) retVals = [] retVals.append(ease_factor) retVals.append(selected_labels.shape[0]) print('[INFO] Selected Solutions:' + str(selected_labels.shape[0])) for method in ensemble_methods: ensemble_labels = _ensemble_method[method](selected_labels, N_clusters_max=class_num) ensemble_nmi = Metrics.normalized_max_mutual_info_score( ensemble_labels, target) retVals.append(ensemble_nmi) print('[INFO] Ensemble Method:' + method) print('[INFO] Performance:' + str(ensemble_nmi)) return retVals
def evaluate_library(name, path, class_num, target, evaluate_methods=_default_evaluate_methods): """ do evaluation for a given library :param name: name of the library :param path: path where the library is :param class_num: #real_classes :param target: real class label :param evaluate_methods: consensus functions used for evaluation Return ------ :return: score of all consensus functions in a list """ labels = np.loadtxt(path + name, delimiter=',') if not name.endswith('_pure.res'): labels = labels[0:-5] scores = [] for method in evaluate_methods: ensemble_label = _ensemble_method[method](labels, N_clusters_max=class_num) scores.append( Metrics.normalized_max_mutual_info_score(target, ensemble_label)) return scores
def do_propagation_ensemble(library_folder, library_name, class_num, target, constraint_file, logger, alphas, have_zero=True, ensemble_method=_default_ensemble_method): logger.debug( '===========================================================================================' ) logger.debug('-----------------Propagation Ensemble for library:' + str(library_name) + '----------------') logger.debug('-----------------Have zero type = ' + str(have_zero) + '-----------------------------------') logger.debug('-----------------Constraint File name = ' + constraint_file + '----------------------------') labels = np.loadtxt(library_folder + library_name + '.res', delimiter=',') labels = labels.astype(int) ml, cl = io_func.read_constraints(constraint_file) hyperedges = ce.build_hypergraph_adjacency(labels) hyperedges = hyperedges.transpose() coas_matrix = hyperedges.dot(hyperedges.transpose()) coas_matrix = np.squeeze(np.asarray(coas_matrix.todense())) coas_matrix = coas_matrix.astype(np.float32) coas_matrix /= np.max(coas_matrix) print coas_matrix nmis = [] for alpha in alphas: logger.debug( '-------------------------->>>>>> PARAM START <<<<<<<---------------------------------' ) propagated_coas_matrix = propagation_on_coassociation_matrix( coas_matrix, ml, cl, alpha) cur_nmis = [] for method in ensemble_method: ensemble_label = _ensemble_method[method](propagated_coas_matrix, labels.shape[0], class_num) ensemble_nmi = Metrics.normalized_max_mutual_info_score( ensemble_label, target) logger.debug(method + ' alpha=' + str(alpha) + ', NMI=' + str(ensemble_nmi)) cur_nmis.append(ensemble_nmi) nmis.append(cur_nmis) logger.debug( '------------------------->>>>>> END OF THIS PARAM <<<<<<------------------------------' ) logger.debug( '===========================================================================================' ) return nmis
def k_selection_ensemble(labels, k_threshold, logger, weighted=False, alpha=0, mlset=None, nlset=None, ctype='both'): """ do selection ensemble using k as criteria clusteing with k smaller than k_threshold will be removed :param labels: :param k_threshold: :param logger: :param weighted: weighted version or not :param alpha: balance factor that control the importance of clustering/cluster consistency in weights (weighted version only) :param mlset: cannot-link set (weighted version only) :param nlset: must-link set (weighted version only) :param ctype: type of consistency (weighted version only) :return: """ k_value = [] class_num = len(np.unique(labels[-1])) # select those clusterings that k larger than the threshold. for label in labels[0:-5]: k_value.append(len(np.unique(label))) k_value = np.array(k_value) idx = k_value.ravel() >= k_threshold selected_labels = labels[0:-5][idx] # weights con_per_cluster = [] con_clustering = [] if weighted: for label in selected_labels: con_per_cluster.append( Metrics.consistency_per_cluster(label, mlset, nlset, cons_type=ctype)) for label in selected_labels: con_clustering.append( Metrics.consistency(label, mlset, nlset, cons_type=ctype)) logger.debug('[K] Start consensus...shape=' + str(selected_labels.shape)) logger.debug('[K] Average k is ' + str(np.mean(k_value[idx]))) if weighted: logger.debug('[K] weighted consensus, alpha=' + str(alpha)) label_CSPA = ce.cluster_ensembles_CSPAONLY( selected_labels, N_clusters_max=class_num, weighted=weighted, clustering_weights=con_clustering, cluster_level_weights=con_per_cluster, alpha=alpha) label_HGPA = ce.cluster_ensembles_HGPAONLY( selected_labels, N_clusters_max=class_num, weighted=weighted, clustering_weights=con_clustering, cluster_level_weights=con_per_cluster, alpha=alpha) label_MCLA = ce.cluster_ensembles_MCLAONLY( selected_labels, N_clusters_max=class_num, weighted=weighted, clustering_weights=con_clustering, cluster_level_weights=con_per_cluster, alpha=alpha) nmi_CSPA = Metrics.normalized_max_mutual_info_score(label_CSPA, labels[-1]) nmi_HGPA = Metrics.normalized_max_mutual_info_score(label_HGPA, labels[-1]) nmi_MCLA = Metrics.normalized_max_mutual_info_score(label_MCLA, labels[-1]) logger.debug('CSPA performance:' + str(nmi_CSPA)) logger.debug('HGPA performance:' + str(nmi_HGPA)) logger.debug('MCLA performance:' + str(nmi_MCLA)) logger.debug('--------------------------------------------') return
def consistency_selection_ensemble(labels, mlset, nlset, logger, must_threshold, cannot_threshold, normalized=True, weighted=False, weighted_type='both', alpha=1): """ do selection ensemble using must/cannot consistency as criteria clusteing with k smaller than k_threshold will be removed :param labels: :param mlset: :param nlset: :param logger: :param must_threshold: :param cannot_threshold: :param normalized: :param weighted: :param weighted_type: :param alpha: :return: """ class_num = len(np.unique(labels[-1])) must_consistencies = [] cannot_consistencies = [] clustering_weights = [] cluster_level_weights = [] k_value = [] for label in labels[0:-5]: must_cons = Metrics.consistency(label, mlset, nlset, cons_type='must') cannot_cons = Metrics.consistency(label, mlset, nlset, cons_type='cannot') if weighted: clustering_weights.append( Metrics.consistency(label, mlset, nlset, cons_type=weighted_type)) cluster_level_weights.append( Metrics.consistency_per_cluster(label, mlset, nlset, cons_type=weighted_type)) must_consistencies.append(must_cons) cannot_consistencies.append(cannot_cons) k_value.append(len(np.unique(label))) if normalized: scaler = preprocessing.MinMaxScaler() must_consistencies = scaler.fit_transform( np.array(must_consistencies).reshape(-1, 1)).ravel() cannot_consistencies = scaler.fit_transform( np.array(cannot_consistencies).reshape(-1, 1)).ravel() idx = np.logical_and(must_consistencies >= must_threshold, cannot_consistencies >= cannot_threshold) selected_labels = labels[0:-5][idx] k_value = np.array(k_value)[idx] logger.debug('[Consistency] Start consensus...shape=' + str(selected_labels.shape)) if selected_labels.shape[0] == 0: logger.debug('[Consistency] No clusterings are selected. Out.') return logger.debug('[Consistency] Average k is ' + str(np.mean(k_value))) label_CSPA = ce.cluster_ensembles_CSPAONLY( selected_labels, N_clusters_max=class_num, weighted=weighted, clustering_weights=clustering_weights, cluster_level_weights=cluster_level_weights, alpha=alpha) label_HGPA = ce.cluster_ensembles_HGPAONLY( selected_labels, N_clusters_max=class_num, weighted=weighted, clustering_weights=clustering_weights, cluster_level_weights=cluster_level_weights, alpha=alpha) label_MCLA = ce.cluster_ensembles_MCLAONLY(selected_labels, N_clusters_max=class_num) nmi_CSPA = Metrics.normalized_max_mutual_info_score(label_CSPA, labels[-1]) nmi_HGPA = Metrics.normalized_max_mutual_info_score(label_HGPA, labels[-1]) nmi_MCLA = Metrics.normalized_max_mutual_info_score(label_MCLA, labels[-1]) logger.debug('CSPA performance:' + str(nmi_CSPA)) logger.debug('HGPA performance:' + str(nmi_HGPA)) logger.debug('MCLA performance:' + str(nmi_MCLA)) return
import member_generation.library_generation as lg import utils.io_func as io import utils.settings as settings import ensemble.Cluster_Ensembles as ce import evaluation.Metrics as metrics # 导入数据集,目前我有使用过的数据集都在utils.load_dataset模块中封装成函数了 # 调用时返回两个量,其一是特征矩阵,尺寸是(#Instances * #Features) # 部分数据集内置了一些参数,如进行0-1规范化等,自行查看 name = 'Iris' d, t = ld.load_iris() # 生成聚类成员集的函数我都包装在member_generation.library_generation中 # 主要函数是generate_library,它可以提供random-subspace的聚类成员集生成 # 以及半监督的聚类成员集(目前有E2CP和COP_KMEANS两种半监督聚类方法)的生成 # 该函数返回的是library的名字,实际library保存在Results/[数据集名字]/ # 具体参数,请见函数注释说明,可能写的比较乱,如果不太明白再问 # p.s. 如果使用random-subspace的方式生成聚类成员,其生成方法主要是对样本or特征的随机采样 # 具体函数封装在member_generation.subspace中,library_generation进行调用 lib_name = lg.generate_library(d, t, name, 10, 3) # 根据名字读入,这里读进来的是一个(#members * #instances)的矩阵 lib = io.read_matrix(settings.default_library_path + name + '/' + lib_name) # 进行ensemble,这里ensemble返回的是集成之后的簇标签 ensemble_result = ce.cluster_ensembles_CSPAONLY(lib, N_clusters_max=3) # print出来看看 print ensemble_result print metrics.normalized_max_mutual_info_score(t, ensemble_result)
# print '--------------------' # for doo in data_selected.as_matrix(): # print doo d, t = ed.dataset['waveform']['data']() # d, t = ed.dataset['Wap']['data'](sparse_type='csr') # d, t = ed.dataset['k1b']['data']() # d, t = ed.dataset['hitech']['data']() # d, t = ed.dataset['re0']['data']() print d.shape print np.unique(t) km = cluster.KMeans(n_clusters=3) t1 = time.clock() km.fit(d) t2 = time.clock() print metrics.normalized_max_mutual_info_score(t, km.labels_) # metrics print t2 - t1 # import member_generation.subspace as sub # subd = sub.feature_sampling(d, 2000) # print d.shape # print subd.shape # data_selected, data_unselected, \ # target_selected, target_unselected = train_test_split(d, t, # train_size=500, # random_state=154) # print data_selected # print data_unselected # print target_selected # print target_unselected # print d
import constrained_methods.constrained_clustering as cc import utils.load_dataset as ld import utils.io_func as io import time import evaluation.Metrics as Metrics data, target = ld.load_mnist_4000() print data.shape data = data.astype(float) ml, cl = io.read_constraints('Constraints/MNIST4000_diff_n_1.txt') t1 = time.clock() e2cp = cc.E2CP(data=data, ml=ml, cl=cl, n_clusters=10) t2 = time.clock() e2cp.fit_constrained() print e2cp.labels print Metrics.normalized_max_mutual_info_score(target, e2cp.labels) print t2 - t1
def comparison_methods(dataset_name, constraints_files=None, additional_postfix='', eval_method=None): """ get the performance of comparison methods. Parameters ---------- :param dataset_name: :param constraints_files: :param additional_postfix: :param eval_method: """ filename = _default_eval_path + dataset_name + '_' + time.strftime( '%Y-%m-%d_%H_%M_%S', time.localtime(time.time())) + '.csv' with open(filename, 'wb') as f: writer = csv.writer(f) data, targets = exd.dataset[dataset_name]['data']() data = data.astype(np.double) k = exd.dataset[dataset_name]['k'] km = cluster.KMeans(n_clusters=k) km.fit(data) writer.writerow([ 'KMeans', str(metrics.normalized_max_mutual_info_score(targets, km.labels_)) ]) eval_methods = _default_eval_methods if eval_method is None else eval_method if constraints_files is None: filenames = _get_default_constraints_files( dataset_name, _default_constraints_postfix, additional_postfix) else: filenames = _get_default_constraints_files(dataset_name, constraints_files, additional_postfix) for filename in filenames: ml, cl = io_func.read_constraints(_default_constraints_folder + filename + '.txt') for method in eval_methods: if method == 'Cop_KMeans': result = _constrained_methods[method](data, k, ml, cl) writer.writerow([ filename + '_Cop_KMeans', str( metrics.normalized_max_mutual_info_score( targets, result)) ]) elif method == 'E2CP': e2cp = _constrained_methods[method](data=data, ml=ml, cl=cl, n_clusters=k) e2cp.fit_constrained() result = e2cp.labels writer.writerow([ filename + '_E2CP', str( metrics.normalized_max_mutual_info_score( targets, result)) ]) return
def do_new_weighted_ensemble_for_library( library_folder, library_name, class_num, target, constraint_file, logger, gammas, internals=None, cons_type='both', ensemble_method=_default_ensemble_method, scale=False): """ :param library_folder: :param library_name: :param class_num: :param target: :param constraint_file: :param logger: :param alphas: :param cons_type: :param ensemble_method :return: """ logger.debug( '===========================================================================================' ) logger.debug('-----------------New ver Weighted Ensemble for library:' + str(library_name) + '---------------') logger.debug('-----------------Weight type = ' + cons_type + '-------------------------------------------') logger.debug('-----------------Scale type = ' + str(scale) + '-------------------------------------------') logger.debug('-----------------Constraint File name = ' + constraint_file + '----------------------------') labels = np.loadtxt(library_folder + library_name + '.res', delimiter=',') labels = labels.astype(int) # if the library is not pure, i.e, ensemble results and targets are also included. # then, last 5 rows should be removed (single kmeans, cspa, hgpa, mcla, real labels) if 'pure' not in library_name: labels = labels[0:-5] mlset, nlset = io_func.read_constraints(constraint_file) n_instances = labels.shape[1] if cons_type == 'both': n_constraints = len(mlset) + len(nlset) else: n_constraints = len(mlset) if internals is None: internals = _build_pesudo_internal(labels) # get cluster/clustering level weights # constraints in each cluster of all clusterings are also obtained to get g_gamma con_per_cluster = [] constraints_num = [] con_clustering = [] cluster_time_sum = 0.0 clustering_time_sum = 0.0 for label in labels: t1 = time.clock() weight, cluster_cons_num = Metrics.consistency_per_cluster_efficient( label, mlset, nlset, cons_type=cons_type) con_per_cluster.append(weight) constraints_num.append(cluster_cons_num) t2 = time.clock() cluster_time_sum += (t2 - t1) for label in labels: t1 = time.clock() con_clustering.append( Metrics.consistency(label, mlset, nlset, cons_type=cons_type)) t2 = time.clock() clustering_time_sum += (t2 - t1) print 'library size=' + str(labels.shape[0]) print 'cluster avg=' + str(cluster_time_sum / labels.shape[0]) print 'clustering avg=' + str(clustering_time_sum / labels.shape[0]) if scale: scaler = preprocessing.MinMaxScaler() con_clustering = scaler.fit_transform(np.array(con_clustering)) nmis = [] for gamma in gammas: logger.debug( '-------------------------->>>>>> PARAM START <<<<<<<---------------------------------' ) cur_g_gamma = get_g_gamma(constraints_num, labels, n_constraints, n_instances, gamma) cur_nmis = [] for method in ensemble_method: ensemble_labels = _ensemble_method[method]( labels, N_clusters_max=class_num, weighted=True, clustering_weights=con_clustering, cluster_level_weights=con_per_cluster, alpha=cur_g_gamma, new_formula=True, internal=internals) # ensemble_labels = _ensemble_method[method](labels, N_clusters_max=class_num, # weighted=True, clustering_weights=con_clustering, # cluster_level_weights=con_per_cluster, alpha=cur_g_gamma, # new_formula=True, internal=internals, ml=mlset, cl=nlset) ensemble_nmi = Metrics.normalized_max_mutual_info_score( ensemble_labels, target) logger.debug(method + ' gamma=' + str(gamma) + ', NMI=' + str(ensemble_nmi)) cur_nmis.append(ensemble_nmi) nmis.append(cur_nmis) logger.debug( '------------------------->>>>>> END OF THIS PARAM <<<<<<-------------------------------' ) logger.debug( '===========================================================================================' ) return nmis
def do_7th_weighted_ensemble_for_library( library_folder, library_name, class_num, target, constraint_file, logger, alphas, internals, cons_type='both', ensemble_method=_default_ensemble_method, scale=False): """ :param library_folder: :param library_name: :param class_num: :param target: :param constraint_file: :param logger: :param alphas: :param cons_type: :param ensemble_method :return: """ logger.debug( '===========================================================================================' ) logger.debug('-----------------New Weighted Ensemble for library:' + str(library_name) + '-------------------') logger.debug('-----------------Weight type = ' + cons_type + '-------------------------------------------') logger.debug('-----------------Scale type = ' + str(scale) + '-------------------------------------------') logger.debug('-----------------Constraint File name = ' + constraint_file + '----------------------------') labels = np.loadtxt(library_folder + library_name + '.res', delimiter=',') labels = labels.astype(int) k_values = [] expected_cons = {} # if the library is not pure, i.e, ensemble results and targets are also included. # then, last 5 rows should be removed (single kmeans, cspa, hgpa, mcla, real labels) if 'pure' not in library_name: labels = labels[0:-5] mlset, nlset = io_func.read_constraints(constraint_file) # get cluster/clustering level weights con_per_cluster = [] con_clustering = [] for label in labels: con_per_cluster.append( Metrics.consistency_per_cluster(label, mlset, nlset, cons_type=cons_type)) for label in labels: con_clustering.append( Metrics.consistency(label, mlset, nlset, cons_type=cons_type)) k_values.append(len(np.unique(label))) k_values = np.array(k_values, dtype=int) possible_k = np.unique(k_values) cons = np.array(con_clustering) for k in possible_k: mean_value = np.mean(cons[k_values == k]) if mean_value == 0: mean_value = 1 expected_cons[k] = mean_value for i in range(0, labels.shape[0]): con_clustering[i] /= expected_cons[k_values[i]] con_clustering[i] *= internals[i] if scale: scaler = preprocessing.MinMaxScaler() con_clustering = scaler.fit_transform(np.array(con_clustering)) nmis = [] for alpha in alphas: logger.debug( '-------------------------->>>>>> PARAM START <<<<<<<---------------------------------' ) cur_nmis = [] for method in ensemble_method: ensemble_labels = _ensemble_method[method]( labels, N_clusters_max=class_num, weighted=True, clustering_weights=con_clustering, cluster_level_weights=con_per_cluster, alpha=alpha) ensemble_nmi = Metrics.normalized_max_mutual_info_score( ensemble_labels, target) logger.debug(method + ' alpha=' + str(alpha) + ', NMI=' + str(ensemble_nmi)) cur_nmis.append(ensemble_nmi) nmis.append(cur_nmis) logger.debug( '------------------------->>>>>> END OF THIS PARAM <<<<<<-------------------------------' ) logger.debug( '===========================================================================================' ) return nmis
def generate_library(data, target, dataset_name, n_members, class_num, n_cluster_lower_bound=0, n_cluster_upper_bound=0, feature_sampling=1.0, sample_sampling=0.7, feature_sampling_lower_bound=0.05, sample_sampling_lower_bound=0.1, f_stable_sample=True, s_stable_sample=True, constraints_file=None, sampling_method='FSRSNC', verbose=True, path=_default_result_path, metric='nid', manifold_type='MDS', subfolder=True, generate_only=True): """ generate a single library of ensemble member. Parameters ---------- :param data: dataset in a ndarray :param target: target in a ndarray or list :param dataset_name: name of dataset :param n_members: #clusters :param class_num: #real_class :param n_cluster_lower_bound: lower bound of k :param n_cluster_upper_bound: upper bound of k :param feature_sampling: fixed sampling rate of feature, or upper bound if not stable :param sample_sampling: fixed sampling rate of instances, or upper bound if not stable :param feature_sampling_lower_bound: lower bound of sampling rate of feature, only available if not stable :param sample_sampling_lower_bound: lower bound of sampling rate of instance, only available if not stable :param f_stable_sample: stable feature sampling or not :param s_stable_sample: stable instance sampling or not :param constraints_file: name of constraint file, only available when :param sampling_method: 'FSRSNC' and 'FSRSNN' supported :param verbose: print debug info. :param path: path to store the library :param metric: used for visualization only :param manifold_type: used for visualization only :param subfolder: save library in a separated sub-folder or not. Return ------ :return: name of the library generated (the library itself will be stored as a file) """ print('start generating library for dataset:' + dataset_name) # make sure that path to store the library existing if not os.path.isdir(path): os.mkdir(path) if subfolder: savepath = path + dataset_name + '/' if not os.path.isdir(savepath): os.mkdir(savepath) else: savepath = path # we set the range of cluster number to [k, 10k] if not defined if n_cluster_lower_bound == 0 or n_cluster_upper_bound == 0: n_cluster_lower_bound = class_num n_cluster_upper_bound = class_num * 10 # get sampling method, if not exist, it will raise a exception if sampling_method in _sampling_methods.keys(): is_constrained = False elif sampling_method in _constrained_methods.keys(): is_constrained = True else: raise ValueError('ensemble generation : Method should be set properly.') # read constraints file if existing if constraints_file is not None: mlset, nlset = io_func.read_constraints(constraints_file) else: if is_constrained: raise Exception('ensemble generation : Constrained Member must be with a constraints file.') constraints_file = '' mlset = [] nlset = [] # lower bound of sampling rate (use only if 'stable' set to be false) if feature_sampling_lower_bound > feature_sampling: feature_sampling_lower_bound = feature_sampling / 2 if sample_sampling_lower_bound > sample_sampling: sample_sampling_lower_bound = sample_sampling / 2 # there should be at least 2 clusters in the clustering if n_cluster_lower_bound < 2: n_cluster_lower_bound = 2 if n_cluster_upper_bound < n_cluster_lower_bound: n_cluster_upper_bound = n_cluster_lower_bound # path and filename to write the file filename = _get_file_name(dataset_name, n_cluster_lower_bound, n_cluster_upper_bound, feature_sampling, feature_sampling_lower_bound, sample_sampling, sample_sampling_lower_bound, n_members, f_stable_sample, s_stable_sample, sampling_method, is_constraint_method=is_constrained, constraint_file=constraints_file) # we won't generate the library with same sampling rate and size if existing if os.path.isfile(savepath + filename + '.res'): print ('[Library Generation] : library already exists.') return filename+'.res' elif os.path.isfile(savepath + filename + '_pure.res'): print ('[Library Generation] : corresponding pure library already exists.') return filename+'_pure.res' tag = True # matrix to store clustering results mat = np.empty(data.shape[0]) # generate ensemble members for i in range(0, n_members): # determine k randomly cluster_num = np.random.randint(n_cluster_lower_bound, n_cluster_upper_bound + 1) random_state = np.random.randint(0, _INT_MAX - 1) cur_feature_sampling = feature_sampling cur_sample_sampling = sample_sampling if not f_stable_sample: cur_feature_sampling = rand.uniform(feature_sampling_lower_bound, feature_sampling) if not s_stable_sample: cur_sample_sampling = rand.uniform(sample_sampling_lower_bound, sample_sampling) print('For this base clustering, cluster number is ' + str(cluster_num)) # generate ensemble member by given method if sampling_method == 'Cop_KMeans': result = _constrained_methods[sampling_method](data, cluster_num, mlset, nlset) elif sampling_method == 'E2CP': e2cp = _constrained_methods[sampling_method](data=data, ml=mlset, cl=nlset, n_clusters=cluster_num) e2cp.fit_constrained() result = e2cp.labels else: result = _sampling_methods[sampling_method](data, target, r_clusters=cluster_num, r_state=random_state, fsr=cur_feature_sampling, ssr=cur_sample_sampling) # print diversity diver = Metrics.normalized_max_mutual_info_score(result, target) if verbose: print ('Base clustering' + str(i) + ' nmi_max between real labels = ' + str(diver)) # stack the result into the matrix if tag: mat = np.array(result) mat = np.reshape(mat, (1, data.shape[0])) tag = False else: temp = np.array(result) temp = np.reshape(temp, (1, data.shape[0])) mat = np.vstack([mat, np.array(temp)]) # change element type to int for consensus mat = mat.astype(int) if generate_only or is_constrained: np.savetxt(savepath + filename + '_pure' + '.res', mat, fmt='%d', delimiter=',') return filename+'_pure.res' # single k-means model, for comparison clf = cluster.KMeans(n_clusters=class_num) clf.fit(data) kmlabels = clf.labels_ # do consensus labels_CSPA = ce.cluster_ensembles_CSPAONLY(mat, N_clusters_max=class_num) labels_HGPA = ce.cluster_ensembles_HGPAONLY(mat, N_clusters_max=class_num) labels_MCLA = ce.cluster_ensembles_MCLAONLY(mat, N_clusters_max=class_num) # put consensus results into the matrix mat = np.vstack([mat, np.reshape(kmlabels, (1, data.shape[0]))]) mat = np.vstack([mat, np.reshape(labels_CSPA, (1, data.shape[0]))]) mat = np.vstack([mat, np.reshape(labels_HGPA, (1, data.shape[0]))]) mat = np.vstack([mat, np.reshape(labels_MCLA, (1, data.shape[0]))]) # put real labels into the matrix temp = np.reshape(target, (1, data.shape[0])) mat = np.vstack([mat, np.array(temp)]) print ('Dataset ' + dataset_name + ', consensus finished, saving...') # write results to external file, use %d to keep integer part only np.savetxt(savepath + filename + '.res', mat, fmt='%d', delimiter=',') # print labels and diversities (between the real labels) nmi_CSPA = Metrics.normalized_max_mutual_info_score(labels_CSPA, target) nmi_HGPA = Metrics.normalized_max_mutual_info_score(labels_HGPA, target) nmi_MCLA = Metrics.normalized_max_mutual_info_score(labels_MCLA, target) print ('consensus NMI (CSPA) =' + str(nmi_CSPA)) print ('consensus NMI (HGPA) =' + str(nmi_HGPA)) print ('consensus NMI (MCLA) =' + str(nmi_MCLA)) kmnmi = Metrics.normalized_max_mutual_info_score(kmlabels, target) print ('single-model diversity (K-means) =' + str(kmnmi)) # save performances perf = np.array([nmi_CSPA, nmi_HGPA, nmi_MCLA, kmnmi]) np.savetxt(savepath + filename + '_performance.txt', perf, fmt='%.6f', delimiter=',') if metric == 'diversity': distance_matrix = Metrics.diversityMatrix(mat) np.savetxt(savepath + filename + '_diversity.txt', distance_matrix, delimiter=',') else: distance_matrix = Metrics.NIDMatrix(mat) np.savetxt(savepath + filename + '_nid.txt', distance_matrix, delimiter=',') if manifold_type == 'MDS': # transform distance matrix into 2-d or 3-d coordinates to visualize mds2d = manifold.MDS(n_components=2, max_iter=10000, eps=1e-12, dissimilarity='precomputed') mds3d = manifold.MDS(n_components=3, max_iter=10000, eps=1e-12, dissimilarity='precomputed') pos2d = mds2d.fit(distance_matrix).embedding_ pos3d = mds3d.fit(distance_matrix).embedding_ np.savetxt(savepath + filename + '_mds2d.txt', pos2d, fmt="%.6f", delimiter=',') np.savetxt(savepath + filename + '_mds3d.txt', pos3d, fmt="%.6f", delimiter=',') # draw odm, k distribution and nmi distribution cv.plot_ordered_distance_matrix(distance_matrix, savepath + filename + '_original_distance.png', savepath + filename + '_odm.png') cv.plot_k_distribution(mat, pos2d, savepath + filename+'_k_distribution.png') cv.plot_nmi_max(mat, pos2d, savepath + filename + '_nmimax_distribution.png') # consistencies are calculated while constraints file exists. if constraints_file != '': cv.plot_consistency(mat, pos2d, mlset, nlset, savepath + filename+'_consistency_both.png', consistency_type='both') cv.plot_consistency(mat, pos2d, mlset, nlset, savepath + filename+'_consistency_must.png', consistency_type='must') cv.plot_consistency(mat, pos2d, mlset, nlset, savepath + filename+'_consistency_cannot.png', consistency_type='cannot') cv.plt_consistency_corelation_with_k(mat, mlset, nlset, savepath + filename+'_normalized.png') return