def check_call(self):
xp = self.link.xp
# Suppress warning that arises from zero division in BatchNormalization
with numpy.errstate(divide='ignore'):
x1 = Variable(xp.asarray(numpy.random.uniform(
-1, 1, (1, 3, 224, 224)).astype(numpy.float32)))
y1 = cuda.to_cpu(self.link(x1)['prob'].data)
self.assertEqual(y1.shape, (1, 1000))
x2 = Variable(xp.asarray(numpy.random.uniform(
-1, 1, (1, 3, 128, 128)).astype(numpy.float32)))
y2 = cuda.to_cpu(self.link(x2, layers=['pool5'])['pool5'].data)
self.assertEqual(y2.shape, (1, 2048))
def check_call_prob(self):
xp = self.link.xp
x = Variable(xp.asarray(numpy.random.uniform(
-1, 1, (1, 3, 224, 224)).astype(self.dtype)))
y = cuda.to_cpu(self.link(x)['prob'].data)
self.assertEqual(y.shape, (1, 1000))
def check_call_loss2_fc2(self):
xp = self.link.xp
x = Variable(xp.asarray(numpy.random.uniform(
-1, 1, (1, 3, 224, 224)).astype(numpy.float32)))
y = cuda.to_cpu(self.link(x, ['loss2_fc2'])['loss2_fc2'].data)
self.assertEqual(y.shape, (1, 1000))
def predict(self, images, oversample=True):
"""Computes all the probabilities of given images.
Args:
images (iterable of PIL.Image or numpy.ndarray): Input images.
When you specify a color image as a :class:`numpy.ndarray`,
make sure that color order is RGB.
oversample (bool): If ``True``, it averages results across
center, corners, and mirrors. Otherwise, it uses only the
center.
Returns:
~chainer.Variable: Output that contains the class probabilities
of given images.
"""
x = concat_examples([prepare(img, size=(256, 256)) for img in images])
if oversample:
x = imgproc.oversample(x, crop_dims=(224, 224))
else:
x = x[:, :, 16:240, 16:240]
# Use no_backprop_mode to reduce memory consumption
with function.no_backprop_mode(), chainer.using_config('train', False):
x = Variable(self.xp.asarray(x))
y = self(x, layers=['prob'])['prob']
if oversample:
n = len(y) // 10
y_shape = y.shape[1:]
y = reshape(y, (n, 10) + y_shape)
y = sum(y, axis=1) / 10
return y
def check_call(self):
xp = self.link.xp
x1 = Variable(xp.asarray(numpy.random.uniform(
-1, 1, (1, 3, 224, 224)).astype(numpy.float32)))
y1 = cuda.to_cpu(self.link(x1)['prob'].data)
self.assertEqual(y1.shape, (1, 1000))
def extract(self,
images,
layers=['pool5'],
size=(224, 224),
test=True,
volatile=flag.OFF):
"""Extracts all the feature maps of given images.
The difference of directly executing ``__call__`` is that
it directly accepts images as an input and automatically
transforms them to a proper variable. That is,
it is also interpreted as a shortcut method that implicitly calls
``prepare`` and ``__call__`` functions.
Args:
images (iterable of PIL.Image or numpy.ndarray): Input images.
layers (list of str): The list of layer names you want to extract.
size (pair of ints): The resolution of resized images used as
an input of CNN. All the given images are not resized
if this argument is ``None``, but the resolutions of
all the images should be the same.
test (bool): If ``True``, BatchNormalization runs in test mode.
volatile (~chainer.Flag): Volatility flag used for input variables.
Returns:
Dictionary of ~chainer.Variable: A directory in which
the key contains the layer name and the value contains
the corresponding feature map variable.
"""
x = concat_examples([prepare(img, size=size) for img in images])
x = Variable(self.xp.asarray(x), volatile=volatile)
return self(x, layers=layers, test=test)
def extract(self, images, layers=["digitcaps"]):
"""
"""
x = concat_examples([preprocess(image) for image in images])
x = Variable(self.xp.asarray(x))
activations = self(x, layers=layers)
return activations
def predict(self, images, oversample=True):
"""Computes all the probabilities of given images.
Args:
images (iterable of PIL.Image or numpy.ndarray): Input images.
oversample (bool): If ``True``, it averages results across
center, corners, and mirrors. Otherwise, it uses only the
center.
Returns:
~chainer.Variable: Output that contains the class probabilities
of given images.
"""
x = concat_examples([prepare(img, size=(256, 256)) for img in images])
if oversample:
x = imgproc.oversample(x, crop_dims=(224, 224))
else:
x = x[:, :, 16:240, 16:240]
# Set volatile option to ON to reduce memory consumption
x = Variable(self.xp.asarray(x), volatile=flag.ON)
y = self(x, layers=['prob'])['prob']
if oversample:
n = y.data.shape[0] // 10
y_shape = y.data.shape[1:]
y = reshape(y, (n, 10) + y_shape)
y = sum(y, axis=1) / 10
return y
def __call__(self, tree):
# skip the node if whose child is only one
while len(tree.children) == 1 and not tree.is_leaf():
tree = tree.children[0]
if tree.is_leaf():
word = tree.get_word()
# avg
if self.is_leaf_as_chunk:
vector = None
for tok in word.split('/'):
embed = self.get_word_vec(tok)
if vector is None:
vector = self.embed2hidden(embed)
else:
vector += self.embed2hidden(embed)
vector /= len(word.split('/'))
else:
embed = self.get_word_vec(word)
vector = self.embed2hidden(embed)
c = Variable(np.zeros((1, self.mem_units), dtype=np.float32))
else:
left_tree, right_tree = tree.children
leftc = self(left_tree)
rightc = self(right_tree)
# skip the node if whose child is only one
while len(left_tree.children) == 1 and not left_tree.is_leaf():
left_tree = left_tree.children[0]
while len(right_tree.children) == 1 and not right_tree.is_leaf():
right_tree = right_tree.children[0]
left_vec = left_tree.data['vector']
right_vec = right_tree.data['vector']
# composition by tree lstm
left_attention_vec = self.calc_attention(left_tree)
right_attention_vec = self.calc_attention(right_tree)
concat = F.concat(
(left_vec, right_vec, left_attention_vec, right_attention_vec))
u_l = self.updatel(concat)
u_r = self.updater(concat)
i_l = self.inputl(concat)
i_r = self.inputr(concat)
if self.comp_type == Composition.tree_attention_lstm:
concatl = F.concat((left_vec, left_attention_vec))
concatr = F.concat((right_vec, right_attention_vec))
f_l = self.forgetl(concatr)
f_r = self.forgetr(concatl)
elif self.comp_type == Composition.attention_slstm:
f_l = self.forgetl(concat)
f_r = self.forgetr(concat)
o_l = self.outputl(concat)
o_r = self.outputr(concat)
l_v = F.concat((u_l, i_l, f_l, o_l))
r_v = F.concat((u_r, i_r, f_r, o_r))
c, vector = F.slstm(leftc, rightc, l_v, r_v)
tree.data['vector'] = vector
if tree.is_root():
self.calc_attention(tree)
return c
def check_call_loss1_fc2(self):
xp = self.link.xp
x = Variable(
xp.asarray(
numpy.random.uniform(-1, 1,
(1, 3, 224, 224)).astype(self.dtype)))
y = cuda.to_cpu(self.link(x, ['loss1_fc2'])['loss1_fc2'].data)
assert y.shape == (1, 1000)
def check_call(self):
xp = self.link.xp
x1 = Variable(
xp.asarray(
numpy.random.uniform(-1, 1,
(1, 3, 224, 224)).astype(self.dtype)))
y1 = cuda.to_cpu(self.link(x1)['prob'].data)
assert y1.shape == (1, 1000)
def extract(self, images, layers=None, size=(224, 224), **kwargs):
"""extract(self, images, layers=['pool5'], size=(224, 224))
Extracts all the feature maps of given images.
The difference of directly executing ``forward`` is that
it directly accepts images as an input and automatically
transforms them to a proper variable. That is,
it is also interpreted as a shortcut method that implicitly calls
``prepare`` and ``forward`` functions.
Unlike ``predict`` method, this method does not override
``chainer.config.train`` and ``chainer.config.enable_backprop``
configuration. If you want to extract features without updating
model parameters, you need to manually set configuration when
calling this method as follows:
.. code-block:: python
# model is an instance of ResNetLayers (50 or 101 or 152 layers)
with chainer.using_config('train', False):
with chainer.using_config('enable_backprop', False):
feature = model.extract([image])
Args:
images (iterable of PIL.Image or numpy.ndarray): Input images.
layers (list of str): The list of layer names you want to extract.
size (pair of ints): The resolution of resized images used as
an input of CNN. All the given images are not resized
if this argument is ``None``, but the resolutions of
all the images should be the same.
Returns:
Dictionary of ~chainer.Variable: A directory in which
the key contains the layer name and the value contains
the corresponding feature map variable.
"""
if layers is None:
layers = ['pool5']
if kwargs:
argument.check_unexpected_kwargs(
kwargs,
test='test argument is not supported anymore. '
'Use chainer.using_config',
volatile='volatile argument is not supported anymore. '
'Use chainer.using_config')
argument.assert_kwargs_empty(kwargs)
x = concat_examples([prepare(img, size=size) for img in images])
x = Variable(self.xp.asarray(x))
return self(x, layers=layers)
def extract(self, images, layers=None, size=(224, 224), **kwargs):
"""extract(self, images, layers=['pool5'], size=(224, 224))
Extracts all the feature maps of given images.
The difference of directly executing ``__call__`` is that
it directly accepts images as an input and automatically
transforms them to a proper variable. That is,
it is also interpreted as a shortcut method that implicitly calls
``prepare`` and ``__call__`` functions.
.. warning::
``train`` and ``volatile`` arguments are not supported anymore since
v2.
Instead, use ``chainer.using_config('train', train)`` and
``chainer.using_config('enable_backprop', not volatile)``
respectively.
See :func:`chainer.using_config`.
Args:
images (iterable of PIL.Image or numpy.ndarray): Input images.
layers (list of str): The list of layer names you want to extract.
size (pair of ints): The resolution of resized images used as
an input of CNN. All the given images are not resized
if this argument is ``None``, but the resolutions of
all the images should be the same.
Returns:
Dictionary of ~chainer.Variable: A directory in which
the key contains the layer name and the value contains
the corresponding feature map variable.
"""
if layers is None:
layers = ['pool5']
argument.check_unexpected_kwargs(
kwargs,
train='train argument is not supported anymore. '
'Use chainer.using_config',
volatile='volatile argument is not supported anymore. '
'Use chainer.using_config')
argument.assert_kwargs_empty(kwargs)
x = concat_examples([prepare(img, size=size) for img in images])
x = Variable(self.xp.asarray(x))
return self(x, layers=layers)
def __call__(self, x, test=False, output_inter=False):
bs = []
numlinks = len(self.links)
if output_inter:
interm_results = [x]
for i, link in enumerate(self.links):
if isinstance(link, Sequential):
# detach if in different stages
#if reduce(lambda x,y: x and y, [stage not in link._stages for stage in self._stages]):
if self.current_stage not in link._stages:
y = Variable(x.data, x.volatile)
else:
y = x
b = link(y, test=test)
bs.append(b[0])
# Currently not support branch inside a branch
# elif isinstance(link, function.dropout):
# x = link(x, train=not test)
elif isinstance(link, chainer.links.BatchNormalization):
x = link(x, test=test)
elif hasattr(link,'__call__') and 'train' in inspect.getargspec(link.__call__)[0]:
#print("train",link)
x = link(x, train=not test)
elif hasattr(link,'__call__') and 'test' in inspect.getargspec(link.__call__)[0]:
#print("test",link)
x = link(x, test=test)
else:
x = link(x)
# do not update this branch if not the current stage
if self.current_stage not in self._stages:
x.unchain_backward()
if output_inter:
interm_results.append(x.data)
bs.append(x)
if output_inter:
return tuple(bs), interm_results
else:
return tuple(bs)
def __call__(self, trainer=None):
iterator = self._iterators['main']
linearmodel = self._targets['main'].predictor
if self.eval_hook:
self.eval_hook(self)
it = copy.copy(iterator)
for batch in it:
observation = {}
with reporter_module.report_scope(observation):
in_arrays = self.converter(batch, self.device)
in_vars = tuple(Variable(x) for x in in_arrays)
bold = in_vars[0]
pred_z = linearmodel(bold).data
if args.gpu_device != -1:
pred_z = pred_z.get()
savemat(self.filen, {'z': pred_z})
from PIL import Image
import cv2
import numpy as np
from chainer import Chain
from chainer.links import Linear, Convolution2D
from chainer.functions import relu, softmax_cross_entropy
from chainer.variable import Variable
from raspi_ip import IP
conv = Convolution2D(3, 1, 3)
edge_filter = np.array([[[[0, -1, 0], [-1, 1, -1], [0, -1, 0]],
[[0, -1, 0], [-1, 1, -1], [0, -1, 0]],
[[0, -1, 0], [-1, 1, -1], [0, -1, 0]]]],
dtype=np.float32)
conv.W = Variable(edge_filter)
def gen_name(dir):
i = 0
while True:
if not os.path.exists(dir + "/" + f"img-{i}.jpg"):
break
i += 1
return dir + "/" + f"img-{i}.jpg"
def detect_line(img):
def extract(self, images, layers=None, size=(224, 224), **kwargs):
"""extract(self, images, layers=['fc7'], size=(224, 224))
Extracts all the feature maps of given images.
The difference of directly executing ``forward`` is that
it directly accepts images as an input and automatically
transforms them to a proper variable. That is,
it is also interpreted as a shortcut method that implicitly calls
``prepare`` and ``forward`` functions.
Unlike ``predict`` method, this method does not override
``chainer.config.train`` and ``chainer.config.enable_backprop``
configuration. If you want to extract features without updating
model parameters, you need to manually set configuration when
calling this method as follows:
.. code-block:: python
# model is an instance of VGGLayers (16 or 19 layers)
with chainer.using_config('train', False):
with chainer.using_config('enable_backprop', False):
feature = model.extract([image])
.. warning::
``test`` and ``volatile`` arguments are not supported
anymore since v2. Instead, users should configure
training and volatile modes with ``train`` and
``enable_backprop``, respectively.
Note that default behavior of this method is different
between v1 and later versions. Specifically,
the default values of ``test`` in v1 were ``True`` (test mode).
But that of ``chainer.config.train`` is also ``True``
(train mode). Therefore, users need to explicitly switch
``train`` to ``False`` to run the code in test mode and
``enable_backprop`` to ``False`` to turn off
coputational graph construction.
See the `upgrade guide <https://docs.chainer.org/en/stable\
/upgrade_v2.html#training-mode-is-configured-by-a-thread-local-flag>`_.
Args:
images (iterable of PIL.Image or numpy.ndarray): Input images.
layers (list of str): The list of layer names you want to extract.
size (pair of ints): The resolution of resized images used as
an input of CNN. All the given images are not resized
if this argument is ``None``, but the resolutions of
all the images should be the same.
Returns:
Dictionary of ~chainer.Variable: A directory in which
the key contains the layer name and the value contains
the corresponding feature map variable.
"""
if layers is None:
layers = ['fc7']
if kwargs:
argument.check_unexpected_kwargs(
kwargs,
test='test argument is not supported anymore. '
'Use chainer.using_config',
volatile='volatile argument is not supported anymore. '
'Use chainer.using_config')
argument.assert_kwargs_empty(kwargs)
x = concat_examples([prepare(img, size=size) for img in images])
x = Variable(self.xp.asarray(x))
return self(x, layers=layers)
def __call__(self, x):
xp = cuda.get_array_module(x.data)
ln_var = math.log(self.std ** 2)
noise = chainer.functions.gaussian(Variable(xp.zeros_like(x.data)), Variable(xp.full_like(x.data, ln_var)))
return x + noise
import chainer.computational_graph as c
from chainercv.datasets import voc_bbox_label_names
import numpy as np
from chainer.variable import Variable
import pydotplus
from multi_task.multi_task_300 import Multi_task_300
x_data = np.zeros([1, 3, 300, 300], dtype=np.float32)
x = Variable(x_data)
model = Multi_task_300(n_fg_class=len(voc_bbox_label_names), pretrained_model='imagenet',detection=True,segmentation=True,attention=True)
detection,mask = model(x)
a,b=detection
#loc,conf=detection
g = c.build_computational_graph([a,b,mask],remove_variable=True)
dot_format = g._to_dot()
graph=pydotplus.graph_from_dot_data(dot_format)
graph.write_pdf('visualization.pdf')
with open('visualization.gv', 'w') as o:
o.write(g.dump())
sigma = noiseLevel*255.0
print("やるぞ")
gradList = []
for _ in range(sampleSize):
print("槍中")
x = np.asarray(image, dtype=np.float32)
# RGB to BGR
x = x[:,:,::-1]
# 平均を引く
x -= np.array([103.939, 116.779, 123.68], dtype=np.float32)
x = x.transpose((2, 0, 1))
x = x[np.newaxis]
# ノイズを追加
x += sigma*np.random.randn(x.shape[0],x.shape[1],x.shape[2],x.shape[3])
x = Variable(np.asarray(x))
# FPして最終層を取り出す
y = model(x, layers=['prob'])['prob']
# 予測が最大のラベルでBP
t = np.zeros((x.data.shape[0]),dtype=np.int32)
#t[:] = np.argmax(y.data)
y_data = y.data
#print(y_data)
#print(y_data.shape)
t[:] = y_data.argsort()[0][-2] # 2番目に高いラベル
t = Variable(np.asarray(t))
loss = F.softmax_cross_entropy(y,t)
loss.backward()
# 勾配をリストに追加
grad = np.copy(x.grad)
gradList.append(grad)
model = L.Classifier(lm)
serializers.load_npz(args.model, model)
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
model.to_gpu()
model.predictor.reset_state()
primetext = args.primetext
if isinstance(primetext, six.binary_type):
primetext = primetext.decode('utf-8')
if primetext in vocab:
prev_word = Variable(xp.array([vocab[primetext]], xp.int32))
else:
print('ERROR: Unfortunately ' + primetext + ' is unknown.')
exit()
prob = F.softmax(model.predictor(prev_word))
sys.stdout.write(primetext + ' ')
for i in six.moves.range(args.length):
prob = F.softmax(model.predictor(prev_word))
if args.sample > 0:
probability = cuda.to_cpu(prob.data)[0].astype(np.float64)
probability /= np.sum(probability)
index = np.random.choice(range(len(probability)), p=probability)
else:
index = np.argmax(cuda.to_cpu(prob.data))
