def bonus(): """ Plots first eigenfunctions versus other via datafold package. """ nr_samples = 5000 # reduce number of points for plotting nr_samples_plot = 1000 idx_plot = np.random.permutation(nr_samples)[0:nr_samples_plot] # generate point cloud X, X_color =make_swiss_roll(nr_samples, noise=0.0, random_state=None) X_pcm = pfold.PCManifold(X) X_pcm.optimize_parameters(result_scaling=0.5) print(f'epsilon={X_pcm.kernel.epsilon}, cut-off={X_pcm.cut_off}') dmap = dfold.DiffusionMaps(kernel=pfold.GaussianKernel(epsilon=X_pcm.kernel.epsilon), n_eigenpairs=9, dist_kwargs=dict(cut_off=X_pcm.cut_off)) dmap = dmap.fit(X_pcm) evecs, evals = dmap.eigenvectors_, dmap.eigenvalues_ print(evecs.shape) print(evals.shape) plot_pairwise_eigenvector(eigenvectors=dmap.eigenvectors_[idx_plot, :], n=1, fig_params=dict(figsize=[15, 15]), scatter_params=dict(cmap=plt.cm.Spectral, c=X_color[idx_plot])) plt.show()
def bonus_task(n=1000): """ Load the swissroll dataset and perform datafold analysis """ X = swissroll_dataset(n) X_color = swissroll_color(X) idx_plot = np.random.permutation(n)[0:n] # Optimize kernel parameters X_pcm = pfold.PCManifold(X) X_pcm.optimize_parameters() print(f"epsilon={X_pcm.kernel.epsilon}, cut-off={X_pcm.cut_off}") dmap = dfold.DiffusionMaps( kernel=pfold.GaussianKernel(epsilon=X_pcm.kernel.epsilon), n_eigenpairs=9, dist_kwargs=dict(cut_off=X_pcm.cut_off), ) dmap = dmap.fit(X_pcm) evecs, evals = dmap.eigenvectors_, dmap.eigenvalues_ plot_pairwise_eigenvector( eigenvectors=dmap.eigenvectors_[idx_plot, :], n=1, fig_params=dict(figsize=[15, 15]), scatter_params=dict(cmap=plt.cm.Spectral, c=X_color[idx_plot]), ) plt.show()
def forward(self, x): x = x.view(16, -1) X_pcm = pfold.PCManifold(x) X_pcm.optimize_parameters(result_scaling=2) dmap = DiffusionMaps( kernel=pfold.GaussianKernel(epsilon=X_pcm.kernel.epsilon), n_eigenpairs=6, dist_kwargs=dict(cut_off=X_pcm.cut_off)) dmap = dmap.fit(X_pcm) dmap = dmap.set_coords([1, 2]) X_pcm = dmap.transform(X_pcm) x = x.view(-1, 3 * 32 * 32) # print(x.shape) x = self.fc(x) return x
def forward(self, x): #print(x.shape) x = x.view(500, -1) X_pcm = pfold.PCManifold(x) X_pcm.optimize_parameters(result_scaling=2) dmap = DiffusionMaps( kernel=pfold.GaussianKernel(epsilon=X_pcm.kernel.epsilon), n_eigenpairs=10, dist_kwargs=dict(cut_off=X_pcm.cut_off)) dmap = dmap.fit(X_pcm) dmap = dmap.set_coords([1, 2, 3]) X_pcm = dmap.transform(X_pcm) X_pcm = torch.from_numpy(X_pcm).float() #print(X_pcm.shape) x = X_pcm.view(-1, 3) x = self.fc(x) return x
def datafold_swiss_roll(n_samples): X, color = make_swiss_roll(n_samples) X_pcm = pfold.PCManifold(X) X_pcm.optimize_parameters(result_scaling=0.5) print(f'epsilon={X_pcm.kernel.epsilon}, cut-off={X_pcm.cut_off}') dmap = dfold.DiffusionMaps(kernel=pfold.GaussianKernel(epsilon=X_pcm.kernel.epsilon), n_eigenpairs=9, dist_kwargs=dict(cut_off=X_pcm.cut_off)) dmap = dmap.fit(X_pcm) evecs, evals = dmap.eigenvectors_, dmap.eigenvalues_ plot_pairwise_eigenvector(eigenvectors=dmap.eigenvectors_, n=1, fig_params=dict(figsize=[15, 15]), scatter_params=dict(cmap=plt.cm.Spectral, c=color)) plt.savefig(f'T3_datafold_lib_{n_samples}.png') plt.show()
def Lift(method, X_trainingSet, X_testSet, eig_trainingSet, eig_Simulation, **kwargs): """ Function to perform lifting :param method: available methods are 'GH' : Geometric Harmonics 'LP' : Laplacial Pyramids 'KR' : Kriging (GPRs) 'SI' : Simple knn interpolation 'RBF' : Radial Basis Functions interpolation :param X_trainingSet: input high-dimensional space data (X), training set :param X_testSet: high-dimensional space data (X), test set :param eig_trainingSet: low-dimensional (embedded) space parsimonious eigenvectors (Y), training set :param eig_Simulation: low-dimensional (embedded) space parsimonious eigenvectors (Y), predicted (by a specific forecasting methodogy, e.g. VAR(3)) set :param knn: input neighbors used for the lifting :return: [extrapolatedPsi_to_X, mse, rmse, residual] extrapolatedPsi_to_X : lifted data mse : mean-squared error between the [extrapolatedPsi_to_X and X_testSet] rmse : corresponding roor-mean-squared-error residual : residuals of the lifting process """ if "lift_optParams_knn" in kwargs: lift_optParams_knn = kwargs["lift_optParams_knn"] else: lift_optParams_knn = 50 #previously default was 25 (the one in datafold module as well) if "GH_epsilon" in kwargs: GH_epsilon = kwargs["GH_epsilon"] else: GH_epsilon = "opt" if "GH_cut_off" in kwargs: GH_cut_off = kwargs["GH_cut_off"] else: GH_cut_off = "opt" if method == 'GH': pcm = pfold.PCManifold(eig_trainingSet) pcm.optimize_parameters(random_state=0, k=lift_optParams_knn) if GH_epsilon == "opt": GH_epsilon = pcm.kernel.epsilon if GH_cut_off == "opt": GH_cut_off = pcm.cut_off #opt_n_eigenpairs = eig_trainingSet.shape[0]-1 opt_n_eigenpairs = eig_trainingSet.shape[1] # Official (Paper) gh_interpolant_psi_to_X = GHI(pfold.GaussianKernel(epsilon=GH_epsilon), n_eigenpairs=opt_n_eigenpairs, dist_kwargs=dict(cut_off=GH_cut_off)) print("fit ... ") gh_interpolant_psi_to_X.fit(eig_trainingSet, X_trainingSet) residual = gh_interpolant_psi_to_X.score(eig_trainingSet, X_trainingSet) print("predict ... ") extrapolatedPsi_to_X = gh_interpolant_psi_to_X.predict(eig_Simulation) print("extrapolatedPsi_to_X.shape = ", extrapolatedPsi_to_X.shape) # print("opt_epsilon = ", opt_epsilon) # print("opt_cutoff = ", opt_cutoff) "Optimize Parameters using BayesianCV" """ n_iters = 5 np.random.seed(random_state) train_indices, test_indices = train_test_split( np.random.permutation(X_trainingSet.shape[0]), train_size=2 / 3, test_size=1 / 3 ) class GHIGauss(GHI): def __init__(self, epsilon=1, n_eigenpairs=2, cut_off=np.inf): self.epsilon = epsilon self.n_eigenpairs = n_eigenpairs self.cut_off = cut_off super(GHIGauss, self).__init__( kernel=pfold.GaussianKernel(self.epsilon), n_eigenpairs=self.n_eigenpairs, is_stochastic=False, dist_kwargs=dict(cut_off=self.cut_off), ) opt = BayesSearchCV( GHIGauss(), { "epsilon": Real( pcm.kernel.epsilon / 2, pcm.kernel.epsilon * 2, prior="log-uniform" ), "cut_off": Real(pcm.cut_off / 2, pcm.cut_off * 2, prior="uniform"), "n_eigenpairs": Integer(10, 1000, prior="uniform"), }, n_iter=n_iters, random_state=0, scoring=lambda estimator, x, y: estimator.score( x, y, multioutput="uniform_average" ), # is to be maximized cv=[[train_indices, test_indices]], refit=False, # we cannot refit to the entire dataset because this would alter the optimal kernel scale ) # run the Bayesian optimization opt.fit(eig_trainingSet, X_trainingSet) # get best model and results from parameter search # refit best parameter set on training set (not entire dataset - the parameters are optimized for the training set!) optimal_GHI = GHIGauss(**opt.best_params_).fit( eig_trainingSet[train_indices, :], X_trainingSet[train_indices, :] ) print( f"Previous epsilon: {pcm.kernel.epsilon}, cut-off: {pcm.cut_off}, #eigenpairs: {opt_n_eigenpairs}" ) print( f"Optimal epsilon: {optimal_GHI.epsilon}, cut-off: {optimal_GHI.cut_off}, #eigenpairs: {optimal_GHI.n_eigenpairs}" ) extrapolatedPsi_to_X = optimal_GHI.predict(eig_Simulation) """ elif method == 'LP': lpyr_interpolant_psi_to_X = LPI(auto_adaptive=True) lpyr_interpolant_psi_to_X.fit(eig_trainingSet, X_trainingSet) residual = lpyr_interpolant_psi_to_X.score(eig_trainingSet, X_trainingSet) extrapolatedPsi_to_X = lpyr_interpolant_psi_to_X.predict( eig_Simulation) elif method == 'KR': mainKernel_Kriging_GP = 1 * ConstantKernel() + 1 * ExpSineSquared( ) + 1 * Matern() + 1 * WhiteKernel() # Official (29/8/2021) gpr_model = GaussianProcessRegressor(kernel=mainKernel_Kriging_GP, normalize_y=True) gpr_model_fit = gpr_model.fit(eig_trainingSet, X_trainingSet) residual = gpr_model_fit.score(eig_trainingSet, X_trainingSet) extrapolatedPsi_to_X = gpr_model_fit.predict(eig_Simulation) elif method == 'SI': # Simple Linear ND Interpolator knn_interpolator = NearestNDInterpolator(eig_trainingSet, X_trainingSet) extrapolatedPsi_to_X = knn_interpolator(eig_Simulation) residual = extrapolatedPsi_to_X - X_testSet elif method == "RBF": print("lift_optParams_knn = ", lift_optParams_knn) extrapolatedPsi_to_X = RBFInterpolator(eig_trainingSet, X_trainingSet, kernel="linear", degree=1, neighbors=lift_optParams_knn, epsilon=1)(eig_Simulation) residual = extrapolatedPsi_to_X - X_testSet return [extrapolatedPsi_to_X, residual]
def Embed(method, X_train_local, target_intrinsic_dim, **kwargs): """ Function to embed input data using a specific embedding method :param method: DM, LLE or PCA :param X_train_local: X to embed :param target_intrinsic_dim: how many parsimonious coordinates :param kwargs: LLE_neighbors, dm_epsilon : either a specific value, or if zero it is internally optimized :return [target_mapping, parsimoniousEigs, X_pcm.kernel.epsilon, eigValsOut]: target_mapping --> the mapped data parsimoniousEigs (str) --> the indexes of the parsimonious coordinates X_pcm.kernel.epsilon --> optimized epsilon value eigValsOut --> corresponding eigenvalues """ if "LLE_neighbors" in kwargs: LLE_neighbors = kwargs["LLE_neighbors"] else: LLE_neighbors = 50 if "dm_optParams_knn" in kwargs: dm_optParams_knn = kwargs["dm_optParams_knn"] else: dm_optParams_knn = 50 #previously default was 25 (the one in datafold module as well) if "dm_epsilon" in kwargs: dm_epsilon = kwargs["dm_epsilon"] else: dm_epsilon = "opt" if "cut_off" in kwargs: cut_off = kwargs["cut_off"] else: cut_off = "opt" if "DM" in method: X_pcm = pfold.PCManifold(X_train_local) X_pcm.optimize_parameters(random_state=0, k=dm_optParams_knn) if dm_epsilon == "opt": dm_epsilon = X_pcm.kernel.epsilon if cut_off == "opt": cut_off = X_pcm.kernel.cut_off if "ComputeParsimonious" in method: if target_intrinsic_dim >= 10: n_eigenpairsIn = target_intrinsic_dim + 1 else: n_eigenpairsIn = 10 else: n_eigenpairsIn = target_intrinsic_dim dmap_local = dfold.DiffusionMaps( kernel=pfold.GaussianKernel(epsilon=dm_epsilon), n_eigenpairs=n_eigenpairsIn, dist_kwargs=dict(cut_off=cut_off)) dmap_local = dmap_local.fit(X_pcm) # evecs_raw, evals_raw = dmap.eigenvectors_, dmap.eigenvalues_ if "ComputeParsimonious" in method: if X_train_local.shape[0] < 500: n_subsampleIn = X_train_local.shape[0] - 1 else: n_subsampleIn = 500 selection = LocalRegressionSelection( intrinsic_dim=target_intrinsic_dim, n_subsample=n_subsampleIn, strategy="dim").fit(dmap_local.eigenvectors_) # print("selection.evec_indices_ = ", selection.evec_indices_) parsimoniousEigs = ",".join( [str(x) for x in selection.evec_indices_]) target_mapping = selection.transform(dmap_local.eigenvectors_) # print("target_mapping.shape = ", target_mapping.shape) eigValsOut = dmap_local.eigenvalues_[selection.evec_indices_] else: parsimoniousEigs = "first" target_mapping = dmap_local.eigenvectors_ eigValsOut = dmap_local.eigenvalues_ out = [ target_mapping, parsimoniousEigs, X_pcm.kernel.epsilon, eigValsOut ] elif "LLE" in method: lle = manifold.LocallyLinearEmbedding( n_neighbors=LLE_neighbors, n_components=target_intrinsic_dim, method="standard", n_jobs=-1) target_mapping = lle.fit_transform(X_train_local) out = [target_mapping, "none", 1, []] elif "PCA" in method: pca = PCA(n_components=target_intrinsic_dim) evecs = pca.fit_transform(X_train_local.T) evals = pca.singular_values_ explainedVarianceRatio = pca.explained_variance_ratio_ target_mapping = pca.components_.T out = [target_mapping, ",".join(evecs), explainedVarianceRatio, evals] return out
noise=0) # plot fig = plt.figure(figsize=(10, 10)) ax = fig.add_subplot(111, projection="3d") ax.scatter(data[idx_plot, 0], data[idx_plot, 1], data[idx_plot, 2], c=data_color[idx_plot], cmap=plt.cm.Spectral) ax.set_xlabel("x") ax.set_ylabel("y") ax.set_zlabel("z") ax.set_title("point cloud on S-shaped manifold") ax.view_init(10, 70) plt.show() data_pcm = pfold.PCManifold(data) data_pcm.optimize_parameters(result_scaling=0.5) # Plot eigen vectors pair-wise dmap = dfold.DiffusionMaps(kernel=pfold.GaussianKernel(epsilon=data_pcm.kernel.epsilon), n_eigenpairs=9, dist_kwargs=dict(cut_off=data_pcm.cut_off)) dmap = dmap.fit(data_pcm) evecs, evals = dmap.eigenvectors_, dmap.eigenvalues_ plot_pairwise_eigenvector(eigenvectors=dmap.eigenvectors_[idx_plot, :], n=1, fig_params=dict(figsize=[15, 15]), scatter_params=dict(cmap=plt.cm.Spectral, c=data_color[idx_plot])) plt.show()