Here are the examples of the python api numpy.in1d.all taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
4 Examples
0
Example 1
Project: lhcb_trigger_ml Source File: metrics_utils.py
def check_metrics_arguments(y_true, y_pred, sample_weight, two_class=True, binary_pred=True):
"""
Checks the arguments passed to metrics
:param y_true:
:param y_pred:
:param sample_weight:
:param two_class:
:param binary_pred:
:return:
"""
sample_weight = check_sample_weight(y_true, sample_weight=sample_weight)
y_true = column_or_1d(y_true)
y_pred = column_or_1d(y_pred)
assert len(y_true) == len(y_pred), \
'The lengths of y_true and y_pred are different: %i and %i' % (len(y_true), len(y_pred))
if two_class:
assert numpy.in1d(y_true, [0, 1]).all(), 'The y_true array should contain only two labels: 0 and 1, ' \
'it contains:' + str(numpy.unique(y_true))
if binary_pred:
assert numpy.in1d(y_pred, [0, 1]).all(), 'The y_pred array should contain only two labels: 0 and 1, ' \
'it contains:' + str(numpy.unique(y_pred))
return y_true, y_pred, sample_weight
0
Example 2
def fit(self, X, y, sample_weight=None, neighbours_matrix=None):
"""Build a boosted classifier from the training set (X, y).
Parameters
----------
X : array-like of shape = [n_samples, n_features]
The training input samples.
y : array-like of shape = [n_samples]
The target values (integers that correspond to classes).
sample_weight : array-like of shape = [n_samples], optional
Sample weights. If None, the sample weights are initialized to
``1 / n_samples``.
neighbours_matrix: array-like of shape [n_samples, n_neighbours],
each row contains indices of signal neighbours
(neighbours should be computed for background too),
if None, this matrix is computed.
Returns
-------
self : object
Returns self.
"""
if self.smoothing < 0:
raise ValueError("Smoothing must be non-negative")
if not isinstance(self.base_estimator, BaseEstimator):
raise TypeError("estimator must be a subclass of BaseEstimator")
if self.n_estimators <= 0:
raise ValueError("n_estimators must be greater than zero.")
if self.learning_rate <= 0:
raise ValueError("learning_rate must be greater than zero")
# Check that algorithm is supported
if self.algorithm not in ('SAMME', 'SAMME.R'):
raise ValueError("algorithm %s is not supported"
% self.algorithm)
if self.algorithm == 'SAMME.R':
if not hasattr(self.base_estimator, 'predict_proba'):
raise TypeError(
"uBoostBDT with algorithm='SAMME.R' requires "
"that the weak learner have a predict_proba method.\n"
"Please change the base estimator or set "
"algorithm='SAMME' instead.")
assert np.in1d(y, [0, 1]).all(), \
"only two-class classification is implemented"
self.signed_uniform_label = 2 * self.uniform_label - 1
if neighbours_matrix is not None:
assert np.shape(neighbours_matrix) == (len(X), self.n_neighbors), \
"Wrong shape of neighbours_matrix"
self.knn_indices = neighbours_matrix
else:
assert self.uniform_variables is not None, \
"uniform_variables should be set"
self.knn_indices = computeKnnIndicesOfSameClass(
self.uniform_variables, X, y, self.n_neighbors)
if sample_weight is None:
# Initialize weights to 1 / n_samples
sample_weight = np.ones(len(X), dtype=np.float) / len(X)
else:
# Normalize existing weights
assert np.all(sample_weight >= 0.), \
'the weights should be non-negative'
sample_weight /= np.sum(sample_weight)
# Clear any previous fit results
self.estimators_ = []
self.estimator_weights_ = []
# score cuts correspond to
# global efficiency == target_efficiency on each iteration.
self.score_cuts_ = []
X_train_variables = self.get_train_vars(X)
y = column_or_1d(y)
X_train_variables, y = check_arrays(X_train_variables, y)
# A dictionary to keep all intermediate weights, efficiencies and so on
if self.keep_debug_info:
self.debug_dict = defaultdict(list)
self.random_generator = check_random_state(self.random_state)
self._boost(X_train_variables, y, sample_weight)
self.score_cut = self.signed_uniform_label * compute_bdt_cut(
self.target_efficiency, y == self.uniform_label, self.predict_score(X) * self.signed_uniform_label)
assert np.allclose(self.score_cut, self.score_cuts_[-1], rtol=1e-10, atol=1e-10), \
"score cut doesn't appear to coincide with the staged one"
assert len(self.estimators_) == len(self.estimator_weights_) == len(self.score_cuts_)
return self
0
Example 3
def fit(self, X, y, sample_weight=None):
if self.uniform_variables is None:
raise ValueError("Please set uniform variables")
if len(self.uniform_variables) == 0:
raise ValueError("The set of uniform variables cannot be empty")
if len(X) != len(y):
raise ValueError("Different size of X and y")
assert np.in1d(y, [0, 1]).all(), \
"only two-class classification is implemented"
X_train_vars = self.get_train_vars(X)
if self.smoothing is None:
self.smoothing = 10. / self.efficiency_steps
neighbours_matrix = computeKnnIndicesOfSameClass(
self.uniform_variables, X, y, n_neighbours=self.knn)
self.target_efficiencies = np.linspace(0, 1, self.efficiency_steps + 2)[1:-1]
self.classifiers = []
for efficiency in self.target_efficiencies:
classifier = uBoostBDT(
uniform_variables=self.uniform_variables,
uniform_label=self.uniform_label,
train_variables=None,
target_efficiency=efficiency, n_neighbors=self.knn,
n_estimators=self.n_estimators,
base_estimator=self.base_estimator,
random_state=self.random_state, bagging=self.bagging,
smoothing=self.smoothing, algorithm=self.algorithm)
self.classifiers.append(classifier)
self.classifiers = map_on_cluster(self.ipc_profile,
_train_classifier,
self.classifiers,
self.efficiency_steps * [X_train_vars],
self.efficiency_steps * [y],
self.efficiency_steps * [sample_weight],
self.efficiency_steps * [neighbours_matrix])
return self
0
Example 4
Project: scikit-tensor Source File: core.py
def check_multiplication_dims(dims, N, M, vidx=False, without=False):
dims = array(dims, ndmin=1)
if len(dims) == 0:
dims = arange(N)
if without:
dims = setdiff1d(range(N), dims)
if not np.in1d(dims, arange(N)).all():
raise ValueError('Invalid dimensions')
P = len(dims)
sidx = np.argsort(dims)
sdims = dims[sidx]
if vidx:
if M > N:
raise ValueError('More multiplicants than dimensions')
if M != N and M != P:
raise ValueError('Invalid number of multiplicants')
if P == M:
vidx = sidx
else:
vidx = sdims
return sdims, vidx
else:
return sdims