Python numpy 模块，ndarray() 实例源码
我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.ndarray()。
def make_grid(I, ncols=8):
assert isinstance(I, np.ndarray), 'plugin error, should pass numpy array here'
assert I.ndim == 4 and I.shape[1] == 3
nimg = I.shape[0]
H = I.shape[2]
W = I.shape[3]
ncols = min(nimg, ncols)
nrows = int(np.ceil(float(nimg) / ncols))
canvas = np.zeros((3, H * nrows, W * ncols))
i = 0
for y in range(nrows):
for x in range(ncols):
if i >= nimg:
break
canvas[:, y * H:(y + 1) * H, x * W:(x + 1) * W] = I[i]
i = i + 1
return canvas
def sizeFiltering(contours):
"""
this function filters out the smaller retroreflector (as well as any noise) by size
"""
if len(contours) == 0:
print "sizeFiltering: Error, no contours found"
return 0
big = contours[0]
for c in contours:
if type(c) and type(big) == numpy.ndarray:
if cv2.contourArea(c) > cv2.contourArea(big):
big = c
else:
print type(c) and type(big)
return 0
x,y,w,h = cv2.boundingRect(big)
return big
def generate(self, sess, conv_hidden, start_word_id, temperature, max_length, stop_word_id):
state = sess.run(self.cell.zero_state(1, tf.float32))
x = [[start_word_id]]
sent = [start_word_id]
for _ in xrange(max_length):
if type(conv_hidden) is np.ndarray:
#if conv_hidden != None:
probs, state = sess.run([self.probs, self.state], \
{self.x: x, self.initial_state: state, self.conv_hidden: conv_hidden})
else:
probs, state = sess.run([self.probs, self.state], \
{self.x: x, self.initial_state: state})
sent.append(self.sample(probs[0], temperature))
if sent[-1] == stop_word_id:
break
x = [[ sent[-1] ]]
return sent
#generate a sequence of words, given a topic
def __keytransform__(self, key):
if isinstance(key[0], np.ndarray):
shape = key[0].shape
dtype = key[0].dtype
i = key[1]
zero = True if len(key) == 2 else key[2]
elif isinstance(key[0], tuple):
if len(key) == 3:
shape, dtype, i = key
zero = True
elif len(key) == 4:
shape, dtype, i, zero = key
else:
raise TypeError("Wrong type of key for work array")
assert isinstance(zero, bool)
assert isinstance(i, int)
self.fillzero = zero
return (shape, np.dtype(dtype), i)
def apply(self, old_values, step):
"""Apply the boundary.
Args:
old_values: Old values of the points in the boundary.
step: Time step of the simulation (required if signals are to be applied).
Returns:
New values for the points in the boundary.
"""
if np.ndim(self.value) == 0 or \
(np.ndim(self.value) == 1 and type(self.value) == list):
# if a single value or a list of single values for each index is given
return self.additive * old_values + self.value
elif type(self.value) == np.ndarray:
# if a signal is given
return self.additive * old_values + self.value[step]
else:
# if a list of signals for each index is given
return [self.additive * old_values[ii] + signal[step]
for ii, signal in enumerate(self.value)]
def test_accuracy_full_batch(tokens, features, mini_batch_size, word_attn, sent_attn, th=0.5):
p = []
l = []
cnt = 0
g = gen_minibatch1(tokens, features, mini_batch_size, False)
for token, feature in g:
if cnt % 100 == 0:
print(cnt)
cnt +=1
# print token.size()
# y_pred = get_predictions(token, word_attn, sent_attn)
# print y_pred
y_pred = get_predictions(token, feature, word_attn, sent_attn)
# print y_pred
# _, y_pred = torch.max(y_pred, 1)
# y_pred = y_pred[:, 1]
# print y_pred
p.append(np.ndarray.flatten(y_pred.data.cpu().numpy()))
p = [item for sublist in p for item in sublist]
p = np.array(p)
return p
def __init__(self, N, V, tree_prior, config):
"""Initialize a model with an empty subsample.
Args:
N (int): Number of rows in the dataset.
V (int): Number of columns (features) in the dataset.
tree_prior: A [K]-shaped numpy array of prior edge log odds, where
K is the number of edges in the complete graph on V vertices.
config: A global config dict.
"""
assert isinstance(N, int)
assert isinstance(V, int)
assert isinstance(tree_prior, np.ndarray)
assert isinstance(config, dict)
K = V * (V - 1) // 2 # Number of edges in complete graph.
assert V <= 32768, 'Invalid # features > 32768: {}'.format(V)
assert tree_prior.shape == (K, )
assert tree_prior.dtype == np.float32
self._config = config.copy()
self._num_rows = N
self._tree_prior = tree_prior
self._tree = TreeStructure(V)
assert self._tree.num_vertices == V
self._program = make_propagation_program(self._tree.tree_grid)
self._added_rows = set()
def __init__(self, data, tree_prior, config):
"""Initialize a model with an empty subsample.
Args:
data: An [N, V]-shaped numpy array of real-valued data.
tree_prior: A [K]-shaped numpy array of prior edge log odds, where
K is the number of edges in the complete graph on V vertices.
config: A global config dict.
"""
assert isinstance(data, np.ndarray)
data = np.asarray(data, np.float32)
assert len(data.shape) == 2
N, V = data.shape
D = config['model_latent_dim']
E = V - 1 # Number of edges in the tree.
TreeTrainer.__init__(self, N, V, tree_prior, config)
self._data = data
self._latent = np.zeros([N, V, D], np.float32)
# This is symmetric positive definite.
self._vert_ss = np.zeros([V, D, D], np.float32)
# This is arbitrary (not necessarily symmetric).
self._edge_ss = np.zeros([E, D, D], np.float32)
# This represents (count, mean, covariance).
self._feat_ss = np.zeros([V, D, 1 + 1 + D], np.float32)
def set_type2000_format(format=list):
"""
Sets the data format returned when reading in type 2000 files.
The default is 'list', meaning a list of NumPy arrays, where the
length of each array is equal to the frame size. To return type 2000
data as a 2-d array, <format> should be 'numpy.ndarray', e.g.:
import bluefile, numpy
bluefile.set_type2000_format(numpy.ndarray)
Note that <format> is expected to a type object.
"""
global _type2000_format
if format not in [ list, numpy.ndarray ]:
raise TypeError, 'Only list and numpy.ndarray are supported'
_type2000_format = format
def array_stream(func):
"""
Decorates streaming functions to make sure that the stream
is a stream of ndarrays. Objects that are not arrays are transformed
into arrays. If the stream is in fact a single ndarray, this ndarray
is repackaged into a sequence of length 1.
The first argument of the decorated function is assumed to be an iterable of
arrays, or an iterable of objects that can be casted to arrays.
"""
@wraps(func) # thanks functools
def decorated(arrays, *args, **kwargs):
if isinstance(arrays, ndarray):
arrays = (arrays,)
return func(map(atleast_1d, arrays), *args, **kwargs)
return decorated
def iload(files, load_func, **kwargs):
"""
Create a stream of arrays from files, which are loaded lazily.
Parameters
----------
pattern : iterable of str or str
Either an iterable of filenames or a glob-like pattern str.
load_func : callable, optional
Function taking a filename as its first arguments
kwargs
Keyword arguments are passed to ``load_func``.
Yields
------
arr: `~numpy.ndarray`
Loaded data.
"""
if isinstance(files, str):
files = iglob(files)
files = iter(files)
yield from map(partial(load_func, **kwargs), files)
# pmap does not support local functions
def _get_fixed_params(im):
""" Parameters that the user has no influence on. Mostly chosen
bases on the input images.
"""
p = Parameters()
if not isinstance(im, np.ndarray):
return p
# Dimension of the inputs
p.FixedImageDimension = im.ndim
p.MovingImageDimension = im.ndim
# Always write result, so I can verify
p.WriteResultImage = True
# How to write the result
tmp = DTYPE_NP2ITK[im.dtype.name]
p.ResultImagePixelType = tmp.split('_')[-1].lower()
p.ResultImageFormat = "mhd"
# Done
return p
def __init__(self, skimage_function=None, **function_params):
'''
:param skimage_function: transformation function from skimage
'''
accepted_types = [
list, np.ndarray, np.array
]
if skimage_function is None:
raise Exception('Please specify transform function from scikit-image'
' http://scikit-image.org/docs/dev/api/skimage.transform.html')
def image_transform_function(img):
return skimage_function(img, **function_params)
super(ImageTransformer, self).__init__(data_types=accepted_types,
columns=None,
transform_function=image_transform_function)
def test_image_transformation():
s = XSeries([generate_image(False) for _ in range(100)])
try:
image_transformer = ImageTransformer().fit()
assert False
except:
assert True
image_transformer = ImageTransformer(skimage_transform.hough_circle, radius=5).fit()
s_transformed = image_transformer.transform(s)
assert s_transformed.data_type == np.ndarray
image_transformer = ImageTransformer(skimage_transform.resize, output_shape=(10, 10)).fit()
s_transformed = image_transformer.transform(s)
assert s_transformed.data_type == np.ndarray
def compute_nearest_neighbors(submatrix, balltree, k, row_start):
""" Compute k nearest neighbors on a submatrix
Args: submatrix (np.ndarray): Data submatrix
balltree: Nearest neighbor index (from sklearn)
k: number of nearest neigbors to compute
row_start: row offset into larger matrix
Returns a COO sparse adjacency matrix of nearest neighbor relations as (i,j,x)"""
nn_dist, nn_idx = balltree.query(submatrix, k=k+1)
# Remove the self-as-neighbors
nn_idx = nn_idx[:,1:]
nn_dist = nn_dist[:,1:]
# Construct a COO sparse matrix of edges and distances
i = np.repeat(row_start + np.arange(nn_idx.shape[0]), k)
j = nn_idx.ravel().astype(int)
return (i, j, nn_dist.ravel())
def plot_loop(self, image, it):
"""
The actual function that updates the data in the plot initialized in :meth:`~.init`
:param image: The image that is recorded with :class:`~.PlotRecorder`. It should be a 2-D numpy array
:param it: The iteration number (independent of the actual x value)
:return:
"""
logger.debug("Plotting %s in %s", self.var_name, self.entity_name)
assert isinstance(image, np.ndarray), "The passed in image should by a numpy array"
assert len(image.shape) == 2, "The image to be shown should be 2-dimensional"
if it == 0:
self.im = self.ax.imshow(image, **self.imshow_kwargs)
else:
if it % self.plot_frequency == 0:
self.im.set_array(image)
def _prepare_image(I):
assert isinstance(I, np.ndarray), 'plugin error, should pass numpy array here'
assert I.ndim == 2 or I.ndim == 3 or I.ndim == 4
if I.ndim == 4: # NCHW
if I.shape[1] == 1: # N1HW
I = np.concatenate((I, I, I), 1) # N3HW
assert I.shape[1] == 3
I = make_grid(I) # 3xHxW
if I.ndim == 3 and I.shape[0] == 1: # 1xHxW
I = np.concatenate((I, I, I), 0) # 3xHxW
if I.ndim == 2: # HxW
I = np.expand_dims(I, 0) # 1xHxW
I = np.concatenate((I, I, I), 0) # 3xHxW
I = I.transpose(1, 2, 0)
return I
def check_numeric_input(self, input_name, input_value):
if type(input_value) is np.ndarray:
if input_value.size == self.P:
setattr(self, input_name, input_value)
elif input_value.size == 1:
setattr(self, input_name, input_value*np.ones(self.P))
else:
raise ValueError("length of %s is %d; should be %d" % (input_name, input_value.size, self.P))
elif type(input_value) is float or type(input_value) is int:
setattr(self, input_name, float(input_value)*np.ones(self.P))
elif type(input_value) is list:
if len(input_value) == self.P:
setattr(self, input_name, np.array([float(x) for x in input_value]))
elif len(input_value) == 1:
setattr(self, input_name, np.array([float(x) for x in input_value]) * np.ones(self.P))
else:
raise ValueError("length of %s is %d; should be %d" % (input_name, len(input_value), self.P))
else:
raise ValueError("user provided %s with an unsupported type" % (input_name))
def load_nifti(filename, with_affine=False):
"""
load image from NIFTI file
Parameters
----------
filename : str
filename of NIFTI file
with_affine : bool
if True, returns affine parameters
Returns
-------
data : np.ndarray
image data
"""
img = nib.load(filename)
data = img.get_data()
data = np.copy(data, order="C")
if with_affine:
return data, img.affine
return data
def update_image_property(self, property_name, property_data, erase_property=False):
if isinstance(property_data,list) or isinstance(property_data,np.ndarray):
assert len(property_data) == len(self._labels)
property_keys = self._labels
elif isinstance(property_data,dict) or isinstance(property_data,array_dict):
property_keys = np.sort(property_data.keys())
property_data = [property_data[l] for l in property_keys]
if property_name in self._properties.keys():
if erase_property:
self._properties[property_name] = array_dict(property_data,keys=property_keys)
else:
for l,v in zip(property_keys,property_data):
self._properties[property_name][l] = v
else:
print "Creating property ",property_name," on image"
self._properties[property_name] = array_dict(property_data,keys=property_keys)
def spatial_image_analysis_property(sia, property_name, labels=None):
if property_name == 'volume':
property_data = sia.volume(labels)
elif property_name == 'neighborhood_size':
property_data = sia.neighbors_number(labels)
elif property_name == 'shape_anisotropy':
inertia_axes_vectors, inertia_axes_values = sia.inertia_axis(labels)
property_data = [fractional_anisotropy(inertia_axes_values[l]) for l in labels]
elif property_name == 'gaussian_curvature':
property_data = sia.gaussian_curvature_CGAL(labels)
else:
property_data = dict(zip(labels,labels))
if isinstance(property_data,np.ndarray) or isinstance(property_data,list):
property_data = array_dict(property_data, keys=labels)
elif isinstance(property_data,dict):
property_data = array_dict(property_data)
return property_data
def __init__(self, buf, offset = 0):
# Accelerate class attributes
self._encode = self.encode
self._dtype = self.dtype
self._xxh = self.xxh
# Initialize buffer
if offset:
self._buf = self._likebuf = buffer(buf, offset)
else:
self._buf = buf
self._likebuf = _likebuffer(buf)
# Parse header and map index
self.index_elements, self.index_offset = self._Header.unpack_from(self._buf, 0)
self.index = numpy.ndarray(buffer = self._buf,
offset = self.index_offset,
dtype = self.dtype,
shape = (self.index_elements, 3))
def validate_dict(self,a_dict):
#Check keys
for key,val in self.dict.items():
if not key in a_dict.keys():
raise ValueError('key:',key,'was not in a_dict.keys()')
for key,val in a_dict.items():
#Check same keys
if not key in self.dict.keys():
raise ValueError('argument key:',key,'was not in self.dict')
if isinstance(val,np.ndarray):
#print('ndarray')
my_val=self.dict[key]
if not np.all(val.shape[1:]==my_val.shape[1:]):
raise ValueError('key:',key,'value shape',val.shape,'does\
not match existing shape',my_val.shape)
else: #scalar
a_val=np.array([[val]])#[1,1]shape array
my_val=self.dict[key]
if not np.all(my_val.shape[1:]==a_val.shape[1:]):
raise ValueError('key:',key,'value shape',val.shape,'does\
not match existing shape',my_val.shape)
def roiChanged(self):
if self.image is None:
return
image = self.getProcessedImage()
if image.ndim == 2:
axes = (0, 1)
elif image.ndim == 3:
axes = (1, 2)
else:
return
data, coords = self.roi.getArrayRegion(image.view(np.ndarray), self.imageItem, axes, returnMappedCoords=True)
if data is not None:
while data.ndim > 1:
data = data.mean(axis=1)
if image.ndim == 3:
self.roiCurve.setData(y=data, x=self.tVals)
else:
while coords.ndim > 2:
coords = coords[:,:,0]
coords = coords - coords[:,0,np.newaxis]
xvals = (coords**2).sum(axis=0) ** 0.5
self.roiCurve.setData(y=data, x=xvals)
def dataType(obj):
if hasattr(obj, '__len__') and len(obj) == 0:
return 'empty'
if isinstance(obj, dict):
return 'dictOfLists'
elif isSequence(obj):
first = obj[0]
if (hasattr(obj, 'implements') and obj.implements('MetaArray')):
return 'MetaArray'
elif isinstance(obj, np.ndarray):
if obj.ndim == 1:
if obj.dtype.names is None:
return 'listOfValues'
else:
return 'recarray'
elif obj.ndim == 2 and obj.dtype.names is None and obj.shape[1] == 2:
return 'Nx2array'
else:
raise Exception('array shape must be (N,) or (N,2); got %s instead' % str(obj.shape))
elif isinstance(first, dict):
return 'listOfDicts'
else:
return 'listOfValues'
def _plotMetaArray(self, arr, x=None, autoLabel=True, **kargs):
inf = arr.infoCopy()
if arr.ndim != 1:
raise Exception('can only automatically plot 1 dimensional arrays.')
## create curve
try:
xv = arr.xvals(0)
except:
if x is None:
xv = np.arange(arr.shape[0])
else:
xv = x
c = PlotCurveItem(**kargs)
c.setData(x=xv, y=arr.view(np.ndarray))
if autoLabel:
name = arr._info[0].get('name', None)
units = arr._info[0].get('units', None)
self.setLabel('bottom', text=name, units=units)
name = arr._info[1].get('name', None)
units = arr._info[1].get('units', None)
self.setLabel('left', text=name, units=units)
return c
def setPen(self, *args, **kargs):
"""Set the pen(s) used to draw the outline around each spot.
If a list or array is provided, then the pen for each spot will be set separately.
Otherwise, the arguments are passed to pg.mkPen and used as the default pen for
all spots which do not have a pen explicitly set."""
update = kargs.pop('update', True)
dataSet = kargs.pop('dataSet', self.data)
if len(args) == 1 and (isinstance(args[0], np.ndarray) or isinstance(args[0], list)):
pens = args[0]
if 'mask' in kargs and kargs['mask'] is not None:
pens = pens[kargs['mask']]
if len(pens) != len(dataSet):
raise Exception("Number of pens does not match number of points (%d != %d)" % (len(pens), len(dataSet)))
dataSet['pen'] = pens
else:
self.opts['pen'] = fn.mkPen(*args, **kargs)
dataSet['sourceRect'] = None
if update:
self.updateSpots(dataSet)
def setBrush(self, *args, **kargs):
"""Set the brush(es) used to fill the interior of each spot.
If a list or array is provided, then the brush for each spot will be set separately.
Otherwise, the arguments are passed to pg.mkBrush and used as the default brush for
all spots which do not have a brush explicitly set."""
update = kargs.pop('update', True)
dataSet = kargs.pop('dataSet', self.data)
if len(args) == 1 and (isinstance(args[0], np.ndarray) or isinstance(args[0], list)):
brushes = args[0]
if 'mask' in kargs and kargs['mask'] is not None:
brushes = brushes[kargs['mask']]
if len(brushes) != len(dataSet):
raise Exception("Number of brushes does not match number of points (%d != %d)" % (len(brushes), len(dataSet)))
dataSet['brush'] = brushes
else:
self.opts['brush'] = fn.mkBrush(*args, **kargs)
#self._spotPixmap = None
dataSet['sourceRect'] = None
if update:
self.updateSpots(dataSet)
def setSymbol(self, symbol, update=True, dataSet=None, mask=None):
"""Set the symbol(s) used to draw each spot.
If a list or array is provided, then the symbol for each spot will be set separately.
Otherwise, the argument will be used as the default symbol for
all spots which do not have a symbol explicitly set."""
if dataSet is None:
dataSet = self.data
if isinstance(symbol, np.ndarray) or isinstance(symbol, list):
symbols = symbol
if mask is not None:
symbols = symbols[mask]
if len(symbols) != len(dataSet):
raise Exception("Number of symbols does not match number of points (%d != %d)" % (len(symbols), len(dataSet)))
dataSet['symbol'] = symbols
else:
self.opts['symbol'] = symbol
self._spotPixmap = None
dataSet['sourceRect'] = None
if update:
self.updateSpots(dataSet)
def setSize(self, size, update=True, dataSet=None, mask=None):
"""Set the size(s) used to draw each spot.
If a list or array is provided, then the size for each spot will be set separately.
Otherwise, the argument will be used as the default size for
all spots which do not have a size explicitly set."""
if dataSet is None:
dataSet = self.data
if isinstance(size, np.ndarray) or isinstance(size, list):
sizes = size
if mask is not None:
sizes = sizes[mask]
if len(sizes) != len(dataSet):
raise Exception("Number of sizes does not match number of points (%d != %d)" % (len(sizes), len(dataSet)))
dataSet['size'] = sizes
else:
self.opts['size'] = size
self._spotPixmap = None
dataSet['sourceRect'] = None
if update:
self.updateSpots(dataSet)
def iteratorFn(self, data):
## Return 1) a function that will provide an iterator for data and 2) a list of header strings
if isinstance(data, list) or isinstance(data, tuple):
return lambda d: d.__iter__(), None
elif isinstance(data, dict):
return lambda d: iter(d.values()), list(map(asUnicode, data.keys()))
elif (hasattr(data, 'implements') and data.implements('MetaArray')):
if data.axisHasColumns(0):
header = [asUnicode(data.columnName(0, i)) for i in range(data.shape[0])]
elif data.axisHasValues(0):
header = list(map(asUnicode, data.xvals(0)))
else:
header = None
return self.iterFirstAxis, header
elif isinstance(data, np.ndarray):
return self.iterFirstAxis, None
elif isinstance(data, np.void):
return self.iterate, list(map(asUnicode, data.dtype.names))
elif data is None:
return (None,None)
else:
msg = "Don't know how to iterate over data type: {!s}".format(type(data))
raise TypeError(msg)
def hoverOver(self, items):
#print "FlowchartWidget.hoverOver called."
term = None
for item in items:
if item is self.hoverItem:
return
self.hoverItem = item
if hasattr(item, 'term') and isinstance(item.term, Terminal):
term = item.term
break
if term is None:
self.hoverText.setPlainText("")
else:
val = term.value()
if isinstance(val, ndarray):
val = "%s %s %s" % (type(val).__name__, str(val.shape), str(val.dtype))
else:
val = str(val)
if len(val) > 400:
val = val[:400] + "..."
self.hoverText.setPlainText("%s.%s = %s" % (term.node().name(), term.name(), val))
#self.hoverLabel.setCursorPosition(0)
def applyFilter(data, b, a, padding=100, bidir=True):
"""Apply a linear filter with coefficients a, b. Optionally pad the data before filtering
and/or run the filter in both directions."""
try:
import scipy.signal
except ImportError:
raise Exception("applyFilter() requires the package scipy.signal.")
d1 = data.view(np.ndarray)
if padding > 0:
d1 = np.hstack([d1[:padding], d1, d1[-padding:]])
if bidir:
d1 = scipy.signal.lfilter(b, a, scipy.signal.lfilter(b, a, d1)[::-1])[::-1]
else:
d1 = scipy.signal.lfilter(b, a, d1)
if padding > 0:
d1 = d1[padding:-padding]
if (hasattr(data, 'implements') and data.implements('MetaArray')):
return MetaArray(d1, info=data.infoCopy())
else:
return d1
def besselFilter(data, cutoff, order=1, dt=None, btype='low', bidir=True):
"""return data passed through bessel filter"""
try:
import scipy.signal
except ImportError:
raise Exception("besselFilter() requires the package scipy.signal.")
if dt is None:
try:
tvals = data.xvals('Time')
dt = (tvals[-1]-tvals[0]) / (len(tvals)-1)
except:
dt = 1.0
b,a = scipy.signal.bessel(order, cutoff * dt, btype=btype)
return applyFilter(data, b, a, bidir=bidir)
#base = data.mean()
#d1 = scipy.signal.lfilter(b, a, data.view(ndarray)-base) + base
#if (hasattr(data, 'implements') and data.implements('MetaArray')):
#return MetaArray(d1, info=data.infoCopy())
#return d1
def modeFilter(data, window=500, step=None, bins=None):
"""Filter based on histogram-based mode function"""
d1 = data.view(np.ndarray)
vals = []
l2 = int(window/2.)
if step is None:
step = l2
i = 0
while True:
if i > len(data)-step:
break
vals.append(mode(d1[i:i+window], bins))
i += step
chunks = [np.linspace(vals[0], vals[0], l2)]
for i in range(len(vals)-1):
chunks.append(np.linspace(vals[i], vals[i+1], step))
remain = len(data) - step*(len(vals)-1) - l2
chunks.append(np.linspace(vals[-1], vals[-1], remain))
d2 = np.hstack(chunks)
if (hasattr(data, 'implements') and data.implements('MetaArray')):
return MetaArray(d2, info=data.infoCopy())
return d2
def _axisSlice(self, i, cols):
#print "axisSlice", i, cols
if 'cols' in self._info[i] or 'values' in self._info[i]:
ax = self._axisCopy(i)
if 'cols' in ax:
#print " slicing columns..", array(ax['cols']), cols
sl = np.array(ax['cols'])[cols]
if isinstance(sl, np.ndarray):
sl = list(sl)
ax['cols'] = sl
#print " result:", ax['cols']
if 'values' in ax:
ax['values'] = np.array(ax['values'])[cols]
else:
ax = self._info[i]
#print " ", ax
return ax
def __getitem__(self, i):
'''
Get the item or slice :attr:`i`.
'''
obj = super(IrregularlySampledSignal, self).__getitem__(i)
if isinstance(i, int): # a single point in time across all channels
obj = pq.Quantity(obj.magnitude, units=obj.units)
elif isinstance(i, tuple):
j, k = i
if isinstance(j, int): # a single point in time across some channels
obj = pq.Quantity(obj.magnitude, units=obj.units)
else:
if isinstance(j, slice):
obj.times = self.times.__getitem__(j)
elif isinstance(j, np.ndarray):
raise NotImplementedError("Arrays not yet supported")
else:
raise TypeError("%s not supported" % type(j))
if isinstance(k, int):
obj = obj.reshape(-1, 1)
elif isinstance(i, slice):
obj.times = self.times.__getitem__(i)
else:
raise IndexError("index should be an integer, tuple or slice")
return obj
def _check_annotations(value):
"""
Recursively check that value is either of a "simple" type (number, string,
date/time) or is a (possibly nested) dict, list or numpy array containing
only simple types.
"""
if isinstance(value, np.ndarray):
if not issubclass(value.dtype.type, ALLOWED_ANNOTATION_TYPES):
raise ValueError("Invalid annotation. NumPy arrays with dtype %s"
"are not allowed" % value.dtype.type)
elif isinstance(value, dict):
for element in value.values():
_check_annotations(element)
elif isinstance(value, (list, tuple)):
for element in value:
_check_annotations(element)
elif not isinstance(value, ALLOWED_ANNOTATION_TYPES):
raise ValueError("Invalid annotation. Annotations of type %s are not"
"allowed" % type(value))
def _check_time_in_range(value, t_start, t_stop, view=False):
'''
Verify that all times in :attr:`value` are between :attr:`t_start`
and :attr:`t_stop` (inclusive.
If :attr:`view` is True, vies are used for the test.
Using drastically increases the speed, but is only safe if you are
certain that the dtype and units are the same
'''
if not value.size:
return
if view:
value = value.view(np.ndarray)
t_start = t_start.view(np.ndarray)
t_stop = t_stop.view(np.ndarray)
if value.min() < t_start:
raise ValueError("The first spike (%s) is before t_start (%s)" %
(value, t_start))
if value.max() > t_stop:
raise ValueError("The last spike (%s) is after t_stop (%s)" %
(value, t_stop))
def assert_arrays_almost_equal(a, b, threshold, dtype=False):
'''
Check if two arrays have the same shape and contents that differ
by abs(a - b) <= threshold for all elements.
If threshold is None, do an absolute comparison rather than a relative
comparison.
'''
if threshold is None:
return assert_arrays_equal(a, b, dtype=dtype)
assert isinstance(a, np.ndarray), "a is a %s" % type(a)
assert isinstance(b, np.ndarray), "b is a %s" % type(b)
assert a.shape == b.shape, "%s != %s" % (a, b)
#assert a.dtype == b.dtype, "%s and %b not same dtype %s %s" % (a, b,
# a.dtype,
# b.dtype)
if a.dtype.kind in ['f', 'c', 'i']:
assert (abs(a - b) < threshold).all(), \
"abs(%s - %s) max(|a - b|) = %s threshold:%s" % \
(a, b, (abs(a - b)).max(), threshold)
if dtype:
assert a.dtype == b.dtype, \
"%s and %s not same dtype %s and %s" % (a, b, a.dtype, b.dtype)
def write(filename, predictions):
''' Write prediction scores in prescribed format'''
with open(filename, "w") as output_file:
for row in predictions:
if type(row) is not np.ndarray and type(row) is not list:
row = [row]
for val in row:
output_file.write('{:g} '.format(float(val)))
output_file.write('\n')
def get_concatenated_sets(lang_codes, feature_set_str):
feature_set_parts = feature_set_str.split("+")
feature_names = []
feature_values = np.ndarray((len(lang_codes),0))
for feature_set_part in feature_set_parts:
more_feature_names, more_feature_values = get_union_sets(lang_codes, feature_set_part)
feature_names += more_feature_names
feature_values = np.concatenate([feature_values, more_feature_values], axis=1)
return feature_names, feature_values
def test_get_vector(self):
net = nt.Netlist(netlists_path + 'dc_ac_check.net')
net.setup_sim('dc', 'v1 0 1 .3')
net.run()
val = net.get_vector('V(1)', 'dc1')
assert isinstance(val, numpy.ndarray)
assert len(val) == 4
ng.reset()
def test_real(self):
val = ng.get_data('const.e')
assert type(val) == np.ndarray
assert len(val) == 1
assert val.dtype == 'float64'
assert val[0] == pytest.approx(np.e)
def test_cmplx(self):
val = ng.get_data('const.i')
assert type(val) == np.ndarray
assert len(val) == 1
assert val.dtype == 'complex128'
assert val[0] == pytest.approx(1j)
def apply(self, x):
s = x.shape
if isinstance(x, np.ndarray):
return np.dot(x.reshape((s[0],np.prod(s[1:]))) - self.mean.get_value(), self.ZCA_mat.get_value()).reshape(s)
elif isinstance(x, T.TensorVariable):
return T.dot(x.flatten(2) - self.mean.dimshuffle('x',0), self.ZCA_mat).reshape(s)
else:
raise NotImplementedError("Whitening only implemented for numpy arrays or Theano TensorVariables")
def invert(self, x):
s = x.shape
if isinstance(x, np.ndarray):
return (np.dot(x.reshape((s[0],np.prod(s[1:]))), self.inv_ZCA_mat.get_value()) + self.mean.get_value()).reshape(s)
elif isinstance(x, T.TensorVariable):
return (T.dot(x.flatten(2), self.inv_ZCA_mat) + self.mean.dimshuffle('x',0)).reshape(s)
else:
raise NotImplementedError("Whitening only implemented for numpy arrays or Theano TensorVariables")
# T.nnet.relu has some issues with very large inputs, this is more stable
def _clip(self, action):
maxs = self.env.action_space.high
mins = self.env.action_space.low
if isinstance(action, np.ndarray):
np.clip(action, mins, maxs, out=action)
elif isinstance(action, list):
for i in range(len(action)):
action[i] = clip(action[i], mins[i], maxs[i])
else:
action = clip(action, mins[0], maxs[0])
return action
def get_minibatches(data, minibatch_size, shuffle=True):
"""
Iterates through the provided data one minibatch at at time. You can use this function to
iterate through data in minibatches as follows:
for inputs_minibatch in get_minibatches(inputs, minibatch_size):
...
Or with multiple data sources:
for inputs_minibatch, labels_minibatch in get_minibatches([inputs, labels], minibatch_size):
...
Args:
data: there are two possible values:
- a list or numpy array
- a list or tuple where each element is either a list or numpy array
minibatch_size: the maximum number of items in a minibatch
shuffle: whether to randomize the order of returned data
Returns:
minibatches: the return value depends on data:
- If data is a list/array it yields the next minibatch of data.
- If data a list of lists/arrays it returns the next minibatch of each element in the
list. This can be used to iterate through multiple data sources
(e.g., features and labels) at the same time.
"""
list_data = isinstance(data, (list, tuple)) and isinstance(data[0], (list,np.ndarray))
data_size = len(data[0]) if list_data else len(data)
indices = np.arange(data_size)
if shuffle:
np.random.shuffle(indices)
for minibatch_start in np.arange(0, data_size, minibatch_size):
minibatch_indices = indices[minibatch_start:minibatch_start + minibatch_size]
yield [minibatch(d, minibatch_indices) for d in data] if list_data \
else minibatch(data, minibatch_indices)