def _validate_X_predict(
self, X: np.ndarray, check_input: bool) -> np.ndarray:
if check_input:
X = check_array(X, dtype=DTYPE, accept_sparse="csr")
if issparse(X) and (X.indices.dtype != np.intc or
X.indptr.dtype != np.intc):
raise ValueError(
"No support for np.int64 index based sparse matrices")
n_features = X.shape[1]
if self.n_features_ != n_features:
raise ValueError(
"Number of features of the model must match the input."
" Model n_features is %s and input n_features is %s "
% (self.n_features_, n_features))
return X
python类intc()的实例源码
def default(self, obj):
# convert dates and numpy objects in a json serializable format
if isinstance(obj, datetime):
return obj.strftime('%Y-%m-%dT%H:%M:%SZ')
elif isinstance(obj, date):
return obj.strftime('%Y-%m-%d')
elif type(obj) in (np.int_, np.intc, np.intp, np.int8, np.int16,
np.int32, np.int64, np.uint8, np.uint16,
np.uint32, np.uint64):
return int(obj)
elif type(obj) in (np.bool_,):
return bool(obj)
elif type(obj) in (np.float_, np.float16, np.float32, np.float64,
np.complex_, np.complex64, np.complex128):
return float(obj)
# Let the base class default method raise the TypeError
return json.JSONEncoder.default(self, obj)
def _validate_X_predict(self, X, check_input):
"""Validate X whenever one tries to predict, apply, predict_proba"""
if self.tree_ is None:
raise NotFittedError("Estimator not fitted, "
"call `fit` before exploiting the model.")
if check_input:
X = check_array(X, dtype=DTYPE, accept_sparse="csr")
if issparse(X) and (X.indices.dtype != np.intc or
X.indptr.dtype != np.intc):
raise ValueError("No support for np.int64 index based "
"sparse matrices")
n_features = X.shape[1]
if self.n_features_ != n_features:
raise ValueError("Number of features of the model must "
"match the input. Model n_features is %s and "
"input n_features is %s "
% (self.n_features_, n_features))
return X
def pairFeatureMatrix(self, elementList):
""" Construction of pair-distance matrices """
# Initiate
nSpecies = len(elementList)
# Get the molecular structure
pos = np.array(self.molecule.positions, dtype = float) # Atomic positions
elInd = np.array(self.molecule.elInd, dtype = np.intc) # Element indices matching to elementList
natoms = len(self.molecule.names) # Total number of atoms in the molecule
# Initiate the matrix
dim1 = natoms * (natoms -1)/2 # First dimension (pairwise distances)
dim2 = nSpecies * (nSpecies + 1)/2 # Number of possible pairs
featMat = np.zeros((dim1,dim2)) # To be passed to fun_pairFeatures (compiled C code)
# Call the C function to store the pairFeatures
pairFeatures.fun_pairFeatures(nSpecies, natoms, elInd, pos, featMat)
# Return featMat
return featMat
def execute(self, actions):
"""
Pass action to universe environment, return reward, next step, terminal state and
additional info.
:param action: action to execute as numpy array, should have dtype np.intc and should adhere to
the specification given in DeepMindLabEnvironment.action_spec(level_id)
:return: dict containing the next state, the reward, and a boolean indicating if the
next state is a terminal state
"""
adjusted_actions = list()
for action_spec in self.level.action_spec():
if action_spec['min'] == -1 and action_spec['max'] == 1:
adjusted_actions.append(actions[action_spec['name']] - 1)
else:
adjusted_actions.append(actions[action_spec['name']]) # clip?
actions = np.array(adjusted_actions, dtype=np.intc)
reward = self.level.step(action=actions, num_steps=self.repeat_action)
state = self.level.observations()['RGB_INTERLACED']
terminal = not self.level.is_running()
return state, terminal, reward
def default(self, obj):
# convert dates and numpy objects in a json serializable format
if isinstance(obj, datetime):
return obj.strftime('%Y-%m-%dT%H:%M:%SZ')
elif isinstance(obj, date):
return obj.strftime('%Y-%m-%d')
elif type(obj) in [np.int_, np.intc, np.intp, np.int8, np.int16,
np.int32, np.int64, np.uint8, np.uint16,
np.uint32, np.uint64]:
return int(obj)
elif type(obj) in [np.bool_]:
return bool(obj)
elif type(obj) in [np.float_, np.float16, np.float32, np.float64,
np.complex_, np.complex64, np.complex128]:
return float(obj)
# Let the base class default method raise the TypeError
return json.JSONEncoder.default(self, obj)
def predict(self, queries, n_jobs=1):
'''
Predict the ranking score for each individual document of the given queries.
n_jobs: int, optional (default is 1)
The number of working threads that will be spawned to compute
the ranking scores. If -1, the current number of CPUs will be used.
'''
if self.trained is False:
raise ValueError('the model has not been trained yet')
predictions = np.zeros(queries.document_count(), dtype=np.float64)
n_jobs = max(1, min(n_jobs if n_jobs >= 0 else n_jobs + cpu_count() + 1, queries.document_count()))
indices = np.linspace(0, queries.document_count(), n_jobs + 1).astype(np.intc)
Parallel(n_jobs=n_jobs, backend="threading")(delayed(parallel_helper, check_pickle=False)
(LambdaRandomForest, '_LambdaRandomForest__predict', self.estimators,
queries.feature_vectors[indices[i]:indices[i + 1]],
predictions[indices[i]:indices[i + 1]]) for i in range(indices.size - 1))
predictions /= len(self.estimators)
return predictions
def perform(self, node, inputs, out):
# TODO support broadcast!
# TODO assert all input have the same shape
z, = out
if (z[0] is None or
z[0].shape != inputs[0].shape or
not z[0].is_c_contiguous()):
z[0] = theano.sandbox.cuda.CudaNdarray.zeros(inputs[0].shape)
if inputs[0].shape != inputs[1].shape:
raise TypeError("PycudaElemwiseSourceModuleOp:"
" inputs don't have the same shape!")
if inputs[0].size > 512:
grid = (int(numpy.ceil(inputs[0].size / 512.)), 1)
block = (512, 1, 1)
else:
grid = (1, 1)
block = (inputs[0].shape[0], inputs[0].shape[1], 1)
self.pycuda_fct(inputs[0], inputs[1], z[0],
numpy.intc(inputs[1].size), block=block, grid=grid)
def make_thunk(self, node, storage_map, _, _2):
mod = SourceModule("""
__global__ void my_fct(float * i0, float * o0, int size) {
int i = blockIdx.x*blockDim.x + threadIdx.x;
if(i<size){
o0[i] = i0[i]*2;
}
}""")
pycuda_fct = mod.get_function("my_fct")
inputs = [ storage_map[v] for v in node.inputs]
outputs = [ storage_map[v] for v in node.outputs]
def thunk():
z = outputs[0]
if z[0] is None or z[0].shape!=inputs[0][0].shape:
z[0] = cuda.CudaNdarray.zeros(inputs[0][0].shape)
grid = (int(numpy.ceil(inputs[0][0].size / 512.)),1)
pycuda_fct(inputs[0][0], z[0], numpy.intc(inputs[0][0].size),
block=(512,1,1), grid=grid)
return thunk
def npy2py_type(npy_type):
int_types = [
np.int_, np.intc, np.intp, np.int8, np.int16, np.int32, np.int64,
np.uint8, np.uint16, np.uint32, np.uint64
]
float_types = [np.float_, np.float16, np.float32, np.float64]
bytes_types = [np.str_, np.string_]
if npy_type in int_types:
return int
if npy_type in float_types:
return float
if npy_type in bytes_types:
return bytes
if hasattr(npy_type, 'char'):
if npy_type.char in ['S', 'a']:
return bytes
raise TypeError
return npy_type
def _validate_X_predict(self, X, check_input):
"""Validate X whenever one tries to predict, apply, predict_proba"""
if self.tree_ is None:
raise NotFittedError("Estimator not fitted, "
"call `fit` before exploiting the model.")
if check_input:
X = check_array(X, dtype=DTYPE, accept_sparse="csr")
if issparse(X) and (X.indices.dtype != np.intc or
X.indptr.dtype != np.intc):
raise ValueError("No support for np.int64 index based "
"sparse matrices")
n_features = X.shape[1]
if self.n_features_ != n_features:
raise ValueError("Number of features of the model must "
"match the input. Model n_features is %s and "
"input n_features is %s "
% (self.n_features_, n_features))
return X
def _open_and_load(f, dtype, multilabel, zero_based, query_id):
if hasattr(f, "read"):
actual_dtype, data, ind, indptr, labels, query = \
_load_svmlight_file(f, dtype, multilabel, zero_based, query_id)
# XXX remove closing when Python 2.7+/3.1+ required
else:
with closing(_gen_open(f)) as f:
actual_dtype, data, ind, indptr, labels, query = \
_load_svmlight_file(f, dtype, multilabel, zero_based, query_id)
# convert from array.array, give data the right dtype
if not multilabel:
labels = frombuffer_empty(labels, np.float64)
data = frombuffer_empty(data, actual_dtype)
indices = frombuffer_empty(ind, np.intc)
indptr = np.frombuffer(indptr, dtype=np.intc) # never empty
query = frombuffer_empty(query, np.intc)
data = np.asarray(data, dtype=dtype) # no-op for float{32,64}
return data, indices, indptr, labels, query
def to_dense(A):
"""
Convert a sparse matrix A to dense.
For debugging only.
"""
if hasattr(A, "getrow"):
n = A.size(0)
m = A.size(1)
B = np.zeros( (n,m), dtype=np.float64)
for i in range(0,n):
[j, val] = A.getrow(i)
B[i,j] = val
return B
else:
x = Vector()
Ax = Vector()
A.init_vector(x,1)
A.init_vector(Ax,0)
n = get_local_size(Ax)
m = get_local_size(x)
B = np.zeros( (n,m), dtype=np.float64)
for i in range(0,m):
i_ind = np.array([i], dtype=np.intc)
x.set_local(np.ones(i_ind.shape), i_ind)
A.mult(x,Ax)
B[:,i] = Ax.get_local()
x.set_local(np.zeros(i_ind.shape), i_ind)
return B
def _create_lookups(self, X):
"""
Create document and term lookups for all tokens.
"""
docs, terms = np.nonzero(X)
if issparse(X):
x = np.array(X[docs, terms])[0]
else:
x = X[docs, terms]
doc_lookup = np.ascontiguousarray(np.repeat(docs, x), dtype=np.intc)
term_lookup = np.ascontiguousarray(np.repeat(terms, x), dtype=np.intc)
return doc_lookup, term_lookup
def _create_edges(self, y, order='tail'):
y.sort(order=order)
_docs, _counts = np.unique(y[order], return_counts=True)
counts = np.zeros(self.n_docs)
counts[_docs] = _counts
docs = np.ascontiguousarray(
np.concatenate(([0], np.cumsum(counts))), dtype=np.intc)
edges = np.ascontiguousarray(y['index'].flatten(), dtype=np.intc)
return docs, edges
def fit(self, X, y):
"""
Estimate the topic distributions per document (theta), term
distributions per topic (phi), and regression coefficients (eta).
Parameters
----------
X : array-like, shape = (n_docs, n_terms)
The document-term matrix.
y : array-like, shape = (n_edges, 3)
Each entry of y is an ordered triple (d_1, d_2, y_(d_1, d_2)),
where d_1 and d_2 are documents and y_(d_1, d_2) is an indicator of
a directed edge from d_1 to d_2.
"""
self.doc_term_matrix = X
self.n_docs, self.n_terms = X.shape
self.n_tokens = X.sum()
self.n_edges = y.shape[0]
doc_lookup, term_lookup = self._create_lookups(X)
# edge info
y = np.ascontiguousarray(np.column_stack((range(self.n_edges), y)))
# we use a view here so that we can sort in-place using named columns
y_rec = y.view(dtype=list(zip(('index', 'tail', 'head', 'data'),
4 * [y.dtype])))
edge_tail = np.ascontiguousarray(y_rec['tail'].flatten(),
dtype=np.intc)
edge_head = np.ascontiguousarray(y_rec['head'].flatten(),
dtype=np.intc)
edge_data = np.ascontiguousarray(y_rec['data'].flatten(),
dtype=np.float64)
out_docs, out_edges = self._create_edges(y_rec, order='tail')
in_docs, in_edges = self._create_edges(y_rec, order='head')
# iterate
self.theta, self.phi, self.H, self.loglikelihoods = gibbs_sampler_grtm(
self.n_iter, self.n_report_iter, self.n_topics, self.n_docs,
self.n_terms, self.n_tokens, self.n_edges, self.alpha, self.beta,
self.mu, self.nu2, self.b, doc_lookup, term_lookup, out_docs,
out_edges, in_docs, in_edges, edge_tail, edge_head, edge_data,
self.seed)
def fit(self, X, y, hier):
"""
Estimate the topic distributions per document (theta), term
distributions per topic (phi), and regression coefficients (eta).
Parameters
----------
X : array-like, shape = (n_docs, n_terms)
The document-term matrix.
y : array-like, shape = (n_docs, n_labels)
Response values for each document for each labels.
hier : 1D array-like, size = n_labels
The index of the list corresponds to the current label
and the value of the indexed position is the parent of the label.
Set -1 as the root.
"""
self.doc_term_matrix = X
self.n_docs, self.n_terms = X.shape
self.n_tokens = X.sum()
doc_lookup, term_lookup = self._create_lookups(X)
# iterate
self.theta, self.phi, self.eta, self.loglikelihoods = gibbs_sampler_blhslda(
self.n_iter, self.n_report_iter,
self.n_topics, self.n_docs, self.n_terms, self.n_tokens,
self.alpha, self.beta, self.mu, self.nu2, self.b, doc_lookup,
term_lookup, np.ascontiguousarray(y, dtype=np.intc),
np.ascontiguousarray(hier, dtype=np.intc), self.seed)
def _create_lookups(self, X):
"""
Create document and term lookups for all tokens.
"""
docs, terms = np.nonzero(X)
if issparse(X):
x = np.array(X[docs, terms])[0]
else:
x = X[docs, terms]
doc_lookup = np.ascontiguousarray(np.repeat(docs, x), dtype=np.intc)
term_lookup = np.ascontiguousarray(np.repeat(terms, x), dtype=np.intc)
return doc_lookup, term_lookup
def fit(self, X, y):
"""
Estimate the topic distributions per document (theta), term
distributions per topic (phi), and regression coefficients (eta).
Parameters
----------
X : array-like, shape = (n_docs, n_terms)
The document-term matrix.
y : array-like, shape = (n_edges, 3)
Each entry of y is an ordered triple (d_1, d_2, y_(d_1, d_2)),
where d_1 and d_2 are documents and y_(d_1, d_2) is an indicator of
a directed edge from d_1 to d_2.
"""
self.doc_term_matrix = X
self.n_docs, self.n_terms = X.shape
self.n_tokens = X.sum()
self.n_edges = y.shape[0]
doc_lookup, term_lookup = self._create_lookups(X)
# edge info
y = np.ascontiguousarray(np.column_stack((range(self.n_edges), y)))
# we use a view here so that we can sort in-place using named columns
y_rec = y.view(dtype=list(zip(('index', 'tail', 'head', 'data'),
4 * [y.dtype])))
edge_tail = np.ascontiguousarray(y_rec['tail'].flatten(),
dtype=np.intc)
edge_head = np.ascontiguousarray(y_rec['head'].flatten(),
dtype=np.intc)
edge_data = np.ascontiguousarray(y_rec['data'].flatten(),
dtype=np.float64)
out_docs, out_edges = self._create_edges(y_rec, order='tail')
in_docs, in_edges = self._create_edges(y_rec, order='head')
# iterate
self.theta, self.phi, self.H, self.loglikelihoods = gibbs_sampler_grtm(
self.n_iter, self.n_report_iter, self.n_topics, self.n_docs,
self.n_terms, self.n_tokens, self.n_edges, self.alpha, self.beta,
self.mu, self.nu2, self.b, doc_lookup, term_lookup, out_docs,
out_edges, in_docs, in_edges, edge_tail, edge_head, edge_data,
self.seed)
def fit(self, X, y, hier):
"""
Estimate the topic distributions per document (theta), term
distributions per topic (phi), and regression coefficients (eta).
Parameters
----------
X : array-like, shape = (n_docs, n_terms)
The document-term matrix.
y : array-like, shape = (n_docs, n_labels)
Response values for each document for each labels.
hier : 1D array-like, size = n_labels
The index of the list corresponds to the current label
and the value of the indexed position is the parent of the label.
Set -1 as the root.
"""
self.doc_term_matrix = X
self.n_docs, self.n_terms = X.shape
self.n_tokens = X.sum()
doc_lookup, term_lookup = self._create_lookups(X)
# iterate
self.theta, self.phi, self.eta, self.loglikelihoods = gibbs_sampler_blhslda(
self.n_iter, self.n_report_iter,
self.n_topics, self.n_docs, self.n_terms, self.n_tokens,
self.alpha, self.beta, self.mu, self.nu2, self.b, doc_lookup,
term_lookup, np.ascontiguousarray(y, dtype=np.intc),
np.ascontiguousarray(hier, dtype=np.intc), self.seed)
def test_dtype(self):
dt = np.intc
p = ndpointer(dtype=dt)
self.assertTrue(p.from_param(np.array([1], dt)))
dt = '<i4'
p = ndpointer(dtype=dt)
self.assertTrue(p.from_param(np.array([1], dt)))
dt = np.dtype('>i4')
p = ndpointer(dtype=dt)
p.from_param(np.array([1], dt))
self.assertRaises(TypeError, p.from_param,
np.array([1], dt.newbyteorder('swap')))
dtnames = ['x', 'y']
dtformats = [np.intc, np.float64]
dtdescr = {'names': dtnames, 'formats': dtformats}
dt = np.dtype(dtdescr)
p = ndpointer(dtype=dt)
self.assertTrue(p.from_param(np.zeros((10,), dt)))
samedt = np.dtype(dtdescr)
p = ndpointer(dtype=samedt)
self.assertTrue(p.from_param(np.zeros((10,), dt)))
dt2 = np.dtype(dtdescr, align=True)
if dt.itemsize != dt2.itemsize:
self.assertRaises(TypeError, p.from_param, np.zeros((10,), dt2))
else:
self.assertTrue(p.from_param(np.zeros((10,), dt2)))
def predict(self, X, check_input=True):
"""Predict class or regression value for X.
For a classification model, the predicted class for each sample in X is
returned. For a regression model, the predicted value based on X is
returned.
Parameters
----------
X : array-like of shape = [n_samples, n_features]
The input samples.
Returns
-------
y : array of shape = [n_samples] or [n_samples, n_outputs]
The predicted classes, or the predict values.
"""
X = check_array(X, dtype=DTYPE, accept_sparse="csr")
if issparse(X) and (X.indices.dtype != np.intc or
X.indptr.dtype != np.intc):
raise ValueError("No support for np.int64 index based "
"sparse matrices")
n_samples, n_features = X.shape
if self.tree_ is None:
raise Exception("Tree not initialized. Perform a fit first")
if self.n_features_ != n_features:
raise ValueError("Number of features of the model must "
" match the input. Model n_features is %s and "
" input n_features is %s "
% (self.n_features_, n_features))
return (self.tree_.get('coefficient') *
(X[:, self.tree_.get('best_dim')] > self.tree_.get('threshold')) +
self.tree_.get('constant'))
def _action(*entries):
return np.array(entries, dtype=np.intc)
def __init__(self, points, fraction):
super(Graph, self).__init__(points, fraction)
self.order = _np.ascontiguousarray(_np.argsort(self.density).astype(_np.intc)[::-1])
self.delta, self.neighbour = _core.get_delta_and_neighbour(
self.order, self.distances, self.max_distance)
def assign(self, min_density, min_delta, border_only=False):
self.min_density = min_density
self.min_delta = min_delta
self.border_only = border_only
if self.autoplot:
self.draw_decision_graph(self.min_density, self.min_delta)
self._get_cluster_indices()
self.membership = _core.get_membership(self.clusters, self.order, self.neighbour)
self.border_density, self.border_member = _core.get_border(
self.kernel_size, self.distances, self.density, self.membership, self.nclusters)
self.halo_idx, self.core_idx = _core.get_halo(
self.density, self.membership,
self.border_density, self.border_member.astype(_np.intc), border_only=border_only)
def _get_cluster_indices(self):
self.clusters = _np.intersect1d(
_np.where(self.density > self.min_density)[0],
_np.where(self.delta > self.min_delta)[0], assume_unique=True).astype(_np.intc)
self.nclusters = self.clusters.shape[0]
def _get_membership(self):
self.membership = -1 * _np.ones(shape=self.order.shape, dtype=_np.intc)
for i in range(self.ncl):
self.membership[self.clusters[i]] = i
for i in range(self.npoints):
if self.membership[self.order[i]] == -1:
self.membership[self.order[i]] = self.membership[self.neighbour[self.order[i]]]
def test_dtype(self):
dt = np.intc
p = ndpointer(dtype=dt)
self.assertTrue(p.from_param(np.array([1], dt)))
dt = '<i4'
p = ndpointer(dtype=dt)
self.assertTrue(p.from_param(np.array([1], dt)))
dt = np.dtype('>i4')
p = ndpointer(dtype=dt)
p.from_param(np.array([1], dt))
self.assertRaises(TypeError, p.from_param,
np.array([1], dt.newbyteorder('swap')))
dtnames = ['x', 'y']
dtformats = [np.intc, np.float64]
dtdescr = {'names': dtnames, 'formats': dtformats}
dt = np.dtype(dtdescr)
p = ndpointer(dtype=dt)
self.assertTrue(p.from_param(np.zeros((10,), dt)))
samedt = np.dtype(dtdescr)
p = ndpointer(dtype=samedt)
self.assertTrue(p.from_param(np.zeros((10,), dt)))
dt2 = np.dtype(dtdescr, align=True)
if dt.itemsize != dt2.itemsize:
self.assertRaises(TypeError, p.from_param, np.zeros((10,), dt2))
else:
self.assertTrue(p.from_param(np.zeros((10,), dt2)))
def MapActions(self, action_raw):
self.action = np.zeros([self.num_actions])
if (action_raw == 0):
self.action[self.indices["LOOK_LEFT_RIGHT_PIXELS_PER_FRAME"]] = -25
elif (action_raw == 1):
self.action[self.indices["LOOK_LEFT_RIGHT_PIXELS_PER_FRAME"]] = 25
"""if (action_raw==2):
self.action[self.indices["LOOK_DOWN_UP_PIXELS_PER_FRAME"]] = -25
elif (action_raw==3):
self.action[self.indices["LOOK_DOWN_UP_PIXELS_PER_FRAME"]] = 25
if (action_raw==4):
self.action[self.indices["STRAFE_LEFT_RIGHT"]] = -1
elif (action_raw==5):
self.action[self.indices["STRAFE_LEFT_RIGHT"]] = 1
if (action_raw==6):
self.action[self.indices["MOVE_BACK_FORWARD"]] = -1
el"""
if (action_raw == 2): # 7
self.action[self.indices["MOVE_BACK_FORWARD"]] = 1
# all binary actions need reset
"""if (action_raw==8):
self.action[self.indices["FIRE"]] = 0
elif (action_raw==9):
self.action[self.indices["FIRE"]] = 1
if (action_raw==10):
self.action[self.indices["JUMP"]] = 0
elif (action_raw==11):
self.action[self.indices["JUMP"]] = 1
if (action_raw==12):
self.action[self.indices["CROUCH"]] = 0
elif (action_raw==13):
self.action[self.indices["CROUCH"]] = 1"""
return np.clip(self.action, self.mins, self.maxs).astype(np.intc)
def _to_ctypes_array(tup, dtype=numpy.intc):
return numpy.array(tup, dtype=dtype).ctypes
