def align(movie_data, options, args, lrh): print 'pICA(scikit-learn)' nvoxel = movie_data.shape[0] nTR = movie_data.shape[1] nsubjs = movie_data.shape[2] align_algo = args.align_algo nfeature = args.nfeature randseed = args.randseed if not os.path.exists(options['working_path']): os.makedirs(options['working_path']) # zscore the data bX = np.zeros((nsubjs*nTR,nvoxel)) for m in range(nsubjs): for t in range(nTR): bX[nTR*m+t,:] = stats.zscore(movie_data[:,t,m].T ,axis=0, ddof=1) del movie_data np.random.seed(randseed) A = np.mat(np.random.random((nfeature,nfeature))) ica = FastICA(n_components= nfeature, max_iter=500,w_init=A,random_state=randseed) ica.fit(bX.T) R = ica.transform(bX.T) niter = 10 # initialization when first time run the algorithm np.savez_compressed(options['working_path']+align_algo+'_'+lrh+'_'+str(niter)+'.npz',\ R = R, niter=niter) return niter
def ica_components(l, dataset, n=5): # l = Learn() # l.get_data(name) ica = FastICA(n_components=n) ica.fit(l.X) title = '{0} Components distribution for ICA with {1} components'.format( dataset.upper(), str(n)) bins = np.linspace(-.0001, .0001, 100) plt.figure() plt.title(title) plt.xlabel('value') plt.ylabel('frequency') a = [] for count, i in enumerate(ica.components_): a.extend(i) kurt = stats.kurtosis(i) plt.hist(i, bins, alpha=0.5, label=str(count + 1) + ": " + str(kurt)) plt.legend(loc='best') print('{0} ica components kurtosis: {1}'.format(dataset, stats.kurtosis(a))) plt.savefig('{0}.png'.format(title.replace(' ', '_')), bbox_inches='tight')
def wrapper_fastica(data, random_state=None): """Call FastICA implementation from scikit-learn.""" ica = FastICA(random_state=random_state) ica.fit(cat_trials(data).T) u = ica.components_.T m = ica.mixing_.T return m, u
def feat_map_ica(layer_name, subset_file='subset_cutoff_200_images.txt', map_index=0, n_plots=25): files = get_feature_files(layer_name, subset_file) maps = [] for idx, file in enumerate(files): mat = np.load(file) map_shape = mat[:, :, map_index].shape maps.append(mat[:, :, map_index].flatten()) maps = np.stack(maps, axis=0) ica = FastICA() ica.fit(maps) cols = int(np.ceil(np.sqrt(n_plots))) rows = int(np.ceil(n_plots // cols)) fig, ax_list = plt.subplots(ncols=cols, nrows=rows) ax_list = ax_list.flatten() for idx, ax in enumerate(ax_list): if idx >= n_plots: ax.axis('off') else: ax.matshow(np.reshape(ica.components_[idx, :], map_shape), interpolation='none') ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) plt.savefig('./plots/ica_' + layer_name + '_map_' + str(map_index) + '.png', format='png', dpi=1500) plt.close()
def perform_ica(data, num_comps=5, dims={'x': 2, 'y': 1, 't': 0}): """Performs an ica on the timedomain Arguments: data {3-d array} -- Input of xyt, can be any order as long as it is accompanied with appropriate dims argument Keyword Arguments: num_comps {int} -- Number of ICs to extract (default: {5}) dims {dict} -- The dimensions corresponding to x, y, and t (default: {{'x':2, 'y':1, 't':0}}) Returns: comps_out {3-d array} -- Array of num_comps x X x Y """ '''Performs ica on data input that is of the for (t,y,x)''' ica = FastICA(n_components=num_comps) data_reshaped = np.transpose(data, [dims['t'], dims['y'], dims['x']]) # Transpose to t, y, x sz = data_reshaped.shape data_re = data_reshaped.reshape([sz[0], sz[1] * sz[2]]) # Make it zero mean and common std for ii in range(sz[1] * sz[2]): data_re[:, ii] = (data_re[:, ii] - np.mean(data_re[:, ii])) / np.std( data_re[:, ii]) # Now perform ica print('fitting model...') ica.fit(data_re) print('done') comps_out = ica.components_.reshape([num_comps, sz[1], sz[2]]) return comps_out
def ica(X, y, components, max_cluster, num_classes, run_nn=False): X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, train_size=0.7, shuffle=True) ica_compress = FastICA(n_components=components, whiten=True) ica_compress.fit(X_train, y=y_train) X_train_new = ica_compress.transform(X_train) X_test_new = ica_compress.transform(X_test) print(kurtosis(X_test_new)) print(ica_compress.components_) if run_nn: mlp_classifier(X_train_new, y_train, 0.3, plot=True, X_test=X_test_new, y_test=y_test) X_new = np.concatenate((X_train_new, X_test_new), axis=0) y = np.concatenate((y_train, y_test), axis=0) kmeans(X_new, y, max_cluster, num_classes, run_nn=run_nn, plot_cluster=True, reduction_algo='ICA') expectation_max(X_new, y, max_cluster, num_classes, run_nn=run_nn, plot_cluster=True, reduction_algo='ICA')
class IcaProcessing(Processing): """ IcaProcessing is the procesisng used when performing Independant Component Analysis on Side-Channel traces. (based on sklearn.decomposition.ICA) """ def __init__(self, container, number_of_components, random_state=0, post_section=None, filename=None): """ :param container: the container on which to perform ICA :param number_of_components: number of component used for the dimensionality reduction :param random_state: optional, for the sklearn object """ self._ica = FastICA(n_components=number_of_components, random_state=random_state) # compute ica: batch = container[:container.number_of_traces] self._ica.fit(batch.leakages) self.post_section = post_section Processing.__init__(self, filename) def __call__(self, leakage): if self.post_section is None: return self._ica.transform([leakage])[0] else: return self._ica.transform([leakage])[0, self.post_section]
def myICA(X,y): t1 = clock() clf = FastICA() clf.fit(X) newRep = clf.transform(X) t2 = clock() return t2-t1
def fast_ica(image, components): """Reconstruct an image from Fast ICA compression using specific number of components to use Args: image: PIL Image, Numpy array or path of 3D image components: Number of components used for reconstruction Returns: Reconstructed image Example: >>> from PIL import Image >>> import numpy as np >>> from ipfml.processing import reconstruction >>> image_values = Image.open('./images/test_img.png') >>> reconstructed_image = reconstruction.fast_ica(image_values, 25) >>> reconstructed_image.shape (200, 200) """ lab_img = transform.get_LAB_L(image) lab_img = np.array(lab_img, 'uint8') ica = FastICA(n_components=50) # run ICA on image ica.fit(lab_img) # reconstruct image with independent components image_ica = ica.fit_transform(lab_img) restored_image = ica.inverse_transform(image_ica) return restored_image
def main(mode): path = "/local/attale00/extracted_pascal__4__Multi-PIE" path_ea = path + "/color128/" allLabelFiles = utils.getAllFiles("/local/attale00/a_labels") labeledImages = [i[0:16] + ".png" for i in allLabelFiles] # labs=utils.parseLabelFiles(path+'/Multi-PIE/labels','mouth',labeledImages,cutoffSeq='.png',suffix='_face0.labels') labs = utils.parseLabelFiles( "/local/attale00/a_labels", "mouth", labeledImages, cutoffSeq=".png", suffix="_face0.labels" ) testSet = fg.dataContainer(labs) roi = (50, 74, 96, 160) X = fg.getAllImagesFlat(path_ea, testSet.fileNames, (128, 256), roi=roi) # perform ICA if mode not in ["s", "v"]: ica = FastICA(n_components=100, whiten=True) ica.fit(X) meanI = np.mean(X, axis=0) X1 = X - meanI data = ica.transform(X1) filters = ica.components_ elif mode in ["s", "v"]: W = np.load("/home/attale00/Desktop/classifiers/ica/filter1.npy") m = np.load("/home/attale00/Desktop/classifiers/ica/meanI1.npy") X1 = X - m data = np.dot(X1, W.T) for i in range(len(testSet.data)): testSet.data[i].extend(data[i, :]) strel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)) # fg.getHogFeature(testSet,roi,path=path_ea,ending='.png',extraMask = None,orientations = 3, cells_per_block=(6,2),maskFromAlpha=False) # fg.getColorHistogram(testSet,roi,path=path_ea,ending='.png',colorspace='lab',bins=10) testSet.targetNum = map(utils.mapMouthLabels2Two, testSet.target) rf = classifierUtils.standardRF(max_features=np.sqrt(len(testSet.data[0])), min_split=5, max_depth=40) if mode in ["s", "v"]: print "Classifying with loaded classifier" classifierUtils.classifyWithOld( path, testSet, mode, clfPath="/home/attale00/Desktop/classifiers/ica/rf128ICA_1" ) elif mode in ["c"]: print "cross validation of data" print "Scores" # print classifierUtils.standardCrossvalidation(rf,testSet,n_jobs=5) # _cvDissect(testSet,rf) classifierUtils.dissectedCV(rf, testSet) print "----" elif mode in ["save"]: print "saving new classifier" _saveRF(testSet) else: print "not doing anything"
def PerformIca(X,Y,num_components,random_state): result = {} algo = FastICA(random_state=random_state,max_iter=800) algo.fit(X) full_mixing_matrix = algo.mixing_ full_unmixing_matrix = algo.components_ _x = algo.transform(X) kt_value = np.abs(kt(_x)) largest_kt_values_idx = np.argsort(kt_value)[::-1] result["ica_kt_all"] = kt_value for n in num_components: prefix = "ica_" + str(n) + "_" component_idx_to_select = largest_kt_values_idx[0:n] mixing_matrix = full_mixing_matrix.T[component_idx_to_select,:].T unmixing_matrix = full_unmixing_matrix[component_idx_to_select,:] algo.components_ = unmixing_matrix algo.mixing_ = mixing_matrix result[prefix+"mm"] = mixing_matrix result[prefix+"umm"] = unmixing_matrix _x = algo.transform(X) result[prefix+"data"] = _x X_recons = algo.inverse_transform(_x) result[prefix+"reconstruction_error"] = ComputeReconstructionSSE(X,X_recons) n_kt_value = kt_value[component_idx_to_select] avg_kt = n_kt_value.mean() #print("ICA num dim {0} : reconstruction error {1} avg kt {2}".format(str(n),str(result[prefix+"reconstruction_error"]),str(avg_kt))) #print(np.sort(n_kt_value)) return result
def fast_ica_from_sklearn(): df = pd.read_csv() data = df.drop() # 独立成分の数=2 decomposer = FastICA(n_components=2) # データの平均を計算 M = np.mean(data, axis=1)[:, np.newaxis] # 各データから平均を引く data2 = data - M # 平均0としたデータに対して、独立成分分析を実施 decomposer.fit(data2) # 独立成分ベクトルを取得(D次元 x 独立成分数) S = decomposer.transform(data2) # 混合行列の計算(データ数 x 独立性分数) W = decomposer.mixing_ # 混合行列と独立成分から元の信号dataを復元 X = np.dot(S, W.T) X += M # 混合行列の擬似逆行列を取得 W_inv = decomposer.components_ plt.plot(W_inv)
def test_fastica_convergence_fail(): # Test the FastICA algorithm on very simple data # (see test_non_square_fastica). # Ensure a ConvergenceWarning raised if the tolerance is sufficiently low. rng = np.random.RandomState(0) n_samples = 1000 # Generate two sources: t = np.linspace(0, 100, n_samples) s1 = np.sin(t) s2 = np.ceil(np.sin(np.pi * t)) s = np.c_[s1, s2].T center_and_norm(s) # Mixing matrix mixing = rng.randn(6, 2) m = np.dot(mixing, s) # Do fastICA with tolerance 0. to ensure failing convergence warn_msg = ("FastICA did not converge. Consider increasing tolerance " "or the maximum number of iterations.") with pytest.warns(ConvergenceWarning, match=warn_msg): ica = FastICA(algorithm="parallel", n_components=2, random_state=rng, max_iter=2, tol=0.0) ica.fit(m.T)
def myICA(bigdf, ncomp, whiten=True): ica = FastICA(n_components=ncomp, whiten=True) ica.fit(bigdf) icafittrans = ica.transform(bigdf) icafittrans = pd.DataFrame(icafittrans) icafittrans.index = dfDateIndex icacomponents = ica.components_ icacomponents = pd.DataFrame(icacomponents) icacomponents.columns = dfSearchTermIndex # ICA results are arbitrarily scaled. # For easy human comprehension we'll rectify the peaks peakdirs = icafittrans.apply(peakDirection, axis=0) icafittrans = icafittrans.multiply(peakdirs, axis='columns') # That's enough to make it look right, but we also need to rectify components icacomponents = icacomponents.multiply(peakdirs, axis='rows') # While we are at it, let's reorder the components from most peaky to least peakinesses = icafittrans.apply(peakiness, axis=0) peakinessSort = np.argsort(-peakinesses) # now sort the columns in the icafittrans and the A_ icafittrans = icafittrans.iloc[:, peakinessSort] icacomponents = icacomponents.iloc[peakinessSort, :] return icafittrans, icacomponents
def calculate_encoder(image, algorithm, patches_size=(DEFAULT_PATCHE_SIZE, DEFAULT_PATCHE_SIZE), projection_dimensios=DEFAULT_PATCHE_SIZE, previous_components=None): """ Gets a higher dimension sparse dictionary.algorithm can be ica, kmeans or colors. """ patches = extract_patches_2d( image, patches_size, calculate_max_number_of_patches(image, patches_size)) patches = numpy.reshape(patches, (patches.shape[0], -1)).astype(float) encoder = None if algorithm == 'ica': encoder = FastICA(n_components=projection_dimensios, whiten=True, max_iter=10) elif algorithm == 'kmeans': encoder = MiniBatchKMeans(projection_dimensios, compute_labels=False) else: raise Exception('Unknow algorithm %s' % algorithm) encoder.fit(patches) return encoder
def get_best_dimensionality_reductions(x1, x2, best_features): dim_reds = {} for d, x in {'wine': x1, 'pima': x2}.items(): pca = PCA(n_components=0.95, whiten=True, random_state=42) pca.fit(x) k = dim_reds.setdefault('pca', {}) k[d] = pca k = dim_reds.setdefault('rfc', {}) k[d] = best_features[d] k = dim_reds.setdefault('ica', {}) ica = FastICA(n_components=8, whiten=True, random_state=42) ica.fit(x1) k['wine'] = ica ica = FastICA(n_components=6, whiten=True, random_state=42) ica.fit(x2) k['pima'] = ica k = dim_reds.setdefault('rp', {}) rp = SparseRandomProjection(random_state=42, n_components=8) rp.fit(x1) k['wine'] = rp rp = SparseRandomProjection(random_state=42, n_components=6) rp.fit(x2) k['pima'] = rp return dim_reds
def extractPatterns(actmat,significance,method): nassemblies = significance.nassemblies if method == 'pca': idxs = np.argsort(-significance.explained_variance_)[0:nassemblies] patterns = significance.components_[idxs,:] elif method == 'ica': from sklearn.decomposition import FastICA ica = FastICA(n_components=nassemblies) ica.fit(actmat.T) patterns = ica.components_ else: print('ERROR !') print(' assembly extraction method '+str(method)+' not understood') patterns = np.nan if patterns is not np.nan: patterns = patterns.reshape(nassemblies,-1) # sets norm of assembly vectors to 1 norms = np.linalg.norm(patterns,axis=1) patterns /= np.matlib.repmat(norms,np.size(patterns,1),1).T return patterns
def get_ICA_features(X_tr, X_te, n_components=None): ica = FastICA(n_components=n_components) ica.fit(X_tr) t_x_tr = ica.transform(X_tr) t_x_te = ica.transform(X_te) return t_x_tr, t_x_te
def fit(self, data): max_sir = None self.ica = None for _ in range(self.n_iter): fca = FastICA(n_components=self.n_components, max_iter=self.max_iter, algorithm='deflation') fca.fit(data) # try: new_components = sorted(zip(fca.components_, np.argmax(np.abs(fca.components_), axis=1)), key= lambda x: x[1]) new_components = np.stack(new_components) new_components = np.array([x[0] for x in new_components]) fca.components_ = new_components m = new_components/(abs(norm(new_components, axis=1)).reshape(-1,1)) - np.identity(data.shape[1]) sir = norm(m, axis=1) # except: # continue sir = -10*np.log10(sir).sum() # in the paper its > if max_sir is None or sir > max_sir: self.max_sir = sir max_sir = sir self.sir_log.append(sir) self.ica = fca return self.ica
def red_dim(metodo, n): trainX = np.load('trainX.npy') testX = np.load('testX.npy') if metodo == "RFE": clf = DecisionTreeClassifier() rfe = RFECV(clf, step=1, cv=10, verbose=2) trainy = np.load('trainy.npy') rfe = rfe.fit(trainX, trainy) l = zip(rfe.ranking_,dnames) for i in sorted(l, key=lambda x: x[0]): print i[1] else: if metodo == "PCA": pca = PCA(n_components=n) pca.fit(trainX) trainX = pca.transform(trainX) testX = pca.transform(testX) elif metodo == "iPCA": pca = IncrementalPCA(n_components=n) pca.fit(trainX) trainX = pca.transform(trainX) testX = pca.transform(testX) elif metodo == "ICA": ica = FastICA(n_components=n) ica.fit(trainX) trainX = ica.transform(trainX) testX = ica.transform(testX) else: print u'Dimensión inválida' exit() np.save('trainX_' + metodo + str(n) , trainX) np.save('testX_' + metodo + str(n), testX)
def ica(n_components, X, y, algorithm='parallel', whiten=True, fun='logcosh', fun_args=None, max_iter=2000, tol=0.000001, w_init=None, random_state=3, plot=1, dataset='german'): ica_model = FastICA(n_components=n_components, algorithm=algorithm, whiten=whiten, fun=fun, fun_args=fun_args, max_iter=max_iter, tol=tol, w_init=w_init, random_state=random_state) ica_model.fit(X) X_new = ica_model.transform(X) if plot: if dataset == 'german': plt.scatter(X_new[y == 1, 0], X_new[y == 1, 1], c='red', label='Samples with label 1') plt.scatter(X_new[y == 0, 0], X_new[y == 0, 1], c='green', label='Samples with label 0') plt.title("German dataset after ICA") plt.legend() plt.xlabel("Component 1") plt.ylabel("Component 2") plt.savefig("german-after-ICA.png") plt.close() elif dataset == 'australian': plt.scatter(X_new[y == 1, 0], X_new[y == 1, 1], c='red', label='Samples with label 1') plt.scatter(X_new[y == 0, 0], X_new[y == 0, 1], c='green', label='Samples with label 0') plt.title("Australian dataset after ICA") plt.legend() plt.xlabel("Component 1") plt.ylabel("Component 2") plt.savefig("australian-after-ICA.png") plt.close() return X_new
def plot_component_kurtosis(datasets, targets): """Plot component kurtosis.""" plt.figure(figsize=(8, 4)) subindex = 0 for dataset, target in zip(datasets, targets): subindex += 1 logging.info(f"Visualizing ICA kurtosis for {dataset}...") data = helpers.load_dataset_df(dataset) train, test = helpers.split_test_train(data, target) train, test = helpers.scale_test_train(train, test) dim = DimRedux(train.X.shape[1], max_iter=5000, whiten=True, random_state=42) dim.fit(train.X) kurt = scipy.stats.kurtosis(dim.transform(train.X)) plt.subplot(1, len(datasets), subindex) plt.bar([n for n, c in enumerate(kurt)], kurt, align="center", alpha=0.5) plt.xlabel("Components") plt.ylabel("Kurtosis") plt.title(f"{dataset}", fontsize=10) plt.tight_layout() outpath = os.path.join(helpers.BASEDIR, "img", f"dim-ica-both-kurtosis.png") plt.savefig(outpath) return None
class ICA(method.Method): def __init__(self, params): self.params = params self.ica = FastICA(**params) def __str__(self): return "FastICA" def train(self, data): """ Train the FastICA on the withened data :param data: whitened data, ready to use """ self.ica.fit(data) def encode(self, data): """ Encodes the ready to use data :returns: encoded data with dimension n_components """ return self.ica.transform(data) def decode(self, components): """ Decode the data to return whitened reconstructed data :returns: reconstructed data """ return self.ica.inverse_transform(components)
def iCA(x_all, y_all): # 独立成分の数=24 decomposer = FastICA(n_components=2) # データの平均を計算 M = np.mean(x_all, axis=1)[:, np.newaxis] # 各データから平均を引く data2 = x_all - M # 平均0としたデータに対して、独立成分分析を実施 decomposer.fit(data2) # 独立成分ベクトルを取得(D次元 x 独立成分数) S = decomposer.transform(data2) #プロットする for label in np.unique(y_all): plt.scatter(S[y_all == label, 0], S[y_all == label, 1], ) plt.legend(loc='upper right', bbox_to_anchor=(1,1), borderaxespad=0.5,fontsize = 10) plt.title('principal component') plt.xlabel('Ic1') plt.ylabel('Ic2') # 主成分の寄与率を出力する #print('各次元の寄与率: {0}'.format(decomposer.explained_variance_ratio_)) #print('累積寄与率: {0}'.format(sum(decomposer.explained_variance_ratio_))) # グラフを表示する plt.show() return S, y_all
def ica_varing_components(data, type): # Run ICA demensionality reduction on original data n_components_max = 56 n_components = np.arange(2, n_components_max, 1) kurtosis_matrix = np.array([]) for n in n_components: print n ica = FastICA(n_components=n,whiten=True, algorithm='deflation', max_iter=100) ica.fit(data) transformed_data = ica.transform(data) kurtosis = sta.kurtosis(transformed_data, axis=0) # for Normal distribution, kurtosis = 0 by this algorithm # shape = n_components when axis = 0, meaning kurtosis is calculated for each column kurtosis_matrix = np.append(kurtosis_matrix, np.average(kurtosis)) # Plot n_components vs. kurtosis plt.figure(figsize=(16, 9)) plt.plot(n_components, kurtosis_matrix, "o-", label="kurtosis") plt.grid(True) plt.xlim(np.amin(n_components), np.amax(n_components)) plt.xticks(range(np.amin(n_components), n_components_max+3, 3)) plt.ylabel('kurtosis') plt.xlabel('# of components') plt.legend() plt.title(("NBA Player Stats %s ICA\n(Kurtosis of Normal Distribution is 0 in this algorithm)") % (type)) plt.savefig(("original_ICA_kurtosis_2_to_%d_components_axis_1.png") % n_components_max) plt.close()
def _ICA_decomposition(X, n_components, max_iter): """ Apply FastICA algorithm from sklearn.decompostion to the matrix X Note: FastICA in sklearn works with a matrix of shape (n_features , n_samples) that is why we fit FastICA with X.T Parameters ---------- X : 2D array, shape (n_samples , n_features) n_components : int number of ICA components max_iter : int see https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.FastICA.html Returns ------- 2D array , shape (n_components , n_features) components obtained from the ICA decomposition of X """ ica = FastICA(n_components=n_components, max_iter=max_iter) ica.fit(X.T) return ica.transform(X.T).T
def img2_coord(img, init=None): assert np.max(img) <= 1.0 if init is None: init = np.zeros((img.shape[0] + 200, img.shape[1] + 200)) init[100:-100, 100:-100] = img img = init img_size = img.shape[0] tile_x = np.tile(np.arange(img_size), (img_size, 1)) tile_y = tile_x.T mean_x = np.sum(img * tile_x) / np.sum(img) mean_y = np.sum(img * tile_y) / np.sum(img) dist_mean_x = np.abs(mean_x - tile_x) * img dist_mean_y = np.abs(mean_y - tile_y) * img hypo = np.max(((dist_mean_x * dist_mean_x) + (dist_mean_y * dist_mean_y))) diff_mean_x = tile_x[img > 0].flatten() - mean_x diff_mean_y = tile_y[img > 0].flatten() - mean_y m = np.stack([diff_mean_x, diff_mean_y]) decomposer = FastICA(2) decomposer.fit(m.T) Uica = decomposer.mixing_ # print('ICA vectors') norms = np.sqrt((Uica**2).sum(axis=0)) Uica = Uica / np.sqrt((Uica**2).sum(axis=0)) if norms[0] > norms[1]: rotate = -np.arctan2(Uica[0, 0], Uica[1, 0]) else: rotate = -np.arctan2(Uica[0, 1], Uica[1, 1]) # represent between [-math.pi, math.pi] if rotate < -math.pi / 2: rotate += math.pi elif rotate > math.pi / 2: rotate -= math.pi # print('rotate: {:.2f} [deg]'.format(rotate * 360 / 2 / 3.14)) aspect_ratio = max(norms) / min(norms) # print('aspect ratio: {:.2f}'.format(aspect_ratio)) width = np.sqrt(hypo / (1 + aspect_ratio**2)) * 2 + 0.25 # height = np.sqrt(hypo * aspect_ratio**2 / (1 + aspect_ratio**2)) * 2 height = width * aspect_ratio # print('width: {} height: {}'.format(width, height)) return mean_x, mean_y, height, aspect_ratio, rotate, img_size
def wrapper_fastica(data): """ Call FastICA implementation from scikit-learn. """ ica = FastICA() ica.fit(datatools.cat_trials(data)) u = ica.components_.T m = ica.mixing_.T return m, u
def ica_algorithm(dataSet, d=0.95): print('Doing FastICA......') print('Origin data size:' + str(dataSet.shape)) ica = FastICA(n_components=d) ica.fit(dataSet) new_data = ica.transform(dataSet) print('After ICA data size:' + str(new_data.shape)) return new_data
def ica(tx, ty, rx, ry): compressor = ICA(whiten=True) # for some people, whiten needs to be off compressor.fit(tx, y=ty) newtx = compressor.transform(tx) newrx = compressor.transform(rx) em(newtx, ty, newrx, ry, add="wICAtr", times=10) km(newtx, ty, newrx, ry, add="wICAtr", times=10) nn(newtx, ty, newrx, ry, add="wICAtr")
def independent_components_decomposition(W, n_components): fast_ica = FastICA(n_components=n_components) fast_ica.fit(W) W_ = fast_ica.components_ norm = np.linalg.norm(W_, axis=1).reshape(-1, n_components) W_nomralize = W_ / norm.T independent_components = torch.from_numpy(W_nomralize.T).float() return independent_components
def ica(tx, ty, rx, ry): compressor = ICA(whiten=False) # for some people, whiten needs to be off compressor.fit(tx, y=ty) newtx = compressor.transform(tx) newrx = compressor.transform(rx) em(newtx, ty, newrx, ry, add="wICAtr", times=10) km(newtx, ty, newrx, ry, add="wICAtr", times=10) nn(newtx, ty, newrx, ry, add="wICAtr")
def fastica(eeg_data): """ Sample function to apply `FastICA`_ to the EEG data. Parameters ---------- eeg_data : array EEG data in a CxTxE array. With C the number of channels, T the number of time samples and E the number of events. Returns ------- ica : ICA object Trained `FastICA`_ object. ica_data : array EEG projected data in a CxTxE array. With C the number of components, T the number of time samples and E the number of events. """ # Dimension shapes ch_len = eeg_data.shape[ch_dim] t_len = eeg_data.shape[t_dim] ev_len = eeg_data.shape[ev_dim] # ------------------------------------------------------------------------- # 1. Fit the FastICA model # We need to collapse time and events dimensions coll_data = eeg_data.transpose([t_dim, ev_dim, ch_dim])\ .reshape([t_len*ev_len, ch_len]) # Fit model ica = FastICA() ica.fit(coll_data) # Normalize ICs to unit norm k = np.linalg.norm(ica.mixing_, axis=0) # Frobenius norm ica.mixing_ /= k ica.components_[:] = (ica.components_.T * k).T # ------------------------------------------------------------------------- # 2. Transform data # Project data bss_data = ica.transform(coll_data) # Adjust shape and dimensions back to "eeg_data" shape ic_len = bss_data.shape[1] bss_data = np.reshape(bss_data, [ev_len, t_len, ic_len]) new_order = [0, 0, 0] # TODO: Check the following order new_order[ev_dim] = 0 new_order[ch_dim] = 2 new_order[t_dim] = 1 bss_data = bss_data.transpose(new_order) # End return ica, bss_data
def ica(self): ''' Perform ICA on the data source_matrix -- rows are sources, columns are time points, values are ? mixing_matrix -- rows are electrodes, columns are source, values are contributions of the electrode to the source ''' ica = FastICA(self.number_of_sources) ica.fit(self.data) self.mixing_matrix = ica.mixing_ # estimated mixing matrix
def test_fastica_nowhiten(): m = [[0, 1], [1, 0]] # test for issue #697 ica = FastICA(n_components=1, whiten=False, random_state=0) warn_msg = "Ignoring n_components with whiten=False." with pytest.warns(UserWarning, match=warn_msg): ica.fit(m) assert hasattr(ica, "mixing_")
def wrapper_fastica(data): """ Call FastICA implementation from scikit-learn. """ from sklearn.decomposition import FastICA ica = FastICA() ica.fit(datatools.cat_trials(data)) u = ica.components_.T m = ica.mixing_.T return m, u
def independent_component(x, y): clf = FastICA(random_state=1) clf.fit(x.reshape(-1, 1), y) comp = clf.components_[0][0] mm = clf.get_mixing_matrix()[0][0] sources = clf.sources_.flatten() src_max = max(sources) src_min = min(sources) return [comp, mm, src_max, src_min]
def ICA(model_data, components = None, transform_data = None): t0 = time() ica = FastICA(n_components=components) if transform_data == None: projection = ica.fit_transform(model_data) else: ica.fit(model_data) projection = ica.transform(transform_data) print "ICA Time: %0.3f" % (time() - t0) return projection
def var_test_ica(flux_arr_orig, exposure_list, wavelengths, low_n=3, hi_n=100, n_step=1, show_plots=False, show_summary_plot=False, save_summary_plot=True, test_ind=7, real_time_progress=False, idstr=None): start_ind = np.min(np.nonzero(flux_arr_orig[test_ind])) end_ind = np.max(np.nonzero(flux_arr_orig[test_ind])) perf_table = Table(names=["n", "avg_diff2", "max_diff_scaled"], dtype=["i4", "f4", "f4"]) if hi_n > flux_arr_orig.shape[0]-1: hi_n = flux_arr_orig.shape[0]-1 for n in range(low_n, hi_n, n_step): ica = FastICA(n_components = n, whiten=True, max_iter=750, random_state=1234975) test_arr = flux_arr_orig[test_ind].copy() flux_arr = np.vstack([flux_arr_orig[:test_ind], flux_arr_orig[test_ind+1:]]) ica_flux_arr = flux_arr.copy() #keep back one for testing ica.fit(ica_flux_arr) ica_trans = ica.transform(test_arr.copy(), copy=True) ica_rev = ica.inverse_transform(ica_trans.copy(), copy=True) avg_diff2 = np.ma.sum(np.ma.power(test_arr-ica_rev[0],2)) / (end_ind-start_ind) max_diff_scaled = np.ma.max(np.ma.abs(test_arr-ica_rev[0])) / (end_ind-start_ind) perf_table.add_row([n, avg_diff2, max_diff_scaled]) if real_time_progress: print "n: {:4d}, avg (diff^2): {:0.5f}, scaled (max diff): {:0.5f}".format(n, avg_diff2, max_diff_scaled) if show_plots: plt.plot(wavelengths, test_arr) plt.plot(wavelengths, ica_rev[0]) plt.plot(wavelengths, test_arr-ica_rev[0]) plt.legend(['orig', 'ica', 'orig-ica']) plt.xlim((wavelengths[start_ind], wavelengths[end_ind])) plt.title("n={}, avg (diff^2)={}".format(n, avg_diff2)) plt.tight_layout() plt.show() plt.close() if show_summary_plot or save_summary_plot: plt.plot(perf_table['n'], perf_table['avg_diff2']) plt.plot(perf_table['n'], perf_table['max_diff_scaled']) plt.title("performance") plt.tight_layout() if show_summary_plot: plt.show() if save_summary_plot: if idstr is None: idstr = random.randint(1000000, 9999999) plt.savefig("ica_performance_{}.png".format(idstr)) plt.close() return perf_table
def independent_component( (x, y) ): lenX = len(x) newX = np.array(x).reshape(lenX, 1) g = FastICA() g.fit(newX, y) ret = [0.0, 0.0, 0.0, 0.0] ret[0] = g.components_[0][0] ret[1] = g.get_mixing_matrix()[0][0] sources = g.sources_.flatten() ret[2] = max(sources) ret[3] = min(sources) return ret
def test_fastica_nowhiten(): m = [[0, 1], [1, 0]] ica = FastICA(whiten=False, random_state=0) ica.fit(m) ica.mixing_ # test for issue #697 with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") ica = FastICA(n_components=1, whiten=False, random_state=0) ica.fit(m) # should raise warning assert_true(len(w) == 1) # 1 warning should be raised
def learnICADict(features, components=25): icaHOG = FastICA(n_components=components) icaHOF = FastICA(n_components=components) icaHOG.fit(np.array([x['hog'] for x in features]).T) icaHOF.fit(np.array([x['hof'] for x in features]).T) hogComponents = icaHOG.components_.T hofComponents = icaHOF.components_.T return hogComponents, hofComponents
def main(mode): path = '/local/attale00/AFLW_ALL/' path_ea = '/local/attale00/AFLW_cropped/mouth_img_error/' # fileNames = utils.getAllFiles(path_ea); labs=utils.parseLabelFiles(path+'/labels/labels','mouth_opening',fileNames,cutoffSeq='.png',suffix='_face0.labels') testSet = fg.dataContainer(labs) components = 150 roi=None X=fg.getAllImagesFlat(path_ea,testSet.fileNames,(40,120),roi=roi) # X=fg.getAllImagesFlat(path_ea,testSet.fileNames,(120,40),roi=roi,resizeFactor = .5) # # perform ICA if mode not in ['s','v']: ica = FastICA(n_components=components,whiten=True) ica.fit(X) meanI=np.mean(X,axis=0) X1=X-meanI data=ica.transform(X1) filters=ica.components_ elif mode in ['s','v']: W=np.load('/home/attale00/Desktop/classifiers/patches/filterMP1.npy') m=np.load('/home/attale00/Desktop/classifiers/patches/meanIMP1.npy') X1=X-m data=np.dot(X1,W.T) for i in range(len(fileNames)): testSet.data[i].extend(data[i,:]) print 'feature vector length: {}'.format(len(testSet.data[0])) testSet.targetNum=map(utils.mapMouthLabels2Two,testSet.target) rf=classifierUtils.standardRF(max_features = np.sqrt(len(testSet.data[0])),min_split=13,max_depth=40) #rf = svm.NuSVC() #rf = linear_model.SGDClassifier(loss='perceptron', eta0=1, learning_rate='constant', penalty=None) if mode in ['s','v']: print 'Classifying with loaded classifier' _classifyWithOld(path,testSet,mode) elif mode in ['c']: print 'cross validation of data' rValues = classifierUtils.dissectedCV(rf,testSet) pickle.dump(rValues,open('errorpatch_ica','w')) elif mode in ['save']: print 'saving new classifier' _saveRF(testSet,rf,filters=filters,meanI=meanI) else: print 'not doing anything'
def fit(self, x, y, i=0): # if gaussian processes are being used, data dimensionality needs to be reduced before fitting if self.method[i] == 'GP': if self.reduce_dim == 'FastICA': print('Reducing dimensionality with ICA') do_ica = FastICA(n_components=self.n_components) self.do_reduce_dim = do_ica.fit(x) if self.reduce_dim == 'PCA': print('Reducing dimensionality with PCA') do_pca = PCA(n_components=self.n_components) self.do_reduce_dim = do_pca.fit(x) x = self.do_reduce_dim.transform(x) #try: print('Training model...') try: self.model.fit(x, y) self.goodfit = True print(self.model) except: self.goodfit = False if self.method[i] == 'GP': print('Model failed to train! (For GP this does not always indicate a problem, especially for low numbers of components.)') pass else: print('Model failed to train!') traceback.print_stack() if self.ransac: self.outliers = np.logical_not(self.model.inlier_mask_) print(str(np.sum(self.outliers)) + ' outliers removed with RANSAC')
def RunICAScikit(): totalTimer = Timer() # Load input dataset. data = np.genfromtxt(self.dataset, delimiter=',') opts = {} if "num_components" in options: opts["n_components"] = int(options.pop("num_components")) if "algorithm" in options: opts["algorithm"] = str(options.pop("algorithm")) if opts["algorithm"] not in ['parallel', 'deflation']: Log.Fatal("Invalid value for algorithm: "+ str(algorithm.group(1))+" .Must be either parallel or deflation") return -1 if "function" in options: opts["fun"] = str(options.pop("function")) if opts["fun"] not in ['logcosh', 'exp', 'cube']: Log.Fatal("Invalid value for fun: "+ str(fun.group(1))+" .Must be either logcosh,exp or cube") return -1 if "tolerance" in options: opts["tol"] = float(options.pop("tolerance")) try: # Perform ICA. with totalTimer: model = FastICA(**opts) ic = model.fit(data).transform(data) except Exception as e: return -1 return totalTimer.ElapsedTime()
def test_fit_transform(): """Test FastICA.fit_transform""" rng = np.random.RandomState(0) X = rng.random_sample((100, 10)) for whiten, n_components in [[True, 5], [False, 10]]: ica = FastICA(n_components=5, whiten=whiten, random_state=0) Xt = ica.fit_transform(X) assert_equal(ica.components_.shape, (n_components, 10)) assert_equal(Xt.shape, (100, n_components)) ica = FastICA(n_components=5, whiten=whiten, random_state=0) ica.fit(X) assert_equal(ica.components_.shape, (n_components, 10)) Xt2 = ica.transform(X) assert_array_almost_equal(Xt, Xt2)
def fastICA(X): from sklearn.decomposition import FastICA # FastICAのライブラリ n, p = X.shape M = np.mean(X, axis=0) M_est = M X2 = X - M decomposer = FastICA(n_components=p) decomposer.fit(X2) A_est = decomposer.mixing_ W_est = np.linalg.inv(A_est) S_est = decomposer.transform(X2) return S_est, W_est, M_est
def test_fit_transform(): # Test FastICA.fit_transform rng = np.random.RandomState(0) X = rng.random_sample((100, 10)) for whiten, n_components in [[True, 5], [False, None]]: n_components_ = (n_components if n_components is not None else X.shape[1]) ica = FastICA(n_components=n_components, whiten=whiten, random_state=0) Xt = ica.fit_transform(X) assert_equal(ica.components_.shape, (n_components_, 10)) assert_equal(Xt.shape, (100, n_components_)) ica = FastICA(n_components=n_components, whiten=whiten, random_state=0) ica.fit(X) assert_equal(ica.components_.shape, (n_components_, 10)) Xt2 = ica.transform(X) assert_array_almost_equal(Xt, Xt2)
def GenFeatures( self ): """Main feature generation method""" if 'Word2Vec' in self.FeatureGenerationMethod: if self.ReTrainW2V: W2V = gensim.models.Word2Vec(min_count = 8, size = 256, workers = 1, window = 5) W2V.build_vocab(self.Summaries) W2V.train(self.Summaries) joblib.dump(W2V, 'data' +os.sep+ 'W2VModel' +os.sep+ 'modelW2V.pkl') else: W2V = joblib.load('data' +os.sep+ 'W2VModel' +os.sep+ 'modelW2V.pkl') modelSet = set(W2V.index2word) icaFeatures = numpy.zeros( (len(self.Summaries), W2V.vector_size) ) fastICA = FastICA(n_components = 32, whiten = True, max_iter=2048, algorithm='deflation') for i in xrange(0, len(self.Summaries)): textVec = self.Summaries[i] features = [] for word in textVec: if word in modelSet: features.append(W2V[word]) features = numpy.asarray(features, dtype = numpy.float32) if features.size > 0: U, s, V = numpy.linalg.svd(features, full_matrices=False) SVDComponents = U SVDVar = numpy.cumsum((s)) # pyplot.subplot(1,3,1), pyplot.imshow(U, interpolation = 'none', vmin = 0.0, vmax = 1.0), pyplot.colorbar(), pyplot.subplot(1,3,2), pyplot.imshow(V, interpolation = 'none', vmin = 0.0, vmax = 1.0), pyplot.colorbar(), pyplot.subplot(1,3,3), pyplot.plot(SVDVar), pyplot.show() # print U.shape, V.shape, s.shape try: sourceICA = fastICA.fit(features).transform(features) fastICAComponents = fastICA.components_ if self.ICAKurt: kurtS = scipy.stats.kurtosis(fastICAComponents, axis = 1) kurtIdx = numpy.argmax(kurtS) icaFeatures[i, :] = fastICAComponents[kurtIdx, :] print i, 'Kurtosis: ' +str(kurtS[kurtIdx]), 'S Shape: ' +str(sourceICA.shape), 'Kurt Shape: ' +str(kurtS.shape), 'ICA Shape: ' +str(fastICAComponents.shape) else: print 'Loop ' +str(i)+ ' of ' +str(len(self.Summaries)) icaFeatures[i, :] = numpy.mean(fastICAComponents, axis = 0) except Exception, e: print i, e else: print i, type(features), features.shape, features.size icaFeatures[i, :] = numpy.zeros( (W2V.vector_size,) ) pyplot.figure(), pyplot.imshow(icaFeatures, interpolation = 'none', vmin = 0.0, vmax = 1.0), pyplot.colorbar(), pyplot.show() return icaFeatures
def ICA_reduction(posture, trainblock, componenet): currentdirectory = os.getcwd() # get the directory. parentdirectory = os.path.abspath(currentdirectory + "/../..") # Get the parent directory(2 levels up) path = parentdirectory + '\Output Files\E5-Dimensionality Reduction/posture-'+str(posture)+'/TrainBlock-'+str(trainblock)+'' if not os.path.exists(path): os.makedirs(path) i_user = 1 block = 1 AUC = [] while i_user <= 31: while block <= 6: train_data = np.genfromtxt("../../Output Files/E3-Genuine Impostor data per user per posture/posture-"+str(posture)+"/User-"+str(i_user)+"/1-"+str(i_user)+"-"+str(posture)+"-"+str(trainblock)+"-GI.csv", dtype=float, delimiter=",") test_data = np.genfromtxt("../../Output Files/E3-Genuine Impostor data per user per posture/posture-"+str(posture)+"/User-"+str(i_user)+"/1-"+str(i_user)+"-"+str(posture)+"-"+str(block)+"-GI.csv", dtype=float, delimiter=",") target_train = np.ones(len(train_data)) row = 0 while row < len(train_data): if np.any(train_data[row, 0:3] != [1, i_user, posture]): target_train[row] = 0 row += 1 row = 0 target_test = np.ones(len(test_data)) while row < len(test_data): if np.any(test_data[row, 0:3] != [1, i_user, posture]): target_test[row] = 0 row += 1 sample_train = train_data[:, [3,4,5,6,7,9,11,12,13,14,15,16,17]] sample_test = test_data[:, [3,4,5,6,7,9,11,12,13,14,15,16,17]] scaler = preprocessing.MinMaxScaler().fit(sample_train) sample_train_scaled = scaler.transform(sample_train) sample_test_scaled = scaler.transform(sample_test) ica = FastICA(n_components=componenet, max_iter=150) sample_train_ica = ica.fit(sample_train_scaled).transform(sample_train_scaled) sample_test_ica = ica.transform(sample_test_scaled) clf = ExtraTreesClassifier(n_estimators=100) clf.fit(sample_train_ica, target_train) prediction = clf.predict(sample_test_ica) auc = metrics.roc_auc_score(target_test, prediction) AUC.append(auc) block += 1 block = 1 i_user += 1 print(AUC) AUC = np.array(AUC) AUC = AUC.reshape(31, 6) np.savetxt("../../Output Files/E5-Dimensionality Reduction/posture-"+str(posture)+"/TrainBlock-"+str(trainblock)+"/ICA-"+str(componenet)+"-Component.csv", AUC, delimiter=",")
def calculate_encoder(image, algorithm, patches_size=(DEFAULT_PATCHE_SIZE,DEFAULT_PATCHE_SIZE), projection_dimensios=DEFAULT_PATCHE_SIZE, previous_components=None): """ Gets a higher dimension sparse dictionary.algorithm can be ica, kmeans or colors. """ patches = extract_patches_2d(image, patches_size, calculate_max_number_of_patches(image, patches_size) ) patches = numpy.reshape(patches, (patches.shape[0],-1)).astype(float) encoder = None if algorithm == 'ica': encoder = FastICA(n_components=projection_dimensios, whiten=True, max_iter=10) elif algorithm == 'kmeans': encoder = MiniBatchKMeans(projection_dimensios,compute_labels=False) else: raise Exception('Unknow algorithm %s' % algorithm) encoder.fit(patches) return encoder
def compute_PCA_ICA_NMF(n_components=5): spec_mean = spectra.mean(0) # PCA: use randomized PCA for speed pca = RandomizedPCA(n_components - 1) pca.fit(spectra) pca_comp = np.vstack([spec_mean, pca.components_]) # ICA treats sequential observations as related. Because of this, we need # to fit with the transpose of the spectra ica = FastICA(n_components - 1) ica.fit(spectra.T) ica_comp = np.vstack([spec_mean, ica.transform(spectra.T).T]) # NMF requires all elements of the input to be greater than zero spectra[spectra < 0] = 0 nmf = NMF(n_components) nmf.fit(spectra) nmf_comp = nmf.components_ return pca_comp, ica_comp, nmf_comp
def genW2VFeatures(model, text): modelSet = set(model.index2word) icaFeatures = numpy.zeros( (len(text), model.vector_size) ) fastICA = FastICA(n_components = 32, whiten = True, max_iter=2048, algorithm='deflation') for i in xrange(0, len(text)): textVec = text[i] features = [] for word in textVec: if word in modelSet: features.append(model[word]) features = numpy.asarray(features, dtype = numpy.float32) # featuresNaN = numpy.isnan(features) # featuresInf = numpy.isinf(features) # print (featuresNaN == True), (featuresInf == True) if features.size > 0: U, s, V = numpy.linalg.svd(features, full_matrices=False) SVDComponents = U SVDVar = numpy.cumsum((s)) # pyplot.subplot(1,3,1), pyplot.imshow(U, interpolation = 'none', vmin = 0.0, vmax = 1.0), pyplot.colorbar(), pyplot.subplot(1,3,2), pyplot.imshow(V, interpolation = 'none', vmin = 0.0, vmax = 1.0), pyplot.colorbar(), pyplot.subplot(1,3,3), pyplot.plot(SVDVar), pyplot.show() # print U.shape, V.shape, s.shape try: sourceICA = fastICA.fit(features).transform(features) fastICAComponents = fastICA.components_ if ICAKurt: kurtS = scipy.stats.kurtosis(fastICAComponents, axis = 1) kurtIdx = numpy.argmax(kurtS) icaFeatures[i, :] = fastICAComponents[kurtIdx, :] print i, 'Kurtosis: ' +str(kurtS[kurtIdx]), 'S Shape: ' +str(sourceICA.shape), 'Kurt Shape: ' +str(kurtS.shape), 'ICA Shape: ' +str(fastICAComponents.shape) else: print 'Loop ' +str(i)+ ' of ' +str(len(text)) icaFeatures[i, :] = numpy.mean(fastICAComponents, axis = 0) except Exception, e: print i, e # PCAIdx = numpy.argmax(PCAVar) # icaFeatures[i, :] = PCAComponents[PCAIdx, :] # pyplot.clf(), pyplot.plot(icaFeatures[i, :]), pyplot.show() else: print i, type(features), features.shape, features.size icaFeatures[i, :] = numpy.zeros( (model.vector_size,) )
def do_ica(data, class_label): # ica ica = ICA() result = ica.fit(data).transform(data) plt.plot(result[:, 0], result[:, 1], "o", markersize=7, color="blue", alpha=0.5, label=class_label) plt.xlabel("x_values") plt.ylabel("y_values") plt.xlim([-0.5, 0.5]) plt.ylim([-0.5, 0.5]) plt.legend() plt.title("Transformed samples versus original data") plt.show()
def split_ica(combined_data, label_1, label_2): ica = ICA() result = ica.fit(combined_data).transform(combined_data) plt.plot(result[0:100, 0], result[0:100, 1], "o", markersize=7, color="blue", alpha=0.5, label=label_1) plt.plot(result[100:200, 0], result[100:200, 1], "^", markersize=7, color="red", alpha=0.5, label=label_2) plt.xlabel("x_values") plt.ylabel("y_values") plt.xlim([-0.3, 0.3]) plt.ylim([-0.3, 0.3]) plt.legend() # plt.title('Transformed samples with class labels from matplotlib.mlab.PCA()') plt.show() return result
def myICA(self): # Now we prepare train_data and test_data. train = np.array(self.train_cells)[:,:50].reshape(-1,400).astype(np.float32) # Size = (2500,400) test = np.array(self.test_cells)[:,50:100].reshape(-1,400).astype(np.float32) # Size = (2500,400) print 'looks good' nn =1000 n_samples = 250 X = np.array(train[(nn):(nn+n_samples),:]) print 'data X shape is ', X.shape # global centering X_centered = X - X.mean(axis=0) self.plotGallery('original images', X[0:6,:], image_shape=(20,20), n_row=2,n_col=3) self.plotGallery('first centered images', X_centered[0:6,:], image_shape=(20,20), n_row=2,n_col=3) # local centering X_centered -= X.mean(axis=1).reshape(n_samples,-1) self.plotGallery('2nd centered images', X_centered[0:6,:], image_shape=(20,20), n_row=2,n_col=3) num_componets = 200 ica = FastICA(n_components = num_componets, whiten = True) newX_centered = ica.fit(X_centered).transform(X_centered) print 'new X centered shape is ', newX_centered.shape img0 = cv2.resize(ica.mean_.reshape(20,20), (0,0), fx =5, fy=5) self.plotGallery('ica original test image set', X[0:6,:], image_shape=(20,20), n_row=2,n_col=3) self.plotGallery('ica components', ica.components_[0:6,:], image_shape=(20,20), n_row=2,n_col=3) #sumImage = np.dot(newX_centered, ica.components_) \ #+ (X.mean(axis=1).reshape(n_samples,-1) +X.mean(axis=0))/10 print ica.mixing_.shape print newX_centered.shape print ica.mean_.shape print 'Is components matrix equivalent to mixing matrix after transpose? Based on this testing, the answer is', np.allclose(ica.mixing_.T, ica.components_) sumImage = np.dot(newX_centered, ica.mixing_.T) +ica.mean_ print newX_centered.shape print ica.components_.shape print sumImage.shape self.plotGallery('ica sum images', sumImage[0:6,:], image_shape=(20,20), n_row=2,n_col=3) print 'the conclusion of this ICA test is that to reconstruct the image, we should use the dot product of the image transformation and the mixing matrix instead of components, also we should add the mean back' self.printALine()
def RunICAScikit(q): totalTimer = Timer() # Load input dataset. data = np.genfromtxt(self.dataset, delimiter=',') s = re.search('-s (\d+)', options) s = 0 if not s else int(s.group(1)) try: # Perform ICA. with totalTimer: model = FastICA(random_state=s) ic = model.fit(data).transform(data) mixing = model.get_mixing_matrix() except Exception as e: q.put(-1) return -1 time = totalTimer.ElapsedTime() q.put(time) return time
def plot_3d(res, label, ca1_label, cell_colors, cell_labels): pca = PCA() X = res S_pca = pca.fit(X).transform(X) ica = FastICA() S_ica = ica.fit(X).transform(X) S_ica /= S_ica.std(axis=0) fig = plt.figure() #ax = fig.add_subplot(111, projection='3d') ax = Axes3D(fig) plot_data = [] plot_data.append(res[~label[:,0] & ~label[:,1] & ca1_label]) plot_data.append(res[label[:,0] & ~label[:,1] & ca1_label]) plot_data.append(res[~label[:,0] & label[:,1] & ca1_label]) plot_data.append(res[label[:,0] & label[:,1] & ca1_label]) plot_data.append(res[~ca1_label]) for plot, color, label in zip(plot_data, cell_colors, cell_labels): ax.scatter(plot[:,0], plot[:,1], plot[:,2], c=color, s=args.cell_diameter / 2, label=label, marker=".", edgecolors=color) axis_list = [pca.components_.T, ica.mixing_] colors = ['orange', 'red'] source = [0,0,0] res_mean = res.mean(axis=0) source_list = [] for i in range(3): source_list.append(np.array([res_mean[i]] * 3)) for color, axis in zip(colors, axis_list): axis /= np.sqrt(np.sum(axis ** 2, axis=0)) #axis *= res.std() x,y,z = axis l = 200 #pca_axis = ax.quiver(source_list[0] + l*x, source_list[1] + l*y, source_list[2]+l*z,x,y,z, color=color, length = l, arrow_length_ratio=0.1) plt.show()