Python numpy 模块，rollaxis() 实例源码
我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.rollaxis()。
def visualizeLayer(model, img, input_image, layerIndex):
layer = model.layers[layerIndex]
get_activations = K.function([model.layers[0].input, K.learning_phase()], [layer.output,])
activations = get_activations([input_image, 0])[0]
output_image = activations
## If 4 dimensional then take the last dimension value as it would be no of filters
if output_image.ndim == 4:
# Rearrange dimension so we can plot the result
o1 = np.rollaxis(output_image, 3, 1)
output_image = np.rollaxis(o1, 3, 1)
print "Dumping filter data of layer{} - {}".format(layerIndex,layer.__class__.__name__)
filters = len(output_image[0,0,0,:])
fig=plt.figure(figsize=(8,8))
# This loop will plot the 32 filter data for the input image
for i in range(filters):
ax = fig.add_subplot(6, 6, i+1)
#ax.imshow(output_image[img,:,:,i],interpolation='none' ) #to see the first filter
ax.imshow(output_image[0,:,:,i],'gray')
#ax.set_title("Feature map of layer#{} \ncalled '{}' \nof type {} ".format(layerIndex,
# layer.name,layer.__class__.__name__))
plt.xticks(np.array([]))
plt.yticks(np.array([]))
plt.tight_layout()
#plt.show()
fig.savefig("img_" + str(img) + "_layer" + str(layerIndex)+"_"+layer.__class__.__name__+".png")
#plt.close(fig)
else:
print "Can't dump data of this layer{}- {}".format(layerIndex, layer.__class__.__name__)
def _random_overlay(self, static_hidden=False):
"""Construct random max pool locations."""
s = self.shapes[2]
if static_hidden:
args = np.random.randint(s[2], size=np.prod(s) / s[2] / s[4])
overlay = np.zeros(np.prod(s) / s[4], np.bool)
overlay[args + np.arange(len(args)) * s[2]] = True
overlay = overlay.reshape([s[0], s[1], s[3], s[2]])
overlay = np.rollaxis(overlay, -1, 2)
return arrays.extend(overlay, s[4])
else:
args = np.random.randint(s[2], size=np.prod(s) / s[2])
overlay = np.zeros(np.prod(s), np.bool)
overlay[args + np.arange(len(args)) * s[2]] = True
overlay = overlay.reshape([s[0], s[1], s[3], s[4], s[2]])
return np.rollaxis(overlay, -1, 2)
def _local_add_sparse(ltenss):
"""Computes the local tensors of a sum of MPArrays (except for the boundary
tensors). Works only for products right now
:param ltenss: Raveled local tensors
:returns: Correct local tensor representation
"""
dim = len(ltenss[0])
nr_summands = len(ltenss)
indptr = np.arange(nr_summands * dim + 1)
indices = np.concatenate((np.arange(nr_summands),) * dim)
data = np.concatenate([lt[None, :] for lt in ltenss])
data = np.rollaxis(data, 1).ravel()
return ssp.csc_matrix((data, indices, indptr),
shape=(nr_summands, dim * nr_summands))
def axis_iter(self, axes=0):
"""Returns an iterator yielding Sub-MPArrays of ``self`` by iterating
over the specified physical axes.
**Example:** If ``self`` represents a bipartite (i.e. length 2)
array with 2 physical dimensions on each site ``A[(k,l), (m,n)]``,
``self.axis_iter(0)`` is equivalent to::
(A[(k, :), (m, :)] for m in range(...) for k in range(...))
:param axes: Iterable or int specifiying the physical axes to iterate
over (default 0 for each site)
:returns: Iterator over :class:`.MPArray`
"""
if not isinstance(axes, collections.Iterable):
axes = it.repeat(axes, len(self))
ltens_iter = it.product(*(iter(np.rollaxis(lten, i + 1))
for i, lten in zip(axes, self.lt)))
return (MPArray(ltens) for ltens in ltens_iter)
##########################
# Algebraic operations #
##########################
def _nanpercentile(a, q, axis=None, out=None, overwrite_input=False,
interpolation='linear', keepdims=False):
"""
Private function that doesn't support extended axis or keepdims.
These methods are extended to this function using _ureduce
See nanpercentile for parameter usage
"""
if axis is None:
part = a.ravel()
result = _nanpercentile1d(part, q, overwrite_input, interpolation)
else:
result = np.apply_along_axis(_nanpercentile1d, axis, a, q,
overwrite_input, interpolation)
# apply_along_axis fills in collapsed axis with results.
# Move that axis to the beginning to match percentile's
# convention.
if q.ndim != 0:
result = np.rollaxis(result, axis)
if out is not None:
out[...] = result
return result
def apply(self, im):
"""
Apply axis-localized displacements.
Parameters
----------
im : ndarray
The image or volume to shift
"""
from scipy.ndimage.interpolation import shift
im = rollaxis(im, self.axis)
im.setflags(write=True)
for ind in range(0, im.shape[0]):
im[ind] = shift(im[ind], map(lambda x: -x, self.delta[ind]), mode='nearest')
im = rollaxis(im, 0, self.axis+1)
return im
def _encode_as_webp(data, profile=None, affine=None):
"""
Uses BytesIO + PIL to encode a (3, 512, 512)
array into a webp bytearray.
Parameters
-----------
data: ndarray
(3 x 512 x 512) uint8 RGB array
profile: None
ignored
affine: None
ignored
Returns
--------
contents: bytearray
webp-encoded bytearray of the provided input data
"""
with BytesIO() as f:
im = Image.fromarray(np.rollaxis(data, 0, 3))
im.save(f, format='webp', lossless=True)
return f.getvalue()
def adaptsize(x, where):
"""Adapt the dimension of an array depending of the tuple dim
Args:
x : the signal for swaping axis
where : where each dimension should be put
Example:
>>> x = np.random.rand(2,4001,160)
>>> adaptsize(x, (1,2,0)).shape -> (160, 2, 4001)
"""
if not isinstance(where, np.ndarray):
where = np.array(where)
where_t = list(where)
for k in range(len(x.shape)-1):
# Find where "where" is equal to "k" :
idx = np.where(where == k)[0]
# Roll axis :
x = np.rollaxis(x, idx, k)
# Update the where variable :
where_t.remove(k)
where = np.array(list(np.arange(k+1)) + where_t)
return x
def _mean_and_std(X, axis=0, with_mean=True, with_std=True):
"""Compute mean and std deviation for centering, scaling.
Zero valued std components are reset to 1.0 to avoid NaNs when scaling.
"""
X = np.asarray(X)
Xr = np.rollaxis(X, axis)
if with_mean:
mean_ = Xr.mean(axis=0)
else:
mean_ = None
if with_std:
std_ = Xr.std(axis=0)
if isinstance(std_, np.ndarray):
std_[std_ == 0.] = 1.0
elif std_ == 0.:
std_ = 1.
else:
std_ = None
return mean_, std_
def logsumexp(a, axis=None, b=None):
a = np.asarray(a)
if axis is None:
a = a.ravel()
else:
a = np.rollaxis(a, axis)
a_max = a.max(axis=0)
if b is not None:
b = np.asarray(b)
if axis is None:
b = b.ravel()
else:
b = np.rollaxis(b, axis)
out = np.log(np.sum(b * np.exp(a - a_max), axis=0))
else:
out = np.log(np.sum(np.exp(a - a_max), axis=0))
out += a_max
return out
def load_test_images():
'''
Loads 64 random images from SVNH test data sets
:return: Tuple of (test images, image labels)
'''
utils.download_train_and_test_data()
_, testset = utils.load_data_sets()
idx = np.random.randint(0, testset['X'].shape[3], size=64)
test_images = testset['X'][:, :, :, idx]
test_labels = testset['y'][idx]
test_images = np.rollaxis(test_images, 3)
test_images = utils.scale(test_images)
return test_images, test_labels
def _nanpercentile(a, q, axis=None, out=None, overwrite_input=False,
interpolation='linear', keepdims=False):
"""
Private function that doesn't support extended axis or keepdims.
These methods are extended to this function using _ureduce
See nanpercentile for parameter usage
"""
if axis is None:
part = a.ravel()
result = _nanpercentile1d(part, q, overwrite_input, interpolation)
else:
result = np.apply_along_axis(_nanpercentile1d, axis, a, q,
overwrite_input, interpolation)
# apply_along_axis fills in collapsed axis with results.
# Move that axis to the beginning to match percentile's
# convention.
if q.ndim != 0:
result = np.rollaxis(result, axis)
if out is not None:
out[...] = result
return result
def __call__(self, plot):
ax = plot.data.axis
xax = plot.data.ds.coordinates.x_axis[ax]
yax = plot.data.ds.coordinates.y_axis[ax]
if not hasattr(self.vertices, "in_units"):
vertices = plot.data.pf.arr(self.vertices, "code_length")
else:
vertices = self.vertices
l_cy = triangle_plane_intersect(plot.data.axis, plot.data.coord, vertices)[:,:,(xax, yax)]
# l_cy is shape (nlines, 2, 2)
# reformat for conversion to plot coordinates
l_cy = np.rollaxis(l_cy,0,3)
# convert all line starting points
l_cy[0] = self.convert_to_plot(plot,l_cy[0])
# convert all line ending points
l_cy[1] = self.convert_to_plot(plot,l_cy[1])
# convert back to shape (nlines, 2, 2)
l_cy = np.rollaxis(l_cy,2,0)
# create line collection and add it to the plot
lc = matplotlib.collections.LineCollection(l_cy, **self.plot_args)
plot._axes.add_collection(lc)
def add_channel(image, channelfirst):
"""
Add channel if missing and make first axis if requested.
>>> import numpy as np
>>> image = np.ones((10, 20))
>>> image = add_channel(image, True)
>>> shapestr(image)
'1x10x20'
:param ndarray image: RBG (h,w,3) or gray-scale image (h,w).
:param bool channelfirst: If True, make channel first axis
:return: Numpy array with channel (as first axis if makefirst=True)
:rtype: numpy.array
"""
if not 2 <= image.ndim <= 3:
raise ValueError('Image must be 2 or 3 channel!')
if image.ndim == 2: # gray-scale image
image = np.expand_dims(image, axis=-1) # add channel axis
return np.rollaxis(image, 2) if channelfirst else image
def eval(self, ss, returnResid=False, *args, **kwargs):
ss = util.segmat(ss)
preds = []
gi = []
for i in xrange(ss.shape[2]):
v = ss[:,:,i]
xs = self.getInputs(v)
gs = self.getTargets(v)
preds.append(self.model[i].evals(xs, *args, **kwargs).squeeze(2))
if returnResid:
gi.append(gs.squeeze(2))
preds = np.rollaxis(np.array(preds), 0,3)
if returnResid:
gs = np.rollaxis(np.array(gi), 0,3)
resids = gs - preds
return preds, resids
else:
return preds
def ensurepil(self, invalidate=True):
if self.dpil is None:
if self.dbuf is not None:
self.dpil = Image.frombytes("RGBA", self.shape, self.dbuf, "raw", "RGBA", 0, 1)
elif self.darr is not None:
data = self.scaledpixelarray(0,255.999)
buf = np.rollaxis(data,1).astype(np.uint8).tostring()
self.dpil = Image.frombytes("RGB", self.shape, buf, "raw", "RGB", 0, -1)
else:
raise ValueError("No source data for conversion to PIL image")
if invalidate:
self.dbuf = None
self.darr = None
self.rangearr = None
## This private function ensures that there is a valid buffer representation, converting from
# one of the other representations if necessary, and invalidating the other representations if requested.
def ensurebuf(self, invalidate=True):
if self.dbuf is None:
if self.dpil is not None:
self.dbuf = self.dpil.tostring("raw", "RGBX", 0, 1)
elif self.darr is not None:
data = self.scaledpixelarray(0,255.999)
self.dbuf = np.dstack(( np.flipud(np.rollaxis(data,1)).astype(np.uint8),
np.zeros(self.shape[::-1],np.uint8) )).tostring()
else:
raise ValueError("No source data for conversion to buffer")
if invalidate:
self.dpil = None
self.darr = None
self.rangearr = None
## This private function ensures that there is a valid numpy array representation, converting from
# one of the other representations if necessary, and invalidating the other representations if requested.
def ensurearr(self, invalidate=True):
if self.darr is None:
if self.dpil is not None:
self.darr = np.fromstring(self.dpil.tostring("raw", "RGB", 0, -1), np.uint8).astype(np.float64)
self.darr = np.rollaxis(np.reshape(self.darr, (self.shape[1], self.shape[0], 3) ), 1)
elif self.dbuf is not None:
self.darr = np.fromstring(self.dbuf, np.uint8).astype(np.float64)
self.darr = np.delete(np.reshape(self.darr, (self.shape[1], self.shape[0], 4) ), 3, 2)
self.darr = np.rollaxis(np.flipud(self.darr), 1)
else:
raise ValueError("No source data for conversion to array")
self.rangearr = ( 0, 255.999 )
if invalidate:
self.dpil = None
self.dbuf = None
# -----------------------------------------------------------------
## This private helper function returns a 2-tuple containing the least and most significant 16-bit portion
# of the specified unsigned 32-bit integer value.
def ensurepil(self, invalidate=True):
if self.dpil is None:
if self.dbuf is not None:
self.dpil = Image.frombytes("RGBA", self.shape, self.dbuf, "raw", "RGBA", 0, 1)
elif self.darr is not None:
data = self.scaledpixelarray(0,255.999)
buf = np.rollaxis(data,1).astype(np.uint8).tostring()
self.dpil = Image.frombytes("RGB", self.shape, buf, "raw", "RGB", 0, -1)
else:
raise ValueError("No source data for conversion to PIL image")
if invalidate:
self.dbuf = None
self.darr = None
self.rangearr = None
## This private function ensures that there is a valid buffer representation, converting from
# one of the other representations if necessary, and invalidating the other representations if requested.
def ensurebuf(self, invalidate=True):
if self.dbuf is None:
if self.dpil is not None:
self.dbuf = self.dpil.tostring("raw", "RGBX", 0, 1)
elif self.darr is not None:
data = self.scaledpixelarray(0,255.999)
self.dbuf = np.dstack(( np.flipud(np.rollaxis(data,1)).astype(np.uint8),
np.zeros(self.shape[::-1],np.uint8) )).tostring()
else:
raise ValueError("No source data for conversion to buffer")
if invalidate:
self.dpil = None
self.darr = None
self.rangearr = None
## This private function ensures that there is a valid numpy array representation, converting from
# one of the other representations if necessary, and invalidating the other representations if requested.
def ensurearr(self, invalidate=True):
if self.darr is None:
if self.dpil is not None:
self.darr = np.fromstring(self.dpil.tostring("raw", "RGB", 0, -1), np.uint8).astype(np.float64)
self.darr = np.rollaxis(np.reshape(self.darr, (self.shape[1], self.shape[0], 3) ), 1)
elif self.dbuf is not None:
self.darr = np.fromstring(self.dbuf, np.uint8).astype(np.float64)
self.darr = np.delete(np.reshape(self.darr, (self.shape[1], self.shape[0], 4) ), 3, 2)
self.darr = np.rollaxis(np.flipud(self.darr), 1)
else:
raise ValueError("No source data for conversion to array")
self.rangearr = ( 0, 255.999 )
if invalidate:
self.dpil = None
self.dbuf = None
# -----------------------------------------------------------------
## This private helper function returns a 2-tuple containing the least and most significant 16-bit portion
# of the specified unsigned 32-bit integer value.
def plot_patches(fig, patches):
if patches.ndim == 4:
channel_step = patches.shape[3] // 3
# patches = np.concatenate([np.sum(patches[:, :, :, i * channel_step:
# (i + 1) * channel_step],
# axis=3)[..., np.newaxis]
# for i in range(3)], axis=3)
if patches.shape[3] == 1:
patches = patches[:, :, :, 0]
elif patches.shape[3] >= 3:
patches = patches[:, :, :, :3]
patches = np.rollaxis(patches, 3, 2).reshape(
(patches.shape[0], patches.shape[1], patches.shape[2] * 3))
patches = patches[:256]
side_size =ceil(sqrt(patches.shape[0]))
for i, patch in enumerate(patches):
ax = fig.add_subplot(side_size, side_size, i + 1)
ax.imshow(
patch,
interpolation='nearest')
ax.set_xticks(())
ax.set_yticks(())
fig.subplots_adjust(0.08, 0.02, 0.92, 0.85, 0.08, 0.23)
return fig
def setUp(self):
with self.test_session():
N = 4
M = 5
self.mu = tf.placeholder(settings.float_type, [M, N])
self.sqrt = tf.placeholder(settings.float_type, [M, N])
self.chol = tf.placeholder(settings.float_type, [M, M, N])
self.I = tf.placeholder(settings.float_type, [M, M])
self.rng = np.random.RandomState(0)
self.mu_data = self.rng.randn(M, N)
self.sqrt_data = self.rng.randn(M, N)
q_sqrt = np.rollaxis(np.array([np.tril(self.rng.randn(M, M)) for _ in range(N)]),
0, 3)
self.chol_data = q_sqrt
self.feed_dict = {
self.mu: self.mu_data,
self.sqrt: self.sqrt_data,
self.chol: self.chol_data,
self.I: np.eye(M),
}
def setUp(self):
with self.test_session():
N = 4
M = 5
self.mu = tf.placeholder(settings.float_type, [M, N])
self.sqrt = tf.placeholder(settings.float_type, [M, N])
self.chol = tf.placeholder(settings.float_type, [M, M, N])
self.K = tf.placeholder(settings.float_type, [M, M])
self.Kdiag = tf.placeholder(settings.float_type, [M, M])
self.rng = np.random.RandomState(0)
self.mu_data = self.rng.randn(M, N)
sqrt_diag = self.rng.randn(M)
self.sqrt_data = np.array([sqrt_diag for _ in range(N)]).T
sqrt_chol = np.tril(self.rng.randn(M, M))
self.chol_data = np.rollaxis(np.array([sqrt_chol for _ in range(N)]), 0, 3)
self.feed_dict = {
self.mu: np.zeros((M, N)),
self.sqrt: self.sqrt_data,
self.chol: self.chol_data,
self.K: squareT(sqrt_chol),
self.Kdiag: np.diag(sqrt_diag ** 2),
}
def collapse(T, W, divisive=False):
if divisive: W = W / np.sum(np.square(W.reshape(W.shape[0], -1)), 1)[:,None,None,None]
if T.shape[-6] == W.shape[0]: # Z ONLY (after 2nd-stage expansion)
W = np.reshape (W, (1,)*(T.ndim-6) + (W.shape[0],1,1) + W.shape[1:])
T = ne.evaluate('T*W')
T = np.reshape (T, T.shape[:-3] + (np.prod(T.shape[-3:]),))
T = np.sum(T, -1)
else: # X ONLY (conv, before 2nd-stage expansion)
T = np.squeeze (T, -6)
T = np.tensordot(T, W, ([-3,-2,-1], [1,2,3]))
T = np.rollaxis (T, -1, 1)
return T
def show_samples(samples, nShow):
"""
Show some input samples.
"""
import math
import matplotlib.pyplot as plt
_, nFeatures, x, y = samples.shape
nColumns = int(math.ceil(nShow/5.))
for i in range(nShow):
plt.subplot(5, nColumns, i+1)
image = samples[i]
image = np.rollaxis(image, 0, 3)*5.
plt.imshow(image)
# plt.axis('off')
def backward_cpu(self, inputs, grad_outputs):
x, W = inputs[:2]
b = inputs[2] if len(inputs) == 3 else None
gy = grad_outputs[0]
h, w = x.shape[2:]
gW = numpy.tensordot(gy, self.col, ((0, 2, 3), (0, 4, 5)))
gcol = numpy.tensordot(W, gy, (0, 1))
gcol = numpy.rollaxis(gcol, 3)
gx = conv.col2im_cpu(gcol, self.sy, self.sx, self.ph, self.pw, h, w)
if b is None:
return gx, gW
else:
gb = gy.sum(axis=(0, 2, 3))
return gx, gW, gb
def forward_cpu(self, inputs):
x, W = inputs[:2]
b = inputs[2] if len(inputs) == 3 else None
kh, kw = W.shape[2:]
_, _, h, w = x.shape
gcol = numpy.tensordot(W, x, (0, 1))
# - k, m, n: shape of out_channel
# - b: number of inputs
# - h, w: height and width of kernels
# k, m, n, b, h, w -> b, k, m, n, h, w
gcol = numpy.rollaxis(gcol, 3)
if self.outh is None:
self.outh = conv.get_deconv_outsize(h, kh, self.sy, self.ph)
if self.outw is None:
self.outw = conv.get_deconv_outsize(w, kw, self.sx, self.pw)
y = conv.col2im_cpu(
gcol, self.sy, self.sx, self.ph, self.pw, self.outh, self.outw)
# b, k, h, w
if b is not None:
y += b.reshape(1, b.size, 1, 1)
return y,
def backward_cpu(self, inputs, grad_outputs):
x, W = inputs[:2]
b = inputs[2] if len(inputs) == 3 else None
gy = grad_outputs[0]
kh, kw = W.shape[2:]
col = conv.im2col_cpu(
gy, kh, kw, self.sy, self.sx, self.ph, self.pw)
gW = numpy.tensordot(x, col, ([0, 2, 3], [0, 4, 5]))
gx = numpy.tensordot(col, W, ([1, 2, 3], [1, 2, 3]))
gx = numpy.rollaxis(gx, 3, 1)
if b is None:
return gx, gW
else:
gb = gy.sum(axis=(0, 2, 3))
return gx, gW, gb
def forward_gpu(self, inputs):
cupy = cuda.cupy
x, t = inputs
log_y = cupy.log(x + 1e-5)
self.y = x
if(self.debug):
ipdb.set_trace()
if getattr(self, 'normalize', True):
coeff = cupy.maximum(1, (t != self.ignore_label).sum())
else:
coeff = max(1, len(t))
self._coeff = cupy.divide(1.0, coeff, dtype=x.dtype)
log_y = cupy.rollaxis(log_y, 1, log_y.ndim)
ret = cuda.reduce(
'S t, raw T log_y, int32 n_channel, raw T coeff', 'T out',
't == -1 ? 0 : log_y[_j * n_channel + t]',
'a + b', 'out = a * -coeff[0]', '0', 'crossent_fwd'
)(t, log_y.reduced_view(), log_y.shape[-1], self._coeff)
return ret,
def forward_cpu(self, inputs):
x, t = inputs
if chainer.is_debug():
self._check_input_values(x, t)
log_y = softmax_log(x, False)
if self.cache_score:
self.y = numpy.exp(log_y)
log_yd = numpy.rollaxis(log_y, 1)
log_yd = log_yd.reshape(len(log_yd), -1)
log_p = log_yd[numpy.maximum(t.ravel(), 0), six.moves.range(t.size)]
# deal with the case where the SoftmaxCrossEntropy is
# unpickled from the old version
if getattr(self, 'normalize', True):
count = (t != self.ignore_label).sum()
else:
count = len(x)
self._coeff = 1.0 / max(count, 1)
y = (log_p * (t.ravel() != self.ignore_label)).sum(keepdims=True) \
* (-self._coeff)
return y.reshape(()),
def forward_gpu(self, inputs):
cupy = cuda.cupy
x, t = inputs
if chainer.is_debug():
self._check_input_values(x, t)
log_y = softmax_log(x, self.use_cudnn)
if self.cache_score:
self.y = cupy.exp(log_y)
if getattr(self, 'normalize', True):
coeff = cupy.maximum(1, (t != self.ignore_label).sum())
else:
coeff = max(1, len(t))
self._coeff = cupy.divide(1.0, coeff, dtype=x.dtype)
log_y = cupy.rollaxis(log_y, 1, log_y.ndim)
ret = cuda.reduce(
'S t, raw T log_y, int32 n_channel, raw T coeff', 'T out',
't == -1 ? T(0) : log_y[_j * n_channel + t]',
'a + b', 'out = a * -coeff[0]', '0', 'crossent_fwd'
)(t, log_y.reduced_view(), log_y.shape[-1], self._coeff)
return ret,
def accuracy(x, t, ignore_label):
x_ = numpy.rollaxis(x, 1, x.ndim).reshape(t.size, -1)
t_ = t.ravel()
if ignore_label is not None:
count = 0
for i in six.moves.range(t_.size):
pred = x_[i].argmax()
if t_[i] != ignore_label and pred == t_[i]:
count += 1
total = (t_ != ignore_label).sum()
else:
count = 0
for i in six.moves.range(t_.size):
pred = x_[i].argmax()
if pred == t_[i]:
count += 1
total = t_.size
if total == 0:
return 0.0
else:
return float(count) / total
def epoch_to_epoch16(self, epoch):
"""
Converts a CDF EPOCH to a CDF EPOCH16 value
Parameters
==========
epoch : double
EPOCH to convert. Lists and numpy arrays are acceptable.
Returns
=======
out : (double, double)
EPOCH16 corresponding to epoch
"""
e = numpy.require(epoch, numpy.float64)
s = numpy.trunc(e / 1000.0)
#ugly numpy stuff, probably a better way....
res = numpy.hstack((s, (e - s * 1000.0) * 1e9))
if len(res) <= 2:
return res
newshape = list(res.shape[0:-2])
newshape.append(res.shape[-1] // 2)
newshape.append(2)
return numpy.rollaxis(res.reshape(newshape), -1, -2)
def backward_cpu(self, inputs, grad_outputs):
x, W = inputs[:2]
Wb = binarize_cpu(W)
b = inputs[2] if len(inputs) == 3 else None
gy = grad_outputs[0]
h, w = x.shape[2:]
gW = numpy.tensordot(gy, self.col, ((0, 2, 3), (0, 4, 5)))
gcol = numpy.tensordot(Wb, gy, (0, 1))
gcol = numpy.rollaxis(gcol, 3)
gx = conv.col2im_cpu(gcol, self.sy, self.sx, self.ph, self.pw, h, w)
if b is None:
return gx, gW
else:
gb = gy.sum(axis=(0, 2, 3))
return gx, gW, gb
def forward_cpu(self, inputs):
x, W = inputs[:2]
b = inputs[2] if len(inputs) == 3 else None
kh, kw = W.shape[2:]
self.col = conv.im2col_cpu(
x, kh, kw, self.sy, self.sx, self.ph, self.pw,
cover_all=self.cover_all)
Wb = numpy.where(W>=0,1,-1).astype(W.dtype, copy=False)
y = numpy.tensordot(
self.col, Wb, ((1, 2, 3), (1, 2, 3))).astype(x.dtype, copy=False)
if b is not None:
y += b
return numpy.rollaxis(y, 3, 1),
def backward_cpu(self, inputs, grad_outputs):
x, W = inputs[:2]
b = inputs[2] if len(inputs) == 3 else None
gy = grad_outputs[0]
h, w = x.shape[2:]
gW = numpy.tensordot(
gy, self.col, ((0, 2, 3), (0, 4, 5))).astype(W.dtype, copy=False)
Wb = numpy.where(W>=0,1,-1).astype(W.dtype, copy=False)
gcol = numpy.tensordot(Wb, gy, (0, 1)).astype(x.dtype, copy=False)
gcol = numpy.rollaxis(gcol, 3)
gx = conv.col2im_cpu(gcol, self.sy, self.sx, self.ph, self.pw, h, w)
if b is None:
return gx, gW
else:
gb = gy.sum(axis=(0, 2, 3))
return gx, gW, gb
def forward_cpu(self, inputs):
x, W = inputs[:2]
b = inputs[2] if len(inputs) == 3 else None
kh, kw = W.shape[2:]
self.col = conv.im2col_cpu(
x, kh, kw, self.sy, self.sx, self.ph, self.pw,
cover_all=self.cover_all)
Xb = numpy.where(self.col>0,1,self.col).astype(x.dtype, copy=False)
Xb = numpy.where(self.col<0,-1,Xb).astype(x.dtype, copy=False)
Wb = numpy.where(W>=0,1,-1).astype(W.dtype, copy=False)
y = numpy.tensordot(
Xb, Wb, ((1, 2, 3), (1, 2, 3))).astype(x.dtype, copy=False)
if b is not None:
y += b
return numpy.rollaxis(y, 3, 1),
def backward_cpu(self, inputs, grad_outputs):
x, W = inputs[:2]
b = inputs[2] if len(inputs) == 3 else None
gy = grad_outputs[0]
h, w = x.shape[2:]
gW = numpy.tensordot(
gy, self.col, ((0, 2, 3), (0, 4, 5))).astype(W.dtype, copy=False)
Wb = numpy.where(W>=0,1,-1).astype(W.dtype, copy=False)
gcol = numpy.tensordot(Wb, gy, (0, 1)).astype(x.dtype, copy=False)
gcol = numpy.rollaxis(gcol, 3)
gx = conv.col2im_cpu(gcol, self.sy, self.sx, self.ph, self.pw, h, w)
if b is None:
return gx, gW
else:
gb = gy.sum(axis=(0, 2, 3))
return gx, gW, gb
def load_video(data):
videoCapture = skvideo.io.VideoCapture(data, (456, 256))
videoCapture.open()
x = []
while True:
retval, image = videoCapture.read()
if retval:
x.append(numpy.rollaxis(image, 2))
else:
break
return numpy.array(x, 'float32')
def backward_cpu(self, inputs, grad_outputs):
x, W = inputs[:2]
Wb = numpy.where(W>=0, 1, -1).astype(numpy.float32, copy=False)
b = inputs[2] if len(inputs) == 3 else None
gy = grad_outputs[0]
h, w = x.shape[2:]
gW = numpy.tensordot(gy, self.col, ((0, 2, 3), (0, 4, 5)))
gcol = numpy.tensordot(Wb, gy, (0, 1))
gcol = numpy.rollaxis(gcol, 3)
gx = conv.col2im_cpu(gcol, self.sy, self.sx, self.ph, self.pw, h, w)
if b is None:
return gx, gW
else:
gb = gy.sum(axis=(0, 2, 3))
return gx, gW, gb
def forward_cpu(self, inputs):
x, t = inputs
if chainer.is_debug():
self._check_input_values(x, t)
log_y = numpy.log(x)
if self.cache_score:
self.y = x
log_yd = numpy.rollaxis(log_y, 1)
log_yd = log_yd.reshape(len(log_yd), -1)
log_p = log_yd[numpy.maximum(t.ravel(), 0), six.moves.range(t.size)]
if getattr(self, 'normalize', True):
count = (t != self.ignore_label).sum()
else:
count = len(x)
self._coeff = 1.0 / max(count, 1)
y = (log_p * (t.ravel() != self.ignore_label)).sum(keepdims=True) * (-self._coeff)
return y.reshape(()),
def forward_gpu(self, inputs):
cupy = cuda.cupy
x, t = inputs
if chainer.is_debug():
self._check_input_values(x, t)
log_y = cupy.log(x)
if self.cache_score:
self.y = x
if getattr(self, 'normalize', True):
coeff = cupy.maximum(1, (t != self.ignore_label).sum())
else:
coeff = max(1, len(t))
self._coeff = cupy.divide(1.0, coeff, dtype=x.dtype)
log_y = cupy.rollaxis(log_y, 1, log_y.ndim)
ret = cuda.reduce(
'S t, raw T log_y, int32 n_channel, raw T coeff', 'T out',
't == -1 ? 0 : log_y[_j * n_channel + t]',
'a + b', 'out = a * -coeff[0]', '0', 'crossent_fwd'
)(t, log_y.reduced_view(), log_y.shape[-1], self._coeff)
return ret,
def plotOutput(layer,feed_dict,fieldShape=None,channel=None,figOffset=1,cmap=None):
# Output summary
try:
W = layer.output
except:
W = layer
wp = W.eval(feed_dict=feed_dict);
if len(np.shape(wp)) < 4: # Fully connected layer, has no shape
temp = np.zeros(np.product(fieldShape)); temp[0:np.shape(wp.ravel())[0]] = wp.ravel()
fields = np.reshape(temp,[1]+fieldShape)
else: # Convolutional layer already has shape
wp = np.rollaxis(wp,3,0)
features, channels, iy,ix = np.shape(wp)
if channel is not None:
fields = wp[:,channel,:,:]
else:
fields = np.reshape(wp,[features*channels,iy,ix])
perRow = int(math.floor(math.sqrt(fields.shape[0])))
perColumn = int(math.ceil(fields.shape[0]/float(perRow)))
fields2 = np.vstack([fields,np.zeros([perRow*perColumn-fields.shape[0]] + list(fields.shape[1:]))])
tiled = []
for i in range(0,perColumn*perRow,perColumn):
tiled.append(np.hstack(fields2[i:i+perColumn]))
tiled = np.vstack(tiled)
if figOffset is not None:
mpl.figure(figOffset); mpl.clf();
mpl.imshow(tiled,cmap=cmap); mpl.title('%s Output' % layer.name); mpl.colorbar();
def plotOutput(layer,feed_dict,fieldShape=None,channel=None,figOffset=1,cmap=None):
# Output summary
W = layer.output
wp = W.eval(feed_dict=feed_dict);
if len(np.shape(wp)) < 4: # Fully connected layer, has no shape
temp = np.zeros(np.product(fieldShape)); temp[0:np.shape(wp.ravel())[0]] = wp.ravel()
fields = np.reshape(temp,[1]+fieldShape)
else: # Convolutional layer already has shape
wp = np.rollaxis(wp,3,0)
features, channels, iy,ix = np.shape(wp)
if channel is not None:
fields = wp[:,channel,:,:]
else:
fields = np.reshape(wp,[features*channels,iy,ix])
perRow = int(math.floor(math.sqrt(fields.shape[0])))
perColumn = int(math.ceil(fields.shape[0]/float(perRow)))
fields2 = np.vstack([fields,np.zeros([perRow*perColumn-fields.shape[0]] + list(fields.shape[1:]))])
tiled = []
for i in range(0,perColumn*perRow,perColumn):
tiled.append(np.hstack(fields2[i:i+perColumn]))
tiled = np.vstack(tiled)
if figOffset is not None:
mpl.figure(figOffset); mpl.clf();
mpl.imshow(tiled,cmap=cmap); mpl.title('%s Output' % layer.name); mpl.colorbar();
def transpose_x(U_send, Uc_hatT, num_processes):
sx = U_send.shape
sy = Uc_hatT.shape
U_send[:] = np.rollaxis(Uc_hatT[:,:-1].reshape(sy[0], num_processes, sx[2]), 1)
return U_send
def transpose_y(Uc_hatT, U_recv, num_processes):
sx = Uc_hatT.shape
sy = U_recv.shape
Uc_hatT[:, :-1] = np.rollaxis(U_recv.reshape(num_processes, sx[0], sy[1]), 1).reshape((sx[0], sx[1]-1))
return Uc_hatT
def transform_Uc_xz(Uc_hat_x, Uc_hat_z, P1):
sz = Uc_hat_z.shape
sx = Uc_hat_x.shape
Uc_hat_x[:] = np.rollaxis(Uc_hat_z[:,:,:-1].reshape((sz[0], sz[1], P1, sx[2])), 2).reshape(sx)
return Uc_hat_x
def transform_Uc_zx(Uc_hat_z, Uc_hat_xr, P1):
sz = Uc_hat_z.shape
sx = Uc_hat_xr.shape
Uc_hat_z[:, :, :-1] = np.rollaxis(Uc_hat_xr.reshape((P1, sz[0], sz[1], sx[2])), 0, 3).reshape((sz[0], sz[1], sz[2]-1))
return Uc_hat_z