def test_polynomial_features_csr_X_dim_edges(deg, dim, interaction_only): X_csr = sparse_random(1000, dim, 0.5, random_state=0).tocsr() X = X_csr.toarray() est = PolynomialFeatures(deg, interaction_only=interaction_only) Xt_csr = est.fit_transform(X_csr) Xt_dense = est.fit_transform(X) assert isinstance(Xt_csr, sparse.csr_matrix) assert Xt_csr.dtype == Xt_dense.dtype assert_array_almost_equal(Xt_csr.A, Xt_dense)
def test_polynomial_features_csr_X_zero_row(zero_row_index, deg, interaction_only): X_csr = sparse_random(3, 10, 1.0, random_state=0).tocsr() X_csr[zero_row_index, :] = 0.0 X = X_csr.toarray() est = PolynomialFeatures(deg, include_bias=False, interaction_only=interaction_only) Xt_csr = est.fit_transform(X_csr) Xt_dense = est.fit_transform(X) assert isinstance(Xt_csr, sparse.csr_matrix) assert Xt_csr.dtype == Xt_dense.dtype assert_array_almost_equal(Xt_csr.A, Xt_dense)
def test_polynomial_features_csr_X_floats(deg, include_bias, interaction_only, dtype): X_csr = sparse_random(1000, 10, 0.5, random_state=0).tocsr() X = X_csr.toarray() est = PolynomialFeatures( deg, include_bias=include_bias, interaction_only=interaction_only ) Xt_csr = est.fit_transform(X_csr.astype(dtype)) Xt_dense = est.fit_transform(X.astype(dtype)) assert isinstance(Xt_csr, sparse.csr_matrix) assert Xt_csr.dtype == Xt_dense.dtype assert_array_almost_equal(Xt_csr.A, Xt_dense)
def polynomial_features_csr_X_zero_row(self, zero_row_index, deg, interaction_only): X_csr = sparse_random(3, 10, 1.0, random_state=0).tocsr() X_csr[zero_row_index, :] = 0.0 X = X_csr.toarray() est = ExtendedFeatures(poly_degree=deg, poly_include_bias=False, poly_interaction_only=interaction_only) est.fit(X) poly = PolynomialFeatures(degree=deg, include_bias=False, interaction_only=interaction_only) poly.fit(X) self.assertEqual(poly.get_feature_names(), est.get_feature_names()) Xt_dense1 = est.fit_transform(X) Xt_dense2 = poly.fit_transform(X) self.assertEqual(Xt_dense1, Xt_dense2)
def test_pca(): st_helper = SklearnTestHelper() pca = PCA(n_components=2) rpca = RobustPCA() data = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]], dtype=np.float32) pca.fit(data) rpca.robust_pca_ = pca dshape = (relay.Any(), len(data[0])) _test_model_impl(st_helper, rpca, dshape, data) tSVD = TruncatedSVD(n_components=5, n_iter=7, random_state=42) data = sparse_random( 100, 100, density=0.01, format="csr", dtype="float32", random_state=42 ).toarray() tSVD.fit(data) rpca.robust_pca_ = tSVD dshape = (relay.Any(), len(data[0])) _test_model_impl(st_helper, rpca, dshape, data)
def _sparse_random_pattern(self): """Generate a sparse random pattern for each hidden layer and output class. Args: Returns: """ densities = config.pattern_sparse_random_density if not isinstance(densities, list): densities = [densities] * (self._patterns_to_generate) for i in range(1, 1 + self._patterns_to_generate): ap = sparse_random(self._network.layer_size(i), self.num_patterns, density=densities[i - 1]) ap = np.array(ap.todense()) ap = normalize(ap, norm='l2', axis=0, copy=False) self._patterns.append(ap)
def do_random_transactions(self): assert self.density > 0, "Transactions density is insignificant" balances = self._create_balances() agents_size = balances.shape[0] random_max_transaction_rates = self.max_transaction_rate * np.random.rand(balances.shape[0]) random_total_transaction_rates = sparse_random(agents_size, agents_size, density=self.density) normalized_random_total_transaction_rates = normalize(random_total_transaction_rates, norm='l1', axis=1) total_transaction_amounts = normalized_random_total_transaction_rates.T.multiply(random_max_transaction_rates * balances).T transactions_sended = (total_transaction_amounts > 0) random_comission_rates = self.max_comission_rate * self.create_similar_random_matrix(transactions_sended) comission_amounts = total_transaction_amounts.multiply(random_comission_rates) transaction_amounts = total_transaction_amounts - comission_amounts income = transaction_amounts.sum(axis=0).A1 outcome = transaction_amounts.sum(axis=1).A1 + comission_amounts.sum(axis=1).A1 new_balances = balances + income - outcome total_comission = comission_amounts.sum() self._set_balances(balances) self._set_total_comission(total_comission)
random.shuffle(networks_list) # Define what nodes belong to what network and what their color should be node_network_map = dict(zip(nodes, networks_list)) colors = ['green', 'royalblue', 'red', 'orange', 'cyan'] color_map = dict(zip(networks, colors)) graph = nx.Graph() graph.add_nodes_from(nodes) nodes_by_color = { val: [node for node in graph if color_map[node_network_map[node]] == val] for val in colors } # Take random sparse matrix as adjacency matrix mat = sparse_random(30, 30, density=0.3).todense() for row, row_val in enumerate(nodes): for col, col_val in enumerate(nodes): if col > row and mat[ row, col] != 0.0: # Stick to upper half triangle, mat is not symmetric graph.add_edge(row_val, col_val, weight=mat[row, col]) # Choose a layout to visualize graph # pos = nx.spring_layout(graph) # import ipdb; ipdb.set_trace() pos = partition_layout(graph, node_network_map, ratio=0.15) edges = graph.edges() # Get the edge weights and normalize them weights = [abs(graph[u][v]['weight']) for u, v in edges] weights_n = [5 * float(i) / max(weights)
:param x: X: array-like, shape (n_samples, n_components) :return: X_original: array, shape (n_samples, n_features) """ return self.model.inverse_transform(X=x) def set_params(self,params): self.model.set_params(**params) def transform(self,X): return self.model.transform(X=X) def get_components(self): return self.model.components_ # 数组, shape(n_components, n_features) 数据的维度 def get_explained_variance(self): # 训练样本的方差通过投影转换每个分量 return self.model.explained_variance_ # 数组 shape(n_components) def get_explained_variance_ratio(self): # 每个选定组建解释的方差百分比 return self.model.explained_variance_ratio_ # 数组 shape(n_components) def get_singular_values(self): # 每个选定components 的奇异值 return self.model.singular_values_ # 数组 shape(n_components) if __name__ =="__main__": X = sparse_random(100, 100, density=0.01, format="csr", random_state=42) svd = TSVD(n_components=5, n_iter=7, random_state=42) svd.fit(X) print(svd.get_explained_variance_ratio()) print(svd.get_explained_variance_ratio().sum()) print(svd.get_singular_values())
dataset.head() dataset.Target.value_counts() dataset.Target.value_counts().plot.bar() X = dataset.drop("Target", axis=1) y = dataset["Target"] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1) # >>> from sklearn.decomposition import TruncatedSVD >>> from scipy.sparse import random as sparse_random >>> X = sparse_random(100, 100, density=0.01, format='csr', ... random_state=42) >>> svd = TruncatedSVD(n_components=5, n_iter=7, random_state=42) >>> svd.fit(X) TruncatedSVD(n_components=5, n_iter=7, random_state=42) >>> print(svd.explained_variance_ratio_) >>> print(svd.explained_variance_ratio_.sum()) >>> print(svd.singular_values_) # >>> from sklearn.decomposition import PCA >>> X = np.array([]) >>> pca = PCA(n_components=2) >>> pca.fit(X) PCA(n_components=2) >>> print(pca.explained_variance_ratio_) >>> print(pca.singular_values_) >>> pca = PCA(n_components=2, svd_solver='full')