def score_samples(self, v):
"""Compute the pseudo-likelihood of v.
Parameters
----------
v : {array-like, sparse matrix} shape (n_samples, n_features)
Values of the visible layer.
Returns
-------
pseudo_likelihood : array-like, shape (n_samples,)
Value of the pseudo-likelihood (proxy to likelihood).
print update"""
rng = check_random_state(self.random_state)
fe = self._free_energy(v)
if issparse(v):
v_ = v.toarray()
else:
v_ = v.copy()
i_ = rng.randint(0, v.shape[1], v.shape[0])
v_[np.arange(v.shape[0]), i_] = 1 - v_[np.arange(v.shape[0]), i_]
fe_ = self._free_energy(v_)
#print fe_
#print fe
return v.shape[1] * logistic_sigmoid(fe_ - fe, log=True)
def score_samples(self, X):
"""Compute the pseudo-likelihood of X.
Parameters
----------
X : {array-like, sparse matrix} shape (n_samples, n_features)
Values of the visible layer. Must be all-boolean (not checked).
Returns
-------
pseudo_likelihood : array-like, shape (n_temperatures, n_samples,)
Value of the pseudo-likelihood (proxy for likelihood).
Notes
-----
This method is not deterministic: it computes a quantity called the
free energy on X, then on a randomly corrupted version of X, and
returns the log of the logistic function of the difference.
"""
check_is_fitted(self, "components_")
v = check_array(X, accept_sparse='csr')
rng = check_random_state(self.random_state)
# Randomly corrupt one feature in each sample in v.
ind = (np.arange(v.shape[0]), rng.randint(0, v.shape[1], v.shape[0]))
if issparse(v):
data = -2 * v[ind] + 1
v_ = v + sp.csr_matrix((data.A.ravel(), ind), shape=v.shape)
else:
v_ = v.copy()
v_[ind] = 1 - v_[ind]
fe = self._free_energy(v, 0)
fe_ = self._free_energy(v_, 0)
return v.shape[1] * log_logistic(fe_ - fe)
def init_weights(self, X):
""" If the user specifies the training dataset, it can be useful to
initialize the visibile biases according to the empirical expected
feature values of the training data.
TODO: Generalize this biasing. Currently, the biasing is only written for
the case of binary RBMs.
"""
#
eps = self.thresh
# Mean across samples
if issparse(X):
probVis = sp.csr_matrix.mean(X, axis=0)
else:
probVis = np.mean(X, axis=0)
# safe for CSR / sparse mats ?
# do we need it if we use softmax ?
probVis[probVis < eps] = eps # Some regularization (avoid Inf/NaN)
#probVis[probVis < (1.0-eps)] = (1.0-eps)
self.v_bias = np.log(probVis /
(1.0 - probVis)) # Biasing as the log-proportion
# (does not work)
# self.v_bias = softmax(probVis)
# initialize arrays to 0
self.W = np.asarray(self.random_state.normal(
0, self.sigma, (self.n_components, X.shape[1])),
order='fortran')
self.dW_prev = np.zeros_like(self.W)
self.W2 = self.W * self.W
return 0
def score_samples(self, v):
"""Compute the pseudo-likelihood of v.
Parameters
----------
v : {array-like, sparse matrix} shape (n_samples, n_features)
Values of the visible layer.
Returns
-------
pseudo_likelihood : array-like, shape (n_samples,)
Value of the pseudo-likelihood (proxy to likelihood).
print update"""
rng = check_random_state(self.random_state)
fe = self._free_energy(v)
if issparse(v):
v_ = v.toarray()
else:
v_ = v.copy()
i_ = rng.randint(0, v.shape[1], v.shape[0])
v_[np.arange(v.shape[0]), i_] = 1 - v_[np.arange(v.shape[0]), i_]
fe_ = self._free_energy(v_)
#print fe_
#print fe
return v.shape[1] * logistic_sigmoid(fe_ - fe, log=True)
def decode(self, vec, pretty=False, strict=True):
# TODO: Whether we should use 'strict' mode depends on whether the model
# we got this vector from does softmax sampling of visibles. Anywhere this
# is called on fantasy samples, we should use the model to set this param.
if issparse(vec):
vec = vec.toarray().reshape(-1)
assert vec.shape == (self.nchars * self.maxlen, )
chars = []
for position_index in range(self.maxlen):
# Hack - insert a tab between name parts in binomial mode
if isinstance(self, BinomialShortTextCodec
) and pretty and position_index == self.maxlen / 2:
chars.append('\t')
subarr = vec[position_index * self.nchars:(position_index + 1) *
self.nchars]
if np.count_nonzero(subarr) != 1 and strict:
char = self.MYSTERY
else:
char_index = np.argmax(subarr)
char = self.alphabet[char_index]
if pretty and char == self.FILLER:
# Hack
char = ' ' if isinstance(self,
BinomialShortTextCodec) else ''
chars.append(char)
return ''.join(chars)
def corrupt(self, v):
# Randomly corrupt one feature in each sample in v.
ind = (np.arange(v.shape[0]),
self.rng_.randint(0, v.shape[1], v.shape[0]))
if issparse(v):
data = -2 * v[ind] + 1
v_ = v + sp.csr_matrix((data.A.ravel(), ind), shape=v.shape)
else:
v_ = v.copy()
v_[ind] = 1 - v_[ind]
return v_, None
def corrupt(self, v):
# Randomly corrupt one feature in each sample in v.
ind = (np.arange(v.shape[0]),
self.rng_.randint(0, v.shape[1], v.shape[0]))
if issparse(v):
data = -2 * v[ind] + 1
v_ = v + sp.csr_matrix((data.A.ravel(), ind), shape=v.shape)
else:
v_ = v.copy()
v_[ind] = 1 - v_[ind]
return v_, None
def _corrupt_data(self, v):
self.random_state = check_random_state(self.random_state)
"""Randomly corrupt one feature in each sample in v."""
ind = (np.arange(v.shape[0]),
self.random_state.randint(0, v.shape[1], v.shape[0]))
if issparse(v):
data = -2 * v[ind] + 1
v_ = v + sp.csr_matrix((data.A.ravel(), ind), shape=v.shape)
else:
v_ = v.copy()
v_[ind] = 1 - v_[ind]
return v, v_
def fit(self, X, y=None, sample_weight=None):
X = check_array(X, accept_sparse=['csc'], ensure_2d=False)
if issparse(X):
# Pre-sort indices to avoid that each individual tree of the
# ensemble sorts the indices.
X.sort_indices()
rnd = check_random_state(self.random_state)
y = rnd.uniform(size=X.shape[0])
super(RandomTreesEmbeddingUnsupervised,
self).fit(X, y, sample_weight=sample_weight)
return self
def fit(self, X, y=None, sample_weight=None):
X = check_array(X, accept_sparse=['csc'], ensure_2d=False)
if issparse(X):
# Pre-sort indices to avoid that each individual tree of the
# ensemble sorts the indices.
X.sort_indices()
rnd = check_random_state(self.random_state)
y = rnd.uniform(size=X.shape[0])
super(RandomTreesEmbeddingUnsupervised,
self).fit(X, y, sample_weight=sample_weight)
return self
def fit_transform(self, X, y=None, sample_weight=None):
X = check_array(X, accept_sparse=['csc'], ensure_2d=False)
if issparse(X):
# Pre-sort indices to avoid that each individual tree of the
# ensemble sorts the indices.
X.sort_indices()
self.fit(X, y, sample_weight=sample_weight)
coding = self.apply(X)
if self.use_one_hot:
self.one_hot_encoder_ = OneHotEncoder(sparse=self.sparse_output)
coding = self.one_hot_encoder_.fit_transform(coding)
return coding
def mh_update(self, v, h):
"""update TAP hidden magnetizations, to second order"""
a = safe_sparse_dot(v, self.W.T) + self.h_bias
v_fluc = (v - (np.multiply(v, v)))
#a += (v-v*v).dot((self.W2).T)*(0.5-h)
if issparse(h):
h_half = (0.5 - h.to_dense())
else:
h_half = (0.5 - h)
a += np.multiply(safe_sparse_dot(v_fluc, self.W2.T), h_half)
return expit(a, out=a)
def fit_transform(self, X, y=None, sample_weight=None):
X = check_array(X, accept_sparse=['csc'], ensure_2d=False)
if issparse(X):
# Pre-sort indices to avoid that each individual tree of the
# ensemble sorts the indices.
X.sort_indices()
self.fit(X, y, sample_weight=sample_weight)
coding = self.apply(X)
if self.use_one_hot:
self.one_hot_encoder_ = OneHotEncoder(sparse=self.sparse_output)
coding = self.one_hot_encoder_.fit_transform(coding)
return coding
def mv_update(self, v, h):
"""update TAP visbile magnetizations, to second order"""
# a = np.dot(h, self.W) + self.v_bias
a = safe_sparse_dot(h, self.W) + self.v_bias
h_fluc = h - np.multiply(h, h)
#a += h_fluc.dot(self.W2)*(0.5-v)
# 0.5-v is elementwise => dense
if issparse(v):
v_half = (0.5 - v.todense())
else:
v_half = (0.5 - v)
a += np.multiply(safe_sparse_dot(h_fluc, self.W2), v_half)
return expit(a, out=a)
def expanded_X_y_sample_weights(X,
y_proba,
expand_factor=10,
sample_weight=None,
shuffle=True,
random_state=None):
"""
scikit-learn can't optimize cross-entropy directly if target
probability values are not indicator vectors.
As a workaround this function expands the dataset according to
target probabilities. ``expand_factor=None`` means no dataset
expansion.
"""
rng = check_random_state(random_state)
if expand_factor:
if sample_weight is not None:
X, y, sample_weight = zip(
*expand_dataset(X,
y_proba,
factor=expand_factor,
random_state=rng,
extra_arrays=[sample_weight]))
else:
X, y = zip(*expand_dataset(
X, y_proba, factor=expand_factor, random_state=rng))
else:
y = y_proba.argmax(axis=1)
if isinstance(X, (list, tuple)) and len(X) and issparse(X[0]):
X = vstack(X)
if shuffle:
if sample_weight is not None:
X, y, sample_weight = _shuffle(X,
y,
sample_weight,
random_state=rng)
else:
X, y = _shuffle(X, y, random_state=rng)
return X, y, sample_weight
def decode(self, vec, pretty=False, strict=True):
# TODO: Whether we should use 'strict' mode depends on whether the model
# we got this vector from does softmax sampling of visibles. Anywhere this
# is called on fantasy samples, we should use the model to set this param.
if issparse(vec):
vec = vec.toarray().reshape(-1)
assert vec.shape == (self.nchars * self.maxlen,)
chars = []
for position_index in range(self.maxlen):
# Hack - insert a tab between name parts in binomial mode
if isinstance(self, BinomialShortTextCodec) and pretty and position_index == self.maxlen/2:
chars.append('\t')
subarr = vec[position_index * self.nchars:(position_index + 1) * self.nchars]
if np.count_nonzero(subarr) != 1 and strict:
char = self.MYSTERY
else:
char_index = np.argmax(subarr)
char = self.alphabet[char_index]
if pretty and char == self.FILLER:
# Hack
char = ' ' if isinstance(self, BinomialShortTextCodec) else ''
chars.append(char)
return ''.join(chars)
def score_samples(self, X):
"""Compute the pseudo-likelihood of X.
Parameters
----------
X : {array-like, sparse matrix} shape (n_samples, n_features)
Values of the visible layer. Must be all-boolean (not checked).
Returns
-------
pseudo_likelihood : array-like, shape (n_samples,)
Value of the pseudo-likelihood (proxy for likelihood).
Notes
-----
This method is not deterministic: it computes a quantity called the
free energy on X, then on a randomly corrupted version of X, and
returns the log of the logistic function of the difference.
"""
check_is_fitted(self, "components_")
v = check_array(X, accept_sparse='csr')
rng = check_random_state(self.random_state)
# Randomly corrupt one feature in each sample in v.
ind = (np.arange(v.shape[0]),
rng.randint(0, v.shape[1], v.shape[0]))
if issparse(v):
data = -2 * v[ind] + 1
v_ = v + sp.csr_matrix((data.A.ravel(), ind), shape=v.shape)
else:
v_ = v.copy()
v_[ind] = 1 - v_[ind]
fe = self._free_energy(v)
fe_ = self._free_energy(v_)
return v.shape[1] * log_logistic(fe_ - fe)
def fit(self, X, y, sample_weight=None, sample_var=None):
"""
Fit the forest.
Parameters
----------
X : ndarray or scipy.sparse matrix, (n_samples, n_features)
Input data.
y : array, shape (n_samples, n_outputs)
Target. Will be cast to X's dtype if necessary
sample_weight : numpy array of shape [n_samples]
Individual weights for each sample. Weights will not be normalized. The weighted square loss
will be minimized by the forest.
sample_var : numpy array of shape [n_samples, n_outputs]
Variance of composite samples (not used here. Exists for API compatibility)
Returns
-------
self
"""
# Validate or convert input data
X = check_array(X, accept_sparse="csc", dtype=DTYPE)
y = check_array(y, accept_sparse='csc', ensure_2d=False, dtype=None)
if sample_weight is not None:
sample_weight = check_array(sample_weight, ensure_2d=False)
if issparse(X):
# Pre-sort indices to avoid that each individual tree of the
# ensemble sorts the indices.
X.sort_indices()
# Remap output
self.n_features_ = X.shape[1]
y = np.atleast_1d(y)
if y.ndim == 2 and y.shape[1] == 1:
warn(
"A column-vector y was passed when a 1d array was"
" expected. Please change the shape of y to "
"(n_samples,), for example using ravel().",
DataConversionWarning,
stacklevel=2)
if y.ndim == 1:
# reshape is necessary to preserve the data contiguity against vs
# [:, np.newaxis] that does not.
y = np.reshape(y, (-1, 1))
self.n_outputs_ = y.shape[1]
y, expanded_class_weight = self._validate_y_class_weight(y)
if getattr(y, "dtype", None) != DOUBLE or not y.flags.contiguous:
y = np.ascontiguousarray(y, dtype=DOUBLE)
if expanded_class_weight is not None:
if sample_weight is not None:
sample_weight = sample_weight * expanded_class_weight
else:
sample_weight = expanded_class_weight
if self.subsample_fr == 'auto':
self.subsample_fr_ = (X.shape[0] /
2)**(1 - 1 /
(2 * X.shape[1] + 2)) / (X.shape[0] / 2)
else:
self.subsample_fr_ = self.subsample_fr
# Check parameters
self._validate_estimator()
random_state = check_random_state(self.random_state)
if not self.warm_start or not hasattr(self, "estimators_"):
# Free allocated memory, if any
self.estimators_ = []
n_more_estimators = self.n_estimators - len(self.estimators_)
if n_more_estimators < 0:
raise ValueError('n_estimators=%d must be larger or equal to '
'len(estimators_)=%d when warm_start==True' %
(self.n_estimators, len(self.estimators_)))
elif n_more_estimators == 0:
warn("Warm-start fitting without increasing n_estimators does not "
"fit new trees.")
else:
if self.warm_start and len(self.estimators_) > 0:
# We draw from the random state to get the random state we
# would have got if we hadn't used a warm_start.
random_state.randint(MAX_INT, size=len(self.estimators_))
trees = [
self._make_estimator(append=False, random_state=random_state)
for i in range(n_more_estimators)
]
# Parallel loop: we prefer the threading backend as the Cython code
# for fitting the trees is internally releasing the Python GIL
# making threading more efficient than multiprocessing in
# that case. However, for joblib 0.12+ we respect any
# parallel_backend contexts set at a higher level,
# since correctness does not rely on using threads.
self.n_slices = int(np.ceil((self.n_estimators)**(1 / 2)))
self.slice_len = int(np.ceil(self.n_estimators / self.n_slices))
s_inds = []
# TODO. This slicing should ultimately be done inside the parallel function
# so that we don't need to create a matrix of size roughly n_samples * n_estimators
for it in range(self.n_slices):
half_sample_inds = np.random.choice(X.shape[0],
X.shape[0] // 2,
replace=False)
for _ in np.arange(
it * self.slice_len,
min((it + 1) * self.slice_len, self.n_estimators)):
s_inds.append(half_sample_inds[np.random.choice(
X.shape[0] // 2,
int(np.ceil(self.subsample_fr_ * (X.shape[0] // 2))),
replace=False)])
trees = Parallel(
n_jobs=self.n_jobs,
verbose=self.verbose,
**_joblib_parallel_args(prefer='threads'))(
delayed(_parallel_add_trees)(t,
self,
X,
y,
sample_weight,
s_inds[i],
i,
len(trees),
verbose=self.verbose)
for i, t in enumerate(trees))
# Collect newly grown trees
self.estimators_.extend(trees)
return self
