def test_check_X(): from sklearn.mixture.base import _check_X rng = np.random.RandomState(0) n_samples, n_components, n_features = 10, 2, 2 X_bad_dim = rng.rand(n_components - 1, n_features) assert_raise_message(ValueError, 'Expected n_samples >= n_components ' 'but got n_components = %d, n_samples = %d' % (n_components, X_bad_dim.shape[0]), _check_X, X_bad_dim, n_components) X_bad_dim = rng.rand(n_components, n_features + 1) assert_raise_message(ValueError, 'Expected the input data X have %d features, ' 'but got %d features' % (n_features, X_bad_dim.shape[1]), _check_X, X_bad_dim, n_components, n_features) X = rng.rand(n_samples, n_features) assert_array_equal(X, _check_X(X, n_components, n_features))
def test_check_X(): from sklearn.mixture.base import _check_X rng = np.random.RandomState(0) n_samples, n_components, n_features = 10, 2, 2 X_bad_dim = rng.rand(n_components - 1, n_features) assert_raise_message(ValueError, 'Expected n_samples >= n_components ' 'but got n_components = %d, n_samples = %d' % (n_components, X_bad_dim.shape[0]), _check_X, X_bad_dim, n_components) X_bad_dim = rng.rand(n_components, n_features + 1) assert_raise_message(ValueError, 'Expected the input data X have %d features, ' 'but got %d features' % (n_features, X_bad_dim.shape[1]), _check_X, X_bad_dim, n_components, n_features) X = rng.rand(n_samples, n_features) assert_array_equal(X, _check_X(X, n_components, n_features))
def fit(self, X, y=None): """Fit the clustered linear regressor model for a training data set using the EM algorithm. It does n_init instances of the algorithm and keeps the one with the highest complete log-likelyhood. Each initialization of the algorithm runs until convergence or max_iter times. If we enable warm_start, we will have a unique initialisation. Parameters ---------- X : array-like, shape (n_samples, n_features) y : array, shape (n_samples, 1) Returns ------- self """ # Check that all the data is well conditioned print('ESTÁ A 0') X = _check_X(X, self.n_components) n_samples, n_features = X.shape y = self._check_y(y, n_samples) self._check_initial_parameters(X) random_state = check_random_state(self.random_state) # Extended X with a column of ones for the bias terms: X_ext = np.concatenate((np.ones((n_samples, 1)), X), axis=1) # If we enable warm_start, we will have a unique initialisation do_init = not (self.warm_start and hasattr(self, 'converged_')) n_init = self.n_init if do_init else 1 max_lower_bound = -np.infty self.converged_ = False init = 0 while init < n_init: self._print_verbose_msg_init_beg(init) if do_init: try: self._initialize(X, X_ext, y, random_state) except (ValueError, linalg.LinAlgError) as error: print("Bad conditions at init. Error type:") print(error) print("Please try a different initialisation strategy.") sys.exit self.lower_bound_ = -np.infty init += 1 for n_iter in range(self.max_iter): prev_lower_bound = self.lower_bound_ # EM steps (log_sum_gamma, log_resp, log_mix_probabilities, log_reg_probabilities) = self._log_e_step_supervised( X, X_ext, y) self.log_resp_ = log_resp self.log_mix_probabilities_ = log_mix_probabilities self.log_reg_probabilities_ = log_reg_probabilities try: self._m_step_supervised(X, X_ext, y, np.exp(log_resp)) except (ValueError, linalg.LinAlgError) as error: print("Bad conditions at execution. Error type:") print(error) print("Resetting initialisation {}.".format(init)) init -= 1 break # Compute log likelyhood self.lower_bound_ = self._compute_log_lower_bound( log_sum_gamma) # Check convergence change = abs(self.lower_bound_ - prev_lower_bound) self._print_verbose_msg_iter_end(n_iter, change) if change < self.tol: self.converged_ = True break self._print_verbose_msg_init_end(self.lower_bound_) # If there is an improvement over the last best initialization, save data if self.lower_bound_ > max_lower_bound: max_lower_bound = self.lower_bound_ best_params = self._get_parameters() best_n_iter = n_iter self.labels_ = self.log_resp_.argmax(axis=1) self.X_labels_ = self.log_mix_probabilities_.argmax(axis=1) self.y_labels_ = self.log_reg_probabilities_.argmax(axis=1) if not self.converged_: warnings.warn( 'Initialization %d did not converge. ' 'Try different init parameters, ' 'or increase max_iter, tol ' 'or check for degenerate data.' % (init + 1), ConvergenceWarning) self._set_parameters(best_params) self.n_iter_ = best_n_iter return self
def fit( self, X, y=None ): # replace to iterative formula using super ._e_step() and overrided ._m_step() 3.5 X = _check_X(X, self.n_components) self._check_initial_parameters(X) # if we enable warm_start, we will have a unique initialisation do_init = not (self.warm_start and hasattr(self, 'converged_')) n_init = self.n_init if do_init else 1 max_lower_bound = -np.infty self.converged_ = False random_state = check_random_state(self.random_state) n_samples, _ = X.shape for init in range(n_init): self._print_verbose_msg_init_beg(init) if do_init: self._initialize_parameters(X, random_state) self.lower_bound_ = -np.infty for n_iter in range(self.max_iter): # ARD EM prev_lower_bound = self.lower_bound_ log_prob_norm, log_resp = self._e_step(X) resp = np.exp(log_resp) self._m_step(X, resp) # resp : array-like, shape (n_samples, n_components) # The responsibilities for each data sample in X. # update covariance F = np.diag(1. / (np.dot(resp, self.weights_)**2)) # F = (1./(np.diag(np.dot(resp, self.weights_)) + 1e-4)) ** 2 # array-like, shape (n_samples, n_samples) A = np.diag(self.reg_weights_ ) # array-like, shape (n_components, n_components) H = np.dot(np.dot(resp.T, F), resp) + A S = np.vstack([ np.diag(np.ones(self.n_components - 1)), -1.0 * np.ones(self.n_components - 1) ]) Sigma = np.linalg.inv(np.dot(np.dot(S.T, H), S)) idx = np.arange(self.n_components - 1) # update weights self.reg_weights_ = np.hstack([ (1 - self.reg_weights_[idx] * Sigma[idx, idx]) / (self.weights_[idx]**2), (1 - self.reg_weights_[-1] * Sigma.sum()) / self.weights_[-1]**2 ]) # drop extra components keep_idx = np.argwhere( np.logical_and( self.reg_weights_ < self.alpha_bound, self.weights_ > self.weight_bound)).squeeze() if len(keep_idx) > 0: self.weights_ = self.weights_[keep_idx] self.reg_weights_ = self.reg_weights_[keep_idx] self.means_ = self.means_[keep_idx, :] if self.covariance_type != 'tied': self.covariances_ = self.covariances_[keep_idx] self.precisions_cholesky_ = self.precisions_cholesky_[ keep_idx] self.n_components = keep_idx.shape[0] # early stop cryterium self.lower_bound_ = self._compute_lower_bound( log_resp, log_prob_norm) change = self.lower_bound_ - prev_lower_bound self._print_verbose_msg_iter_end(n_iter, change) if abs(change) < self.tol and len(keep_idx) > 0: self.converged_ = True break self._print_verbose_msg_init_end(self.lower_bound_) if self.lower_bound_ > max_lower_bound: max_lower_bound = self.lower_bound_ best_params = self._get_parameters() best_n_iter = n_iter if not self.converged_: warnings.warn( 'Initialization %d did not converge. ' 'Try different init parameters, ' 'or increase max_iter, tol ' 'or check for degenerate data.' % (init + 1), ConvergenceWarning) self._set_parameters(best_params) self.n_iter_ = best_n_iter return self
def fit(self, X_arr, y=None): """Estimate model parameters with the EM algorithm. Modified to do cotraining. The method fit the model `n_init` times and set the parameters with which the model has the largest likelihood or lower bound. Within each trial, the method iterates between E-step and M-step for `max_iter` times until the change of likelihood or lower bound is less than `tol`, otherwise, a `ConvergenceWarning` is raised. Parameters ---------- X_arr : array-like, shape (n_diff_data_sources) Each array-like, shape (n_samples, n_features) List of n_features-dimensional data points. Each row corresponds to a single data point. Returns ------- self """ print("Fitting with co-training...") for i, X in enumerate(X_arr): X = _check_X(X, self.n_components) self._check_initial_parameters(X) X_arr[i] = X # if we enable warm_start, we will have a unique initialisation do_init = not (self.warm_start and hasattr(self, 'converged_')) n_init = self.n_init if do_init else 1 max_lower_bound = -np.infty self.converged_ = False random_state = check_random_state(self.random_state) n_samples, _ = X_arr[0].shape for init in range(n_init): self._print_verbose_msg_init_beg(init) if do_init: self._initialize_parameters(X, random_state) self.lower_bound_ = -np.infty for n_iter in range(self.max_iter): # With co-training, each iteration goes thru each data source prev_lower_bound = self.lower_bound_ for X in X_arr: log_prob_norm, log_resp = self._e_step(X) self._m_step(X, log_resp) # use log_resp and log_prob_norm from last data src self.lower_bound_ = self._compute_lower_bound( log_resp, log_prob_norm) change = self.lower_bound_ - prev_lower_bound self._print_verbose_msg_iter_end(n_iter, change) if abs(change) < self.tol: self.converged_ = True break self._print_verbose_msg_init_end(self.lower_bound_) if self.lower_bound_ > max_lower_bound: max_lower_bound = self.lower_bound_ best_params = self._get_parameters() best_n_iter = n_iter if not self.converged_: warnings.warn( 'Initialization %d did not converge. ' 'Try different init parameters, ' 'or increase max_iter, tol ' 'or check for degenerate data.' % (init + 1), ConvergenceWarning) self._set_parameters(best_params) self.n_iter_ = best_n_iter return self