repo stringlengths 2 99 | file stringlengths 13 225 | code stringlengths 0 18.3M | file_length int64 0 18.3M | avg_line_length float64 0 1.36M | max_line_length int64 0 4.26M | extension_type stringclasses 1
value |
|---|---|---|---|---|---|---|
chainer | chainer-master/chainer/functions/pooling/roi_average_align_2d.py | # Modified work:
# -----------------------------------------------------------------------------
# Copyright (c) 2018 Preferred Infrastructure, Inc.
# Copyright (c) 2018 Preferred Networks, Inc.
# -----------------------------------------------------------------------------
# Original work:
# -------------------------... | 23,553 | 39.332192 | 79 | py |
chainer | chainer-master/chainer/functions/pooling/average_pooling_2d.py | import numpy
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer.backends import intel64
from chainer import function_node
from chainer.functions.pooling import average_pooling_nd
from chainer.functions.pooling import pooling_2d
from chainer.utils import conv
import chainerx
cla... | 8,383 | 35.77193 | 79 | py |
chainer | chainer-master/chainer/functions/pooling/upsampling_2d.py | import numpy
from chainer.backends import cuda
from chainer import function_node
from chainer.functions.pooling import pooling_2d
from chainer.utils import conv
from chainer.utils import type_check
class Upsampling2D(pooling_2d.Pooling2D):
"""Upsampling over a set of 2d planes w/ indices used for max pooling.""... | 9,757 | 38.666667 | 79 | py |
chainer | chainer-master/chainer/functions/pooling/unpooling_nd.py | import numpy
import six
from chainer import backend
from chainer import function_node
from chainer.functions.pooling import pooling_nd
from chainer.utils import conv
from chainer.utils import conv_nd
from chainer.utils import type_check
class UnpoolingND(pooling_nd._PoolingND):
"""Unpooling over a set of N-dimen... | 6,503 | 33.967742 | 79 | py |
chainer | chainer-master/chainer/functions/pooling/__init__.py | 0 | 0 | 0 | py | |
chainer | chainer-master/chainer/functions/pooling/max_pooling_nd.py | import functools
from operator import mul
import numpy
import six
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer.backends import intel64
from chainer import configuration
from chainer import function_node
from chainer.functions.pooling import max_pooling_nd_kernel
from chain... | 17,994 | 33.605769 | 79 | py |
chainer | chainer-master/chainer/functions/pooling/unpooling_2d.py | import numpy
import numpy.lib.stride_tricks
try:
import cupy.lib.stride_tricks # NOQA
except Exception:
pass
from chainer import backend
from chainer.backends import cuda
from chainer import function_node
from chainer.functions.pooling import pooling_2d
from chainer.utils import conv
from chainer.utils import... | 6,940 | 39.121387 | 79 | py |
chainer | chainer-master/chainer/functions/theano/theano_function.py | import six
from chainer import backend
from chainer.backends import cuda
from chainer import function
from chainer.utils import type_check
class TheanoFunction(function.Function):
def __init__(self, forward_func, backward_func):
self.forward_func = forward_func
self.backward_func = backward_func... | 2,311 | 32.507246 | 76 | py |
chainer | chainer-master/chainer/functions/theano/__init__.py | 0 | 0 | 0 | py | |
chainer | chainer-master/chainer/functions/normalization/group_normalization.py | import numpy
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import configuration
from chainer import function_node
from chainer.utils import type_check
if cuda.cudnn_enabled:
cudnn = cuda.cudnn
libcudnn = cuda.cuda.cudnn
class GroupNormalization(function_node.Func... | 13,988 | 32.953883 | 78 | py |
chainer | chainer-master/chainer/functions/normalization/l2_normalization.py | import six
from chainer import backend
from chainer import function_node
import chainer.functions
from chainer import utils
from chainer.utils import type_check
class _SetItemZero(function_node.FunctionNode):
"""Write values to mask of zero-initialized array"""
def __init__(self, mask):
self.mask =... | 3,642 | 30.95614 | 78 | py |
chainer | chainer-master/chainer/functions/normalization/layer_normalization.py | from chainer import backend
from chainer import function_node
import chainer.functions
from chainer.utils import type_check
class LayerNormalization(function_node.FunctionNode):
"""Layer normalization"""
def __init__(self, eps=1e-5):
self.eps = eps
def check_type_forward(self, in_types):
... | 3,301 | 29.293578 | 78 | py |
chainer | chainer-master/chainer/functions/normalization/batch_renormalization.py | import warnings
import numpy
from chainer import backend
from chainer.backends import cuda
from chainer import configuration
from chainer import function
from chainer.functions.normalization import batch_normalization
from chainer.utils import type_check
def _xhat(x, mean, std, expander):
x_mu = x - mean[expand... | 8,316 | 36.129464 | 82 | py |
chainer | chainer-master/chainer/functions/normalization/decorrelated_batch_normalization.py | import numpy
from chainer import backend
from chainer import function_node
from chainer.utils import argument
from chainer.utils import type_check
# {numpy: True, cupy: False}
_xp_supports_batch_eigh = {}
# routines for batched matrices
def _eigh(a, xp):
if xp not in _xp_supports_batch_eigh:
try:
... | 11,689 | 32.591954 | 79 | py |
chainer | chainer-master/chainer/functions/normalization/local_response_normalization.py | import numpy
import six
from chainer.backends import cuda
from chainer.backends import intel64
from chainer import function_node
from chainer.utils import type_check
def _cu_conv_sum(y, x, n):
# Convolutional sum
# TODO(beam2d): Use scan computation
rdim = x.size // (x.shape[0] * x.shape[1])
cuda.ele... | 6,877 | 31.29108 | 79 | py |
chainer | chainer-master/chainer/functions/normalization/__init__.py | 0 | 0 | 0 | py | |
chainer | chainer-master/chainer/functions/normalization/batch_normalization.py | import warnings
import numpy
import six
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer.backends import intel64
from chainer import configuration
from chainer import function_node
from chainer import memory_layouts
from chainer.utils import argument
from chainer.utils import ... | 38,911 | 38.186304 | 79 | py |
chainer | chainer-master/chainer/functions/rnn/lstm.py | import numpy
import six
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer.backends import intel64
from chainer import function
from chainer import function_node
from chainer.utils import type_check
import chainerx
def _extract_gates(x):
r = x.reshape((len(x), x.shape[1] //... | 12,992 | 31.810606 | 79 | py |
chainer | chainer-master/chainer/functions/rnn/n_step_gru.py | import numpy
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer.functions.activation import sigmoid
from chainer.functions.activation import tanh
from chainer.functions.array import concat
from chainer.functions.array import split_axis
from chainer.functions.connection import lin... | 17,052 | 40.796569 | 78 | py |
chainer | chainer-master/chainer/functions/rnn/tree_lstm.py | import numpy
import six
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import function
from chainer.utils import type_check
import chainerx
def _extract_gates(x, n_split=5):
"""Extract gates by split.
This is different from ``_extract_gates`` in lstm.py,
which ... | 10,927 | 36.296928 | 79 | py |
chainer | chainer-master/chainer/functions/rnn/slstm.py | import numpy
import six
from chainer import backend
from chainer.backends import cuda
from chainer.backends import intel64
from chainer import function
from chainer import function_node
from chainer.utils import type_check
import chainerx
def _extract_gates(x):
r = x.reshape((x.shape[0], x.shape[1] // 4, 4) + x.... | 15,311 | 34.526682 | 79 | py |
chainer | chainer-master/chainer/functions/rnn/n_step_lstm.py | import numpy
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer.functions.array import reshape
from chainer.functions.array import stack
from chainer.functions.connection import linear
from chainer.functions.rnn import lstm
from chainer.functions.rnn import n_step_rnn
from chaine... | 22,970 | 40.917883 | 79 | py |
chainer | chainer-master/chainer/functions/rnn/__init__.py | 0 | 0 | 0 | py | |
chainer | chainer-master/chainer/functions/rnn/n_step_rnn.py | import itertools
import numpy
import six
import chainer
import chainerx
from chainer import backend
from chainer import variable
from chainer.backends import cuda
from chainer import configuration
from chainer import function
from chainer.functions.activation import relu
from chainer.functions.activation import tanh
... | 33,371 | 37.491349 | 79 | py |
chainer | chainer-master/chainer/functions/util/forget.py | import chainer
from chainer import function
from chainer import function_node
from chainer import variable
def _call_func(func, xs):
outs = func(*xs)
if isinstance(outs, tuple):
for i, out in enumerate(outs):
if isinstance(out, variable.Variable):
continue
n = ... | 5,860 | 36.33121 | 79 | py |
chainer | chainer-master/chainer/functions/util/__init__.py | 0 | 0 | 0 | py | |
chainer | chainer-master/chainer/functions/array/squeeze.py | import six
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
def argone(iterable):
result = []
for i, x in enumerate(iterable):
if not isinstance(x, six.integer_types):
raise ValueError('elements in iterable must be int')
if x == 1:... | 3,313 | 28.589286 | 79 | py |
chainer | chainer-master/chainer/functions/array/rollaxis.py | import six
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
class Rollaxis(function_node.FunctionNode):
"""Roll axis of an array."""
def __init__(self, axis, start):
if not isinstance(axis, six.integer_types):
raise TypeError('axis must ... | 2,092 | 27.283784 | 73 | py |
chainer | chainer-master/chainer/functions/array/concat.py | import numpy
import six
import chainer
from chainer import backend
from chainer.backends import intel64
from chainer import function_node
from chainer.utils import type_check
import chainerx
class Concat(function_node.FunctionNode):
"""Concatenate multiple tensors towards specified axis."""
# concat along ... | 3,365 | 29.6 | 79 | py |
chainer | chainer-master/chainer/functions/array/depth2space.py | import numpy
import chainer
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
class Depth2Space(function_node.FunctionNode):
"""Depth to space transformation."""
def __init__(self, r):
self.r = r
def check_type_forward(self, in_types):
t... | 2,907 | 29.291667 | 76 | py |
chainer | chainer-master/chainer/functions/array/permutate.py | import numpy
import six
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import function_node
from chainer.utils import type_check
def _check_indices(indices):
if len(indices) == 0:
return
# TODO(unno): Check indices without cpu
indices = cuda.to_cpu(indic... | 4,025 | 28.822222 | 78 | py |
chainer | chainer-master/chainer/functions/array/separate.py | from chainer import backend
from chainer import function_node
from chainer.functions.array import stack
from chainer.utils import type_check
class Separate(function_node.FunctionNode):
"""Function that separates a given array."""
def __init__(self, axis):
self.axis = axis
def check_type_forward... | 2,459 | 27.941176 | 78 | py |
chainer | chainer-master/chainer/functions/array/copy.py | import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import function_node
from chainer.utils import type_check
import chainerx
class Copy(function_node.FunctionNode):
"""Copies the input variable onto the specified device."""
def __init__(self, in_device, out_device):
... | 3,635 | 32.981308 | 79 | py |
chainer | chainer-master/chainer/functions/array/get_item.py | import numpy
import chainer
from chainer import backend
from chainer import function_node
from chainer import utils
from chainer.utils import type_check
from chainer import variable
import chainerx
_numpy_supports_0d_bool_index = \
numpy.lib.NumpyVersion(numpy.__version__) >= '1.13.0'
class GetItem(function_no... | 4,935 | 30.641026 | 78 | py |
chainer | chainer-master/chainer/functions/array/flipud.py | from chainer import backend
from chainer import function_node
from chainer.utils import type_check
class FlipUD(function_node.FunctionNode):
"""Flip array in the up/down direction."""
def check_type_forward(self, in_types):
type_check._argname(in_types, ('a',))
a_type = in_types[0]
... | 872 | 21.973684 | 73 | py |
chainer | chainer-master/chainer/functions/array/spatial_transformer_sampler.py | import numpy
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import function
from chainer.utils import argument
from chainer.utils import type_check
if cuda.cudnn_enabled:
cudnn = cuda.cudnn
libcudnn = cuda.libcudnn
_sampler_type = cuda.libcudnn.CUDNN_SAMPLER_BIL... | 11,635 | 35.939683 | 78 | py |
chainer | chainer-master/chainer/functions/array/as_strided.py | import numpy as np
import six
from chainer import backend
from chainer.backends import cuda
from chainer import function_node
from chainer.utils import type_check
index_dtype = {t().itemsize: t for t in np.sctypes['int']}
def _byte2step(iterable, itemsize):
for i in iterable:
assert i % itemsize == 0
... | 14,427 | 35.994872 | 79 | py |
chainer | chainer-master/chainer/functions/array/diagonal.py | import numpy
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
class Diagonal(function_node.FunctionNode):
def __init__(self, offset, axis1, axis2):
self.offset = offset
self.axis1 = axis1
self.axis2 = axis2
def check_type_forward(sel... | 2,584 | 29.411765 | 79 | py |
chainer | chainer-master/chainer/functions/array/fliplr.py | from chainer import backend
from chainer import function_node
from chainer.utils import type_check
class FlipLR(function_node.FunctionNode):
"""Flip array in the left/right direction."""
def check_type_forward(self, in_types):
type_check._argname(in_types, ('a',))
a_type = in_types[0]
... | 878 | 22.131579 | 73 | py |
chainer | chainer-master/chainer/functions/array/moveaxis.py | import six
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
def _normalize_axis_tuple(axis, ndim):
ret = []
for ax in axis:
ret.append(ax % ndim)
return ret
def _moveaxis(a, source, destination, xp):
if hasattr(xp, 'moveaxis'):
retur... | 4,098 | 31.023438 | 76 | py |
chainer | chainer-master/chainer/functions/array/scatter_add.py | import numpy
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import function_node
from chainer.utils import type_check
import chainerx
class ScatterAdd(function_node.FunctionNode):
def __init__(self, slices):
if isinstance(slices, list):
if all([isin... | 3,309 | 29.648148 | 77 | py |
chainer | chainer-master/chainer/functions/array/tile.py | import six
import chainer
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
class Tile(function_node.FunctionNode):
"""Tiling of an array."""
def __init__(self, reps):
if isinstance(reps, six.integer_types):
self.reps = (reps,)
el... | 4,207 | 28.843972 | 78 | py |
chainer | chainer-master/chainer/functions/array/cast.py | import numpy
import chainer
from chainer import function_node
from chainer.utils import type_check
class Cast(function_node.FunctionNode):
"""Cast function."""
def __init__(self, typ):
self.type = typ
def check_type_forward(self, in_types):
type_check._argname(in_types, ('x',))
de... | 1,478 | 23.65 | 60 | py |
chainer | chainer-master/chainer/functions/array/swapaxes.py | from chainer import function_node
from chainer.utils import type_check
class Swapaxes(function_node.FunctionNode):
"""Swap two axes of an array."""
def __init__(self, axis1, axis2):
self.axis1 = axis1
self.axis2 = axis2
def check_type_forward(self, in_types):
type_check.expect(in... | 1,426 | 24.482143 | 73 | py |
chainer | chainer-master/chainer/functions/array/broadcast.py | import six
import chainer
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
import chainerx
class Broadcast(function_node.FunctionNode):
"""Function that broadcasts given arrays."""
def check_type_forward(self, in_types):
type_check.expect(in_types.s... | 4,232 | 29.673913 | 77 | py |
chainer | chainer-master/chainer/functions/array/space2depth.py | import chainer
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
class Space2Depth(function_node.FunctionNode):
"""Space to depth transformation."""
def __init__(self, r):
self.r = r
def check_type_forward(self, in_types):
type_check._arg... | 2,545 | 28.604651 | 77 | py |
chainer | chainer-master/chainer/functions/array/reshape.py | import chainer
from chainer import function_node
from chainer.utils import type_check
def _count_unknown_dims(shape):
cnt = 0
for dim in shape:
cnt += dim < 0
return cnt
class Reshape(function_node.FunctionNode):
"""Reshapes an input array without copy."""
def __init__(self, shape):
... | 2,918 | 28.19 | 77 | py |
chainer | chainer-master/chainer/functions/array/where.py | import numpy
import chainer
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
class Where(function_node.FunctionNode):
"""Choose elements depending on condition."""
def __init__(self, condition):
self.condition = condition
def check_type_forward... | 2,995 | 31.565217 | 74 | py |
chainer | chainer-master/chainer/functions/array/expand_dims.py | import chainer
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
class ExpandDims(function_node.FunctionNode):
"""Expands dimensions of an input array without copy."""
def __init__(self, axis):
self.axis = int(axis)
def check_type_forward(self, i... | 2,057 | 26.810811 | 78 | py |
chainer | chainer-master/chainer/functions/array/flatten.py | import chainer
def flatten(x):
"""Flatten a given array into one dimension.
Args:
x (:class:`~chainer.Variable` or :ref:`ndarray`): Input variable.
Returns:
~chainer.Variable: Output variable flatten to one dimension.
.. note::
When you input a scalar array (i.e. the shape ... | 891 | 21.3 | 73 | py |
chainer | chainer-master/chainer/functions/array/hstack.py | import numpy
import six
import chainer
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
class Hstack(function_node.FunctionNode):
"""Concatenate multiple tensors horizontally (column wise)."""
def check_type_forward(self, in_types):
type_check.expec... | 3,651 | 31.035088 | 79 | py |
chainer | chainer-master/chainer/functions/array/transpose.py | import numpy
from chainer import function_node
from chainer.utils import type_check
class Transpose(function_node.FunctionNode):
"""Permute the dimensions of an array."""
def __init__(self, axes=None):
self.axes = axes
def check_type_forward(self, in_types):
type_check.expect(in_types.s... | 2,061 | 26.131579 | 79 | py |
chainer | chainer-master/chainer/functions/array/spatial_transformer_grid.py | import numpy
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import function
from chainer.utils import argument
from chainer.utils import type_check
if cuda.cudnn_enabled:
cudnn = cuda.cudnn
libcudnn = cuda.libcudnn
_sampler_type = cuda.libcudnn.CUDNN_SAMPLER_BILI... | 5,933 | 33.5 | 78 | py |
chainer | chainer-master/chainer/functions/array/repeat.py | import six
from chainer import backend
from chainer import function_node
from chainer import utils
from chainer.utils import type_check
class Repeat(function_node.FunctionNode):
"""Repeat elements of an array."""
def __init__(self, repeats, axis=None):
if isinstance(repeats, six.integer_types):
... | 4,817 | 29.884615 | 78 | py |
chainer | chainer-master/chainer/functions/array/select_item.py | import numpy
import six
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import function_node
from chainer.utils import type_check
class SelectItem(function_node.FunctionNode):
"""Select elements stored in given indices."""
def check_type_forward(self, in_types):
... | 3,484 | 28.041667 | 77 | py |
chainer | chainer-master/chainer/functions/array/im2col.py | import numpy
from chainer import function_node
from chainer.utils.conv import col2im_cpu
from chainer.utils.conv import col2im_gpu
from chainer.utils.conv import im2col_cpu
from chainer.utils.conv import im2col_gpu
from chainer.utils import type_check
def _pair(x):
if hasattr(x, '__getitem__'):
return x
... | 5,495 | 32.717791 | 79 | py |
chainer | chainer-master/chainer/functions/array/vstack.py | import numpy
import six
import chainer
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
class Vstack(function_node.FunctionNode):
"""Concatenate multiple tensors vertically (row wise)."""
def check_type_forward(self, in_types):
type_check.expect(in_... | 3,567 | 31.144144 | 79 | py |
chainer | chainer-master/chainer/functions/array/__init__.py | 0 | 0 | 0 | py | |
chainer | chainer-master/chainer/functions/array/stack.py | import chainer
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
import chainerx
class Stack(function_node.FunctionNode):
"""Concatenate variables along a new axis."""
def __init__(self, axis):
self.axis = axis
def check_type_forward(self, in_typ... | 3,888 | 28.915385 | 78 | py |
chainer | chainer-master/chainer/functions/array/dstack.py | import numpy
import six
import chainer
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
class Dstack(function_node.FunctionNode):
"""Concatenate multiple tensors along third axis (depth wise)."""
def check_type_forward(self, in_types):
type_check.ex... | 4,433 | 30.671429 | 79 | py |
chainer | chainer-master/chainer/functions/array/flip.py | import six
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
def _flip(array, axis):
indices = [slice(None)] * array.ndim
indices[axis] = slice(None, None, -1)
return array[tuple(indices)]
class Flip(function_node.FunctionNode):
"""Flips an input var... | 1,569 | 27.035714 | 78 | py |
chainer | chainer-master/chainer/functions/array/pad_sequence.py | import numpy
import six
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import function_node
from chainer import utils
from chainer.utils import type_check
class PadSequence(function_node.FunctionNode):
"""Padding arrays to create a matrix."""
def __init__(self, le... | 3,502 | 31.435185 | 79 | py |
chainer | chainer-master/chainer/functions/array/split_axis.py | import numpy
import six
import chainer
from chainer import backend
from chainer.backends import intel64
from chainer import function_node
from chainer.utils import collections_abc
from chainer.utils import type_check
import chainerx
_numpy_split_ok = numpy.lib.NumpyVersion(numpy.__version__) >= '1.11.0'
def _fix_n... | 7,645 | 35.409524 | 79 | py |
chainer | chainer-master/chainer/functions/array/transpose_sequence.py | import numpy
from chainer import backend
from chainer.backends import cuda
from chainer import function_node
from chainer.utils import type_check
def _transpose(xs, length):
if length == 0:
return ()
xp = backend.get_array_module(*xs)
lengths = numpy.empty(length, dtype=numpy.int32)
end = le... | 3,591 | 28.68595 | 78 | py |
chainer | chainer-master/chainer/functions/array/pad.py | import numpy
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
class Pad(function_node.FunctionNode):
"""Padding of an array."""
def __init__(self, pad_width, mode, **keywords):
self.mode = mode
self.keywords = keywords
self.pad_width... | 2,221 | 33.71875 | 78 | py |
chainer | chainer-master/chainer/functions/array/resize_images.py | from __future__ import division
import numpy
from chainer import backend
from chainer.backends import cuda
from chainer import function_node
from chainer.utils import type_check
def _infer_lines(B, C, H, W, out_H, out_W, kH, kW):
target_size = 2 ** 17
line_size = B * C * (H * W // out_H + kH * kW * out_W)
... | 10,949 | 31.784431 | 76 | py |
chainer | chainer-master/chainer/functions/activation/softmax.py | import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import function_node
import chainer.functions
from chainer.utils import type_check
if cuda.cudnn_enabled:
cudnn = cuda.cudnn
_algorithm = cuda.libcudnn.CUDNN_SOFTMAX_ACCURATE
class Softmax(function_node.FunctionNode):
... | 3,591 | 29.965517 | 77 | py |
chainer | chainer-master/chainer/functions/activation/rrelu.py | import numpy as np
import chainer
from chainer.backends import cuda
from chainer import function_node
from chainer.utils import argument
from chainer.utils import type_check
def _kern():
return cuda.elementwise(
'T cond, T x, T slope', 'T y',
'y = cond >= 0 ? x : (T)(slope * x)', 'rrelu')
class... | 5,240 | 31.351852 | 78 | py |
chainer | chainer-master/chainer/functions/activation/selu.py | from chainer.functions.activation import elu
def selu(x,
alpha=1.6732632423543772848170429916717,
scale=1.0507009873554804934193349852946):
"""Scaled Exponential Linear Unit function.
For parameters :math:`\\alpha` and :math:`\\lambda`, it is expressed as
.. math::
f(x) = \\lam... | 933 | 29.129032 | 78 | py |
chainer | chainer-master/chainer/functions/activation/softplus.py | import numpy
from chainer.backends import cuda
from chainer import function_node
import chainer.functions
from chainer import utils
from chainer.utils import type_check
class Softplus(function_node.FunctionNode):
"""Softplus function."""
def __init__(self, beta=1.0):
self.beta = float(beta)
... | 3,567 | 28.983193 | 78 | py |
chainer | chainer-master/chainer/functions/activation/log_softmax.py | import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import function_node
import chainer.functions
from chainer.utils import type_check
import chainerx
if cuda.cudnn_enabled:
cudnn = cuda.cudnn
_algorithm = cuda.cuda.cudnn.CUDNN_SOFTMAX_LOG # type: ignore
def logsumexp(x... | 4,633 | 29.688742 | 78 | py |
chainer | chainer-master/chainer/functions/activation/maxout.py | from chainer.functions.array import reshape
from chainer.functions.math import minmax
from chainer.utils import type_check
def maxout(x, pool_size, axis=1):
"""Maxout activation function.
It accepts an input tensor ``x``, reshapes the ``axis`` dimension
(say the size being ``M * pool_size``) into two dim... | 3,309 | 38.879518 | 77 | py |
chainer | chainer-master/chainer/functions/activation/leaky_relu.py | from chainer.backends import cuda
from chainer.backends import intel64
from chainer import function_node
from chainer.utils import type_check
_kern = None
def _get_kern():
global _kern
if _kern is None:
_kern = cuda.elementwise(
'T cond, T x, T slope', 'T y',
'y = cond <= 0 ?... | 3,792 | 25.900709 | 78 | py |
chainer | chainer-master/chainer/functions/activation/hard_sigmoid.py | import numpy
from chainer.backends import cuda
from chainer import function_node
from chainer import utils
from chainer.utils import type_check
class HardSigmoid(function_node.FunctionNode):
"""Hard-sigmoid function."""
def check_type_forward(self, in_types):
type_check._argname(in_types, ('x',))
... | 2,749 | 25.442308 | 78 | py |
chainer | chainer-master/chainer/functions/activation/elu.py | import numpy
from chainer.backends import cuda
from chainer import function_node
from chainer import utils
from chainer.utils import type_check
class ELU(function_node.FunctionNode):
"""Exponential Linear Unit."""
def __init__(self, alpha=1.0):
self.alpha = float(alpha)
def check_type_forward(... | 3,179 | 26.413793 | 78 | py |
chainer | chainer-master/chainer/functions/activation/swish.py | import numpy
import chainer
from chainer.backends import cuda
from chainer import function_node
from chainer import utils
from chainer.utils import type_check
def _get_extended_shape(beta, x):
return (1,) + beta.shape + (1,) * (x.ndim - beta.ndim - 1)
def _get_reduction_axes(beta, x):
return (0,) + tuple(r... | 6,024 | 30.217617 | 79 | py |
chainer | chainer-master/chainer/functions/activation/__init__.py | 0 | 0 | 0 | py | |
chainer | chainer-master/chainer/functions/activation/tanh.py | import numpy
import chainer
from chainer.backends import cuda
from chainer import function_node
from chainer import utils
from chainer.utils import type_check
import chainerx
if cuda.cudnn_enabled:
cudnn = cuda.cudnn
_mode = cuda.libcudnn.CUDNN_ACTIVATION_TANH
class Tanh(function_node.FunctionNode):
""... | 3,299 | 27.205128 | 78 | py |
chainer | chainer-master/chainer/functions/activation/crelu.py | import six
import chainer
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
class CReLU(function_node.FunctionNode):
"""Concatenated Rectified Linear Unit."""
def __init__(self, axis=1):
if not isinstance(axis, six.integer_types):
raise T... | 2,525 | 28.717647 | 79 | py |
chainer | chainer-master/chainer/functions/activation/relu.py | import numpy
import chainer
from chainer.backends import cuda
from chainer.backends import intel64
from chainer import function_node
from chainer import utils
from chainer.utils import type_check
import chainerx
if cuda.available:
_relu_grad2_kernel = cuda.elementwise(
'T y, T gy', 'T gx',
'gx = ... | 4,736 | 27.196429 | 78 | py |
chainer | chainer-master/chainer/functions/activation/prelu.py | import numpy
import chainer
from chainer.backends import cuda
from chainer import function_node
from chainer.utils import type_check
def _fwd_kern():
return cuda.elementwise(
'T x, T cond, T W', 'T y',
'y = cond >= 0 ? x : (T)(x * W)', 'prelu')
def _get_extended_shape(W, x):
return (1,) + W... | 6,332 | 30.984848 | 78 | py |
chainer | chainer-master/chainer/functions/activation/clipped_relu.py | import numpy
import chainer
from chainer.backends import cuda
from chainer import function_node
from chainer import utils
from chainer.utils import type_check
import chainerx
if cuda.cudnn_enabled:
cudnn = cuda.cudnn
_mode = cuda.cuda.cudnn.CUDNN_ACTIVATION_CLIPPED_RELU # type: ignore
class ClippedReLU(fu... | 5,519 | 27.601036 | 78 | py |
chainer | chainer-master/chainer/functions/activation/sigmoid.py | import numpy
import chainer
from chainer.backends import cuda
from chainer import function_node
from chainer import utils
from chainer.utils import type_check
if cuda.cudnn_enabled:
cudnn = cuda.cudnn
_mode = cuda.libcudnn.CUDNN_ACTIVATION_SIGMOID
class Sigmoid(function_node.FunctionNode):
"""Logistic ... | 3,489 | 28.327731 | 78 | py |
chainer | chainer-master/chainer/functions/connection/shift.py | import numpy
from chainer.backends import cuda
from chainer import function_node
from chainer.utils import type_check
def _pair(x):
if hasattr(x, '__getitem__'):
return x
return x, x
class Shift(function_node.FunctionNode):
def __init__(self, ksize=3, dilate=1):
super(Shift, self).__in... | 4,425 | 31.072464 | 77 | py |
chainer | chainer-master/chainer/functions/connection/deformable_convolution_2d_sampler.py | import numpy
from chainer import backend
from chainer.functions.array import broadcast
from chainer.functions.array import concat
from chainer.functions.array import pad as pad_module
from chainer.functions.array import spatial_transformer_sampler
from chainer.functions.math import matmul
def deformable_convolution... | 5,710 | 37.073333 | 79 | py |
chainer | chainer-master/chainer/functions/connection/bilinear.py | import numpy
import chainer
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
def _as_mat(x):
if x.ndim == 2:
return x
return x.reshape(len(x), -1)
def _ij_ik_il_to_jkl(a, b, c):
ab = chainer.functions.matmul(a[:, :, None], b[:, None, :]) # ijk
... | 9,015 | 33.412214 | 79 | py |
chainer | chainer-master/chainer/functions/connection/deconvolution_2d.py | import numpy
import chainer
from chainer.backends import cuda
from chainer.backends import intel64
from chainer import configuration
from chainer import function_node
import chainer.functions
from chainer.functions.connection import convolution_2d
from chainer import memory_layouts
from chainer.utils import argument
f... | 18,105 | 36.255144 | 79 | py |
chainer | chainer-master/chainer/functions/connection/convolution_nd.py | import numpy
from six import moves
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import configuration
from chainer import function_node
from chainer.functions.connection import convolution_2d
from chainer import utils
from chainer.utils import conv
from chainer.utils import ... | 20,150 | 36.247689 | 79 | py |
chainer | chainer-master/chainer/functions/connection/linear.py | import numpy
from chainer import backend
from chainer.backends import intel64
from chainer import function_node
import chainer.functions
from chainer.graph_optimizations import static_code
from chainer import utils
from chainer.utils import type_check
import chainerx
class LinearFunction(function_node.FunctionNode):... | 10,790 | 33.586538 | 75 | py |
chainer | chainer-master/chainer/functions/connection/deconvolution_nd.py | import numpy
from six import moves
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import configuration
from chainer import function_node
from chainer.functions.connection import convolution_2d
from chainer.functions.connection import convolution_nd
from chainer import utils
f... | 16,246 | 35.428251 | 79 | py |
chainer | chainer-master/chainer/functions/connection/depthwise_convolution_2d.py | import chainer
def depthwise_convolution_2d(x, W, b=None, stride=1, pad=0):
"""Two-dimensional depthwise convolution function.
This is an implementation of two-dimensional depthwise convolution.
It takes two or three variables: the input image ``x``, the filter weight
``W``, and optionally, the bias ... | 3,003 | 38.012987 | 79 | py |
chainer | chainer-master/chainer/functions/connection/local_convolution_2d.py | from six import moves
import chainer
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
from chainer import variable
def _pair(x):
if hasattr(x, '__getitem__'):
return x
return x, x
class LocalConvolution2DFunction(function_node.FunctionNode):
de... | 7,212 | 36.373057 | 79 | py |
chainer | chainer-master/chainer/functions/connection/__init__.py | 0 | 0 | 0 | py | |
chainer | chainer-master/chainer/functions/connection/convolution_2d.py | import numpy
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer.backends import intel64
from chainer import configuration
from chainer import function_node
import chainer.functions
from chainer import memory_layouts
from chainer.utils import argument
from chainer.utils import con... | 24,207 | 35.678788 | 79 | py |
chainer | chainer-master/chainer/functions/connection/embed_id.py | import numpy
import six
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import function_node
from chainer import utils
from chainer.utils import type_check
class EmbedIDFunction(function_node.FunctionNode):
def __init__(self, ignore_label=None):
self.ignore_labe... | 5,774 | 33.171598 | 78 | py |
chainer | chainer-master/chainer/functions/connection/dilated_convolution_2d.py | from chainer.functions.connection import convolution_2d
def dilated_convolution_2d(x, W, b=None, stride=1, pad=0, dilate=1,
cover_all=False):
"""Two-dimensional dilated convolution function.
This is an implementation of two-dimensional dilated convolution
in ConvNets.
It ta... | 3,279 | 43.324324 | 79 | py |
chainer | chainer-master/chainer/functions/loss/mean_absolute_error.py | import numpy
import chainer
from chainer import backend
from chainer import function_node
from chainer.utils import type_check
def _get_intermediate_dtype(dtype):
# Returns the dtype for intermediate calculation.
# For float16 input, float32 is used.
# Otherwise the same dtype as the parameter is used.
... | 3,585 | 32.830189 | 76 | py |
chainer | chainer-master/chainer/functions/loss/ctc.py | import numpy
import six
import chainer
from chainer import backend
from chainer.backends import cuda
from chainer import function
from chainer import utils
from chainer.utils import collections_abc
from chainer.utils import type_check
def _logsumexp(a, xp, axis=None):
vmax = xp.amax(a, axis=axis, keepdims=True)
... | 16,314 | 38.21875 | 81 | py |
chainer | chainer-master/chainer/functions/loss/absolute_error.py | from chainer import backend
from chainer import function_node
from chainer import utils
from chainer.utils import type_check
import chainerx
class AbsoluteError(function_node.FunctionNode):
"""Element-wise absolute error function."""
def check_type_forward(self, in_types):
type_check._argname(in_typ... | 1,603 | 26.186441 | 77 | py |
chainer | chainer-master/chainer/functions/loss/sigmoid_cross_entropy.py | import chainer
from chainer import backend
from chainer import function_node
from chainer.functions.activation import sigmoid
from chainer import utils
from chainer.utils import type_check
class SigmoidCrossEntropy(function_node.FunctionNode):
"""Sigmoid activation followed by a sigmoid cross entropy loss."""
... | 6,098 | 33.851429 | 77 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.