code stringlengths 17 6.64M |
|---|
def dtype_bb_to_numpy(dtype):
if (dtype == core.TYPE_FP32):
return np.float32
elif (dtype == core.TYPE_FP64):
return np.float64
elif (dtype == core.TYPE_INT8):
return np.int8
elif (dtype == core.TYPE_INT16):
return np.int16
elif (dtype == core.TYPE_INT32):
return np.int32
elif (dtype == core.TYPE_INT64):
return np.int64
elif (dtype == core.TYPE_UINT8):
return np.uint8
elif (dtype == core.TYPE_UINT16):
return np.uint16
elif (dtype == core.TYPE_UINT32):
return np.uint32
elif (dtype == core.TYPE_UINT64):
return np.uint64
return None
|
def dtype_to_name(dtype):
if (dtype == core.TYPE_BIT):
return 'bit'
elif (dtype == core.TYPE_FP32):
return 'fp32'
elif (dtype == core.TYPE_FP64):
return 'fp64'
elif (dtype == core.TYPE_INT8):
return 'int8'
elif (dtype == core.TYPE_INT16):
return 'int16'
elif (dtype == core.TYPE_INT32):
return 'int32'
elif (dtype == core.TYPE_INT64):
return 'int64'
elif (dtype == core.TYPE_UINT8):
return 'uint8'
elif (dtype == core.TYPE_UINT16):
return 'uint16'
elif (dtype == core.TYPE_UINT32):
return 'uint32'
elif (dtype == core.TYPE_UINT64):
return 'uint64'
return None
|
def dtype_from_name(name):
if (name == 'bit'):
return core.TYPE_BIT
elif (name == 'fp32'):
return core.TYPE_FP32
elif (name == 'fp64'):
return core.TYPE_FP64
elif (name == 'int8'):
return core.TYPE_INT8
elif (name == 'int16'):
return core.TYPE_INT16
elif (name == 'int32'):
return core.TYPE_INT32
elif (name == 'int64'):
return core.TYPE_INT64
elif (name == 'uint8'):
return core.TYPE_UINT8
elif (name == 'uint16'):
return core.TYPE_UINT16
elif (name == 'uint32'):
return core.TYPE_UINT32
elif (name == 'uint64'):
return core.TYPE_UINT64
return None
|
class FrameBuffer(bb.Object):
'FrameBuffer class\n \n BinaryBrainでの学習データを格納する特別な型である\n バッチと対応する 1次元のframe項と、各レイヤーの入出力ノードに対応する\n 多次元のnode項を有している\n numpy の ndarray に変換する際は axis=0 が frame 項となり、以降が\n node項となる\n\n Tensor と異なり、frame 項に対して reshape を行うことはできず、\n node 項に対しても transpose することはできない。\n\n node に関しては 2次元以上の shape も持ちうるが、実際のレイヤー間接続に\n 際しては、畳み込みなどの次元に意味を持つノード以外では、ノード数さえ\n あっていれば接続できるものが殆どである(多くの処理系で必要とする\n flatten が省略できる)。\n\n host_only フラグを指定すると device(GPU側) が利用可能であっても\n host(CPU側) のみにメモリを確保する\n\n Args:\n frame_size (int): frame サイズ\n shape (list[int]): node シェイプ\n dtype (int): Data type\n host_only (bool): flag of host only\n '
def __init__(self, frame_size: int=0, shape: List[int]=[], dtype=bb.DType.FP32, host_only: bool=False, core_buf=None):
if (core_buf is None):
core_buf = core.FrameBuffer(frame_size, shape, dtype.value, host_only)
super(FrameBuffer, self).__init__(core_object=core_buf)
@staticmethod
def zeros(frame_size: int=0, node_shape: List[int]=[], dtype=bb.DType.FP32, host_only: bool=False):
buf = FrameBuffer(frame_size=frame_size, shape=node_shape, dtype=dtype, host_only=host_only)
buf.fill_zero()
return buf
@staticmethod
def zeros_like(buf, *, frame_size: int=None, node_shape: List[int]=None, dtype=None, host_only: bool=None):
if (frame_size is None):
frame_size = buf.get_frame_size()
if (node_shape is None):
node_shape = buf.get_node_shape()
if (dtype is None):
dtype = buf.get_type()
if (host_only is None):
host_only = buf.is_host_only()
return FrameBuffer.zeros(frame_size=frame_size, node_shape=node_shape, dtype=dtype, host_only=host_only)
@staticmethod
def from_core(core_buf):
return FrameBuffer(core_buf=core_buf)
def is_host_only(self) -> bool:
return self.get_core().is_host_only()
def astype(self, dtype):
return FrameBuffer(core_buf=self.get_core().astype(dtype))
def get_type(self) -> int:
'データ型取得\n \n Returns:\n dtype (DType)\n '
return bb.DType(self.get_core().get_type())
def get_frame_size(self) -> int:
'get size of frame.\n \n Returns:\n frame size.\n '
return self.get_core().get_frame_size()
def get_frame_stride(self) -> int:
'get stride of frame.\n \n Returns:\n frame stride.\n '
return self.get_core().get_frame_stride()
def get_node_size(self) -> int:
'get size of node.\n \n Returns:\n node size.\n '
return self.get_core().get_node_size()
def get_node_shape(self) -> List[int]:
'get shape of node.\n \n Returns:\n shape\n '
return self.get_core().get_node_shape()
def numpy(self) -> np.ndarray:
'Convert to NumPy\n \n Args:\n shape (list[int]): Shape of created array\n dtype (int): Data type\n host_only (bool): flag of host only\n '
dtype = self.get_type()
if (dtype == bb.DType.BIT):
ndarray = self.get_core().numpy_uint8()
elif (dtype == bb.DType.BINARY):
ndarray = self.get_core().numpy_uint8()
elif (dtype == bb.DType.FP32):
ndarray = self.get_core().numpy_fp32()
elif (dtype == bb.DType.FP64):
ndarray = self.get_core().numpy_fp64()
elif (dtype == bb.DType.INT8):
ndarray = self.get_core().numpy_int8()
elif (dtype == bb.DType.INT16):
ndarray = self.get_core().numpy_int16()
elif (dtype == bb.DType.INT32):
ndarray = self.get_core().numpy_int32()
elif (dtype == bb.DType.INT64):
ndarray = self.get_core().numpy_int64()
elif (dtype == bb.DType.UINT8):
ndarray = self.get_core().numpy_uint8()
elif (dtype == bb.DType.UINT16):
ndarray = self.get_core().numpy_uint16()
elif (dtype == bb.DType.UINT32):
ndarray = self.get_core().numpy_uint32()
elif (dtype == bb.DType.UINT64):
ndarray = self.get_core().numpy_uint64()
else:
raise TypeError('unexpected dtype')
tran = ([(ndarray.ndim - 1)] + list(range(0, (ndarray.ndim - 1))))
ndarray = ndarray.transpose(tran)
if (dtype != bb.DType.BIT):
shape = list(ndarray.shape)
shape[0] = self.get_core().get_frame_size()
ndarray = np.resize(ndarray, shape)
return ndarray
@staticmethod
def from_numpy(ndarray: np.ndarray, host_only=False):
'Create from NumPy\n \n Args:\n ndarray (np.ndarray): array of NumPy\n host_only (bool): flag of host only\n '
shape = list(ndarray.shape)
assert (len(shape) >= 2)
bb_dtype = bb.dtype_numpy_to_bb(ndarray.dtype)
frame_size = shape[0]
frame_stride = core.FrameBuffer.calc_frame_stride(bb_dtype, frame_size)
shape[0] = (frame_stride // core.dtype_get_byte_size(bb_dtype))
ndarray = np.resize(ndarray, shape)
tran = (list(range(1, ndarray.ndim)) + [0])
ndarray = ndarray.transpose(tran)
ndarray = ndarray.copy(order='C')
if (ndarray.dtype == np.float32):
core_buf = bb.core.FrameBuffer.from_numpy_fp32(ndarray, bb_dtype, frame_size, frame_stride, shape[1:], host_only)
elif (ndarray.dtype == np.float64):
core_buf = bb.core.FrameBuffer.from_numpy_fp64(ndarray, bb_dtype, frame_size, frame_stride, shape[1:], host_only)
elif (ndarray.dtype == np.int8):
core_buf = bb.core.FrameBuffer.from_numpy_int8(ndarray, bb_dtype, frame_size, frame_stride, shape[1:], host_only)
elif (ndarray.dtype == np.int16):
core_buf = bb.core.FrameBuffer.from_numpy_int16(ndarray, bb_dtype, frame_size, frame_stride, shape[1:], host_only)
elif (ndarray.dtype == np.int32):
core_buf = bb.core.FrameBuffer.from_numpy_int32(ndarray, bb_dtype, frame_size, frame_stride, shape[1:], host_only)
elif (ndarray.dtype == np.int64):
core_buf = bb.core.FrameBuffer.from_numpy_int64(ndarray, bb_dtype, frame_size, frame_stride, shape[1:], host_only)
elif (ndarray.dtype == np.uint8):
core_buf = bb.core.FrameBuffer.from_numpy_uint8(ndarray, bb_dtype, frame_size, frame_stride, shape[1:], host_only)
elif (ndarray.dtype == np.uint16):
core_buf = bb.core.FrameBuffer.from_numpy_uint16(ndarray, bb_dtype, frame_size, frame_stride, shape[1:], host_only)
elif (ndarray.dtype == np.uint32):
core_buf = bb.core.FrameBuffer.from_numpy_uint32(ndarray, bb_dtype, frame_size, frame_stride, shape[1:], host_only)
elif (ndarray.dtype == np.uint64):
core_buf = bb.core.FrameBuffer.from_numpy_uint64(ndarray, bb_dtype, frame_size, frame_stride, shape[1:], host_only)
else:
core_buf = None
raise TypeError('unsupported')
return FrameBuffer(core_buf=core_buf)
def fill_zero(self):
self.get_core().fill_zero()
def fill(self, x):
self.get_core().fill(x)
def isnan(self):
return self.get_core().isnan()
def min(self):
return self.get_core().min()
def max(self):
return self.get_core().max()
def quantize(self, bits, scale=0.0, offset=0):
return self.get_core().quantize(bits, scale, offset)
def __add__(self, x):
if (type(x) == FrameBuffer):
core_buf = (self.get_core() + x.get_core())
else:
core_buf = (self.get_core() + float(x))
return FrameBuffer(core_buf=core_buf)
def __sub__(self, x):
if (type(x) == FrameBuffer):
core_buf = (self.get_core() - x.get_core())
else:
core_buf = (self.get_core() - float(x))
return FrameBuffer(core_buf=core_buf)
def __mul__(self, x):
if (type(x) == FrameBuffer):
core_buf = (self.get_core() * x.get_core())
else:
core_buf = (self.get_core() * float(x))
return FrameBuffer(core_buf=core_buf)
def __truediv__(self, x):
if (type(x) == FrameBuffer):
core_buf = (self.get_core() / x.get_core())
else:
core_buf = (self.get_core() / float(x))
return FrameBuffer(core_buf=core_buf)
def __radd__(self, x):
if (type(x) == FrameBuffer):
core_buf = (x.get_core() + self.get_core())
else:
core_buf = (float(x) + self.get_core())
return FrameBuffer(core_buf=core_buf)
def __rsub__(self, x):
if (type(x) == FrameBuffer):
core_buf = (x.get_core() - self.get_core())
else:
core_buf = (float(x) - self.get_core())
return FrameBuffer(core_buf=core_buf)
def __rmul__(self, x):
if (type(x) == FrameBuffer):
core_buf = (x.get_core() * self.get_core())
else:
core_buf = (float(x) * self.get_core())
return FrameBuffer(core_buf=core_buf)
def __rtruediv__(self, x):
if (type(x) == FrameBuffer):
core_buf = (x.get_core() / self.get_core())
else:
core_buf = (float(x) / self.get_core())
return FrameBuffer(core_buf=core_buf)
def __iadd__(self, x):
core_buf = self.get_core()
if (type(x) == FrameBuffer):
core_buf += x.get_core()
else:
core_buf += float(x)
return self
def __isub__(self, x):
core_buf = self.get_core()
if (type(x) == FrameBuffer):
core_buf -= x.get_core()
else:
core_buf -= float(x)
return self
def __imul__(self, x):
core_buf = self.get_core()
if (type(x) == FrameBuffer):
core_buf *= x.get_core()
else:
core_buf *= float(x)
return self
def __itruediv__(self, x):
core_buf = self.get_core()
if (type(x) == FrameBuffer):
core_buf /= x.get_core()
else:
core_buf /= float(x)
return self
@classmethod
def from_bytes(cls, data):
new_buffer = cls()
data = new_buffer.loads(data)
return (data, new_buffer)
|
def framebuffer_creator(data, name, dtypes):
if (name == 'FrameBuffer'):
return FrameBuffer.from_bytes(data)
return (data, None)
|
def make_lut_func_name(name, node):
return ('%s_lut_%d' % (name, node))
|
def dump_hls_lut_node(f, name, lut, node):
f.write(('\ninline ap_uint<1> %s(\n' % make_lut_func_name(name, node)))
n = lut.get_node_connection_size(node)
s = lut.get_lut_table_size(node)
for i in range(n):
f.write((' ap_uint<1> in_data%d' % i))
if (i < (n - 1)):
f.write(',\n')
else:
f.write(')\n')
f.write('{\n')
f.write(' #pragma HLS inline\n\n')
f.write((' ap_uint<%d> index;\n' % n))
for i in range(n):
f.write((' index[%d] = in_data%d;\n' % (i, i)))
f.write(' \n')
f.write((' const ap_uint<1> table[%d] = {' % s))
for i in range(s):
f.write(('%d,' % lut.get_lut_table(node, i)))
f.write('};\n')
f.write(' #pragma HLS bind_storage variable=table type=ROM_1P impl=LUTRAM\n')
f.write(' return table[index];\n')
f.write('}\n\n')
|
def dump_hls_lut_layer(f, name, lut):
' dump HLS source of LUT layer\n \n Args:\n f (StreamIO) : 出力先ストリーム\n name (str): 関数名\n lut (Model): 変換するネット\n '
ins = lut.get_input_node_size()
outs = lut.get_output_node_size()
for node in range(outs):
dump_hls_lut_node(f, name, lut, node)
f.write('\n')
f.write(('inline ap_uint<%d> %s(ap_uint<%d> in_data)\n' % (outs, name, ins)))
f.write('{\n')
f.write((' ap_uint<%d> out_data;\n' % outs))
for node in range(outs):
f.write((' out_data[%d] = %s(' % (node, make_lut_func_name(name, node))))
n = lut.get_node_connection_size(node)
for i in range(n):
f.write(('in_data[%d]' % lut.get_node_connection_index(node, i)))
if (i < (n - 1)):
f.write(',')
else:
f.write(');\n')
f.write(' return out_data;\n')
f.write('}\n\n')
|
def make_hls_lut_layer(name, lut):
' make HLS source of LUT layer\n \n Args:\n name (str): 関数名\n lut (Model): 変換するネット\n \n Returns:\n HLS source code (str)\n '
with io.StringIO() as f:
dump_hls_lut_layer(f, name, lut)
return f.getvalue()
|
class LossFunction(bb.Object):
'LossFunction class\n 損失関数の基底クラス\n '
def __init__(self, core_loss=None):
super(LossFunction, self).__init__(core_object=core_loss)
def clear(self):
'値のクリア\n\n 集計をクリアする。通常 epoch の単位でクリアして再集計を行う\n '
self.get_core().clear()
def get(self):
'値の取得\n\n Returns:\n loss(float) : 現在までの損失値を返す\n '
return self.get_core().get_loss()
def calculate(self, y_buf, t_buf, mini_batch_size=None):
'損失の計算\n\n mini_batch_size はメモリなどの都合でミニバッチをさらに分割する場合などに用いる。通常はNoneでよい。\n\n Args:\n y_buf (FrameBuffer): forward演算結果\n t_buf (FrameBuffer): 教師データ\n mini_batch_size (int): ミニバッチサイズ\n\n Returns:\n dy_buf (FrameBuffer) : 逆伝搬させる誤差を返す\n '
if (mini_batch_size is None):
mini_batch_size = t_buf.get_frame_size()
return bb.FrameBuffer.from_core(self.get_core().calculate_loss(y_buf.get_core(), t_buf.get_core(), mini_batch_size))
|
class LossMeanSquaredError(LossFunction):
'LossMeanSquaredError class\n\n 平均二乗誤差(MSE)を計算して誤差として戻す\n '
def __init__(self, reduction='mean', dtype=bb.DType.FP32):
core_loss = bb.search_core_object('LossMeanSquaredError', [dtype]).create(reduction=reduction)
super(LossMeanSquaredError, self).__init__(core_loss=core_loss)
|
class LossCrossEntropy(LossFunction):
'LossCrossEntropy class\n\n 交差エントロピー誤差を戻す\n '
def __init__(self, dtype=bb.DType.FP32):
core_loss = bb.search_core_object('LossCrossEntropy', [dtype]).create()
super(LossCrossEntropy, self).__init__(core_loss=core_loss)
|
class LossBinaryCrossEntropy(LossFunction):
'LossBinaryCrossEntropy class\n \n 2値の交差エントロピー誤差を戻す\n '
def __init__(self, dtype=bb.DType.FP32):
core_loss = bb.search_core_object('LossBinaryCrossEntropy', [dtype]).create()
super(LossBinaryCrossEntropy, self).__init__(core_loss=core_loss)
|
class LossSoftmaxCrossEntropy(LossFunction):
'LossSoftmaxCrossEntropy class\n\n Softmax(活性化) と CrossEntropy(損失関数) の複合\n 両者を統合すると計算が簡略化される。\n \n 利用に際しては最終段に Softmax が挿入されたのと等価になるので注意すること。\n '
def __init__(self, dtype=bb.DType.FP32):
core_loss = bb.search_core_object('LossSoftmaxCrossEntropy', [dtype]).create()
super(LossSoftmaxCrossEntropy, self).__init__(core_loss=core_loss)
|
class LossSigmoidCrossEntropy(LossFunction):
'LossSigmoidCrossEntropy class\n\n Sigmoid(活性化) と BinaryCrossEntropy(損失関数) の複合\n 両者を統合すると計算が簡略化される。\n \n 利用に際しては最終段に Sigmoid が挿入されたのと等価になるので注意すること。\n '
def __init__(self, dtype=bb.DType.FP32):
core_loss = bb.search_core_object('LossSigmoidCrossEntropy', [dtype]).create()
super(LossSigmoidCrossEntropy, self).__init__(core_loss=core_loss)
|
class Metrics(bb.Object):
'Metrics class\n 評価関数の基底クラス\n '
def __init__(self, core_metrics=None):
super(Metrics, self).__init__(core_object=core_metrics)
def clear(self):
'値のクリア\n\n 集計をクリアする。通常 epoch の単位でクリアして再集計を行う\n '
self.get_core().clear()
def get(self):
'値の取得\n\n Returns:\n metrics(float) : 現在までの損失値を返す\n '
return self.get_core().get_metrics()
def calculate(self, y_buf, t_buf):
'評価の計算\n\n Args:\n y_buf (FrameBuffer): forward演算結果\n t_buf (FrameBuffer): 教師データ\n '
return self.get_core().calculate_metrics(y_buf.get_core(), t_buf.get_core())
def get_metrics_string(self):
'評価対象の文字列取得\n\n 評価関数ごとに評価値の単位が異なるため計算しているものの文字列を返す\n 平均二乗誤差(MSE)であったり、認識率(accuracy)であったり\n getで得られる値を、表示やログで表す際に利用できる\n\n Args:\n metrics_string (str): 評価対象の文字列取得\n '
return self.get_core().get_metrics_string()
|
class MetricsMeanSquaredError(Metrics):
'MetricsMeanSquaredError class\n\n 平均二乗誤差の評価関数\n 教師信号との平均二乗誤差を計算する\n '
def __init__(self, dtype=bb.DType.FP32):
core_metrics = bb.search_core_object('MetricsMeanSquaredError', [dtype]).create()
super(MetricsMeanSquaredError, self).__init__(core_metrics=core_metrics)
|
class MetricsCategoricalAccuracy(Metrics):
'MetricsCategoricalAccuracy class\n\n 多クラス分類用の評価関数\n 一致率を accuracy として計算する\n '
def __init__(self, dtype=bb.DType.FP32):
core_metrics = bb.search_core_object('MetricsCategoricalAccuracy', [dtype]).create()
super(MetricsCategoricalAccuracy, self).__init__(core_metrics=core_metrics)
|
class MetricsBinaryCategoricalAccuracy(Metrics):
'MetricsBinaryCategoricalAccuracy class\n\n 2クラス分類用の評価関数\n 一致率を accuracy として計算する\n '
def __init__(self, dtype=bb.DType.FP32):
core_metrics = bb.search_core_object('MetricsBinaryCategoricalAccuracy', [dtype]).create()
super(MetricsBinaryCategoricalAccuracy, self).__init__(core_metrics=core_metrics)
|
def search_core_model(model_name, dtypes=None):
if (dtypes is None):
dtypes = []
return bb.search_core_object(model_name, dtypes)
|
def model_creator_regist(model_name, creator):
_model_creator_list[model_name] = creator
|
def model_creator(data, name, dtypes):
if (name in _model_creator_list):
return _model_creator_list[name](data)
return (data, None)
|
class Model(bb.Object):
'Model class\n ネットワーク各層の演算モデルの基底クラス\n すべてのモデルはこのクラスを基本クラスに持つ\n\n BinaryBrain では、モデルを実際にインスタンスとして生成して組み合わせることで\n 学習ネットワークを構成する。特にネットワーク内のインスタンス化された\n モデルをレイヤーという呼び方をする場合がある。\n '
def __init__(self, *, core_model=None, input_shape=None, name=None):
super(Model, self).__init__(core_object=core_model)
self.input_shape = input_shape
self.name = name
if (core_model is not None):
if (name is not None):
self.set_name(name)
if (input_shape is not None):
self.set_input_shape(input_shape)
@classmethod
def from_bytes(cls, data):
(data, core_model) = bb.core_object_loads(data)
return (data, cls(core_model=core_model))
def set_name(self, name: str):
'インスタンス名の設定\n\n 生成したモデルには任意の名前を付けることが可能であり、表示や\n 保存時のファイル名などに利用することが可能である\n\n Args:\n name (str): 新しいインスタンス名\n '
self.name = name
core_model = self.get_core()
if (core_model is not None):
core_model.set_name(name)
def get_name(self):
'インスタンス名の取得\n\n インスタンス名を取得する。名称が設定されていない場合はクラス名が返される\n\n Returns:\n name (str)\n '
core_model = self.get_core()
if (core_model is not None):
return core_model.get_name()
elif self.name:
return self.name
else:
return self.get_model_name()
def is_named(self):
'インスタンス名の設定確認\n\n インスタンス名が設定されているかどうか確認する\n\n Returns:\n named (bool)\n '
core_model = self.get_core()
if (core_model is not None):
return core_model.is_named()
else:
return (self.name is not None)
def get_model_name(self):
'モデル名の取得\n\n モデル名を取得する。\n\n Returns:\n model name (str)\n '
core_model = self.get_core()
if (core_model is not None):
return core_model.get_model_name()
else:
return self.__class__.__name__
def get_info(self, depth: int=0, *, columns: int=70, nest: int=0) -> str:
'モデル情報取得\n\n モデルの情報表示用の文字列を取得する\n そのまま表示やログに利用することを想定している\n\n Returns:\n info (str)\n '
core_model = self.get_core()
if (core_model is not None):
return core_model.get_info(depth, columns, nest)
indent = (' ' * (nest * 2))
separetor = ('-' * (columns - len(indent)))
name = self.name
if (name is None):
name = ''
text = ((indent + separetor) + '\n')
text += (((((indent + '[') + self.get_model_name()) + '] ') + name) + '\n')
text += ((indent + ' input shape : ') + str(self.get_input_shape()))
text += (((indent + ' output shape : ') + str(self.get_output_shape())) + '\n')
if (nest == 0):
text += ((indent + separetor) + '\n')
return text
def print_info(self, depth: int=0):
'モデル情報表示\n\n モデルの情報を表示する\n '
print(self.get_info(depth=depth))
def send_command(self, command, send_to='all'):
"コマンドの送信\n\n モデルごとにコマンド文字列で設定を行う\n コマンド文字列の定義はモデルごとに自由である\n Sequentialクラスなどは、保有する下位のモデルに再帰的にコマンドを\n 伝搬させるので、複数の層に一括した設定が可能である\n 受取先は send_to で送り先はインスタンス名やクラス名で制限でき 'all' を指定すると\n フィルタリングされない\n\n Args:\n command (str): コマンド文字列\n send_to (str): 送信先\n "
core_model = self.get_core()
if (core_model is not None):
self.get_core().send_command(command, send_to)
def set_input_shape(self, input_shape):
'入力シェイプ設定\n\n BinaryBarainではモデル生成時に入力のシェイプを決定する必要はなく\n ネットワーク構築後に、ネットワークを構成する各モデルの\n set_input_shape を順に呼び出して形状を伝搬させることで\n 各モデルの形状の設定を簡易化できる\n\n set_input_shape が呼ばれるとそれまでの各層で保有する情報は\n 保証されない。ネットワーク構築後に一度だけ呼び出すことを想定している\n \n Args:\n input_shape (List[int]): 入力シェイプ\n\n Returns:\n output_shape (List[int]): 出力シェイプ\n '
if ((type(input_shape) == list) and (len(input_shape) > 0) and (type(input_shape[0]) == list)):
output_shapes = self.set_input_shape_multi(input_shape)
if (len(output_shapes) == 1):
return output_shapes[0]
return output_shapes
self.input_shape = input_shape
core_model = self.get_core()
if (core_model is not None):
output_shape = self.get_core().set_input_shape(input_shape)
return output_shape
return self.input_shape
def set_input_shape_multi(self, input_shapes: List[List[int]]):
self.input_shape = input_shapes
core_model = self.get_core()
if (core_model is not None):
output_shapes = self.get_core().set_input_shape_multi(input_shapes)
return output_shapes
return self.input_shape
def get_input_shape(self) -> List[int]:
'入力シェイプ取得\n\n Returns:\n input_shape (List[int]): 入力シェイプ\n '
core_model = self.get_core()
if (core_model is not None):
return core_model.get_input_shape()
return self.input_shape
def get_output_shape(self) -> List[int]:
'出力シェイプ取得\n\n Returns:\n output_shape (List[int]): 出力シェイプ\n '
core_model = self.get_core()
if (core_model is not None):
return core_model.get_output_shape()
return self.input_shape
def get_input_node_size(self) -> int:
core_model = self.get_core()
if (core_model is not None):
return core_model.get_input_node_size()
shape = self.get_input_shape()
size = 1
for s in shape:
size *= s
return size
def get_output_node_size(self) -> int:
core_model = self.get_core()
if (core_model is not None):
return core_model.get_output_node_size()
return self.get_input_node_size()
def get_parameters(self):
'パラメータ変数取得\n\n 学習対象とするパラメータ群を Variables として返す\n 主に最適化(Optimizer)に渡すことを目的としている\n\n モデル側を自作する際には、このメソッドで戻す変数の中に\n 含めなかったパラメータは学習対象から外すことができる為\n パラメータを凍結したい場合などに利用できる\n\n Returns:\n parameters (Variables): パラメータ変数\n '
core_model = self.get_core()
if (core_model is not None):
return bb.Variables.from_core(core_model.get_parameters())
return bb.Variables()
def get_gradients(self):
'勾配変数取得\n\n get_parameters と対になる勾配変数を Variables として返す\n 主に最適化(Optimizer)に渡すことを目的としている\n\n Returns:\n gradients (Variables): 勾配変数\n '
core_model = self.get_core()
if (core_model is not None):
return bb.Variables.from_core(core_model.get_gradients())
return bb.Variables()
def forward(self, x_buf, train=True):
'Forward\n\n モデルは学習および推論の為に forward メソッドを持つ\n train 変数を\n \n Args:\n x_buf (FrameBuffer): 入力データ\n train (bool) : Trueで学習、Falseで推論\n\n Returns:\n y_buf (FrameBuffer): 出力データ\n '
if (type(x_buf) == list):
y_bufs = self.forward_multi(x_buf)
if (len(y_bufs) == 1):
return y_bufs[0]
return y_bufs
core_model = self.get_core()
if (core_model is not None):
return bb.FrameBuffer.from_core(core_model.forward(x_buf.get_core(), train))
return x_buf
def forward_multi(self, x_bufs, train=True):
core_model = self.get_core()
if (core_model is not None):
core_x_bufs = []
for x_buf in x_bufs:
core_x_bufs.append(x_buf.get_core())
core_y_bufs = core_model.forward_multi(core_x_bufs, train)
y_bufs = []
for core_y_buf in core_y_bufs:
y_bufs.append(bb.FrameBuffer.from_core(core_y_buf))
return y_bufs
return x_bufs
def backward(self, dy_buf):
'Backward\n\n モデルは学習の為に backword メソッドを持つ\n 必ず forwad と対で呼び出す必要があり、直前の forward 結果に対する\n 勾配計算を行いながら逆伝搬する\n\n BinaryBrain は自動微分の機能を備えないので、backword の実装は必須である\n \n Args:\n dy_buf (FrameBuffer): 入力データ\n\n Returns:\n dx_buf (FrameBuffer): 出力データ\n '
if (type(dy_buf) == list):
dx_bufs = self.backward_multi(dy_buf)
if (len(dx_bufs) == 1):
return dx_bufs[0]
return dx_bufs
core_model = self.get_core()
if (core_model is not None):
return bb.FrameBuffer.from_core(core_model.backward(dy_buf.get_core()))
return dy_buf
def backward_multi(self, dy_bufs):
core_model = self.get_core()
if (core_model is None):
return dy_bufs
if (type(dy_bufs) != list):
dy_bufs = [dy_bufs]
core_dy_bufs = []
for dy_buf in dy_bufs:
core_dy_bufs.append(dy_buf.get_core())
core_dx_bufs = core_model.backward_multi(core_dy_bufs)
dx_bufs = []
for core_dx_buf in core_dx_bufs:
dx_bufs.append(bb.FrameBuffer.from_core(core_dx_buf))
return dx_bufs
def clear(self):
core_model = self.get_core()
if (core_model is not None):
core_model.clear()
def push(self, x):
core_model = self.get_core()
if (core_model is not None):
core_model.push(x.get_core())
def pop(self):
core_model = self.get_core()
if (core_model is not None):
return bb.FrameBuffer.from_core(core_model.pop())
def top(self):
core_model = self.get_core()
if (core_model is not None):
return bb.FrameBuffer.from_core(core_model.top())
def dump_bytes(self):
core_model = self.get_core()
if (core_model is not None):
return core_model.dump()
return b''
def load_bytes(self, data):
core_model = self.get_core()
if (core_model is not None):
size = core_model.load(data)
return data[size:]
return data
def __str__(self):
return self.get_info(1)
def __repr__(self):
return self.get_info(1)
|
class Sequential(Model):
'Sequential class\n 複数レイヤーを直列に接続してグルーピングするクラス\n\n リストの順番で set_input_shape, forward, backward などを実行する\n また send_command の子レイヤーへのブロードキャストや、\n get_parameters, get_gradients の統合を行うことで複数のレイヤーを\n １つのレイヤーとして操作できる\n\n Args:\n model_list (List[Model]): モデルのリスト\n '
def __init__(self, model_list=None, *, input_shape=None, name=None):
if (model_list is None):
model_list = []
self.name = ''
self.model_list = model_list
super(Sequential, self).__init__(input_shape=input_shape, name=name)
def get_core(self):
core_model = core.Sequential.create()
for model in self.model_list:
core_model.add(model.get_core())
if (self.name is not None):
core_model.set_name(self.name)
return core_model
def set_name(self, name):
self.name = name
def get_name(self):
if ((self.name is None) or (len(self.name) == 0)):
return self.get_model_name()
return self.name
def is_named(self):
if (self.name is None):
return False
if (len(self.name) == 0):
return False
return True
def set_model_list(self, model_list):
'モデルリストの設定\n \n Args:\n model_list (List[Model]): モデルのリスト\n '
self.model_list = model_list
def get_model_list(self):
'モデルリストの取得\n \n Returns:\n model_list (List[Model]): モデルのリスト\n '
return self.model_list
def get_input_shape(self):
return self.model_list[0].get_input_shape()
def get_output_shape(self):
return self.model_list[(- 1)].get_output_shape()
def __len__(self):
return len(self.model_list)
def __iter__(self):
return self.model_list.__iter__()
def __getitem__(self, item):
return self.model_list[item]
def __setitem__(self, item, model):
self.model_list[item] = model
def append(self, model):
'リストへのモデル追加\n \n Args:\n model (Model): リストに追加するモデル\n '
self.model_list.append(model)
def remove(self, model):
'リストへからモデル削除\n \n Args:\n model (Model): リストから削除するモデル\n '
self.model_list.remove(model)
def get_info(self, depth=0, *, columns=70, nest=0):
if ((depth > 0) and ((nest + 1) >= depth)):
return super(Sequential, self).get_info(depth=depth, columns=columns, nest=nest)
else:
indent = (' ' * (nest * 2))
separetor = ('-' * (columns - len(indent)))
name = self.name
if (name is None):
name = ''
text = ((indent + separetor) + '\n')
text += (((((indent + '[') + self.get_model_name()) + '] ') + name) + '\n')
text += ((indent + ' input shape : ') + str(self.get_input_shape()))
text += (((indent + ' output shape : ') + str(self.get_output_shape())) + '\n')
for model in self.model_list:
text += model.get_info(depth=depth, columns=columns, nest=(nest + 1))
if (nest == 0):
text += ((indent + separetor) + '\n')
return text
def send_command(self, command, send_to='all'):
for model in self.model_list:
model.send_command(command=command, send_to=send_to)
def set_input_shape(self, shape):
self.input_shape = shape
for model in self.model_list:
shape = model.set_input_shape(shape)
return shape
def get_parameters(self):
variables = bb.Variables()
for model in self.model_list:
variables.append(model.get_parameters())
return variables
def get_gradients(self):
variables = bb.Variables()
for model in self.model_list:
variables.append(model.get_gradients())
return variables
def forward(self, x_buf, train=True):
for model in self.model_list:
x_buf = model.forward(x_buf, train)
return x_buf
def backward(self, dy_buf):
for model in reversed(self.model_list):
dy_buf = model.backward(dy_buf)
return dy_buf
def clear(self):
for model in self.model_list:
model.clear()
def dumps(self):
data = bb.dump_object_header('Sequential')
ver = 2
data += bb.int_to_bytes(ver)
name = self.name
if (name is None):
name = ''
data += bb.string_to_bytes(name)
layer_size = len(self.model_list)
data += bb.int_to_bytes(layer_size)
for model in self.model_list:
data += model.dumps()
return data
def loads(self, data):
(data, name) = bb.load_object_header(data)
assert (name == 'Sequential')
(data, ver) = bb.int_from_bytes(data)
assert ((ver == 1) or (ver == 2))
if (ver == 2):
(data, name) = bb.string_from_bytes(data)
if (not self.is_named()):
self.name = name
(data, layer_size) = bb.int_from_bytes(data)
if (self.model_list is not None):
assert (layer_size == len(self.model_list))
for model in self.model_list:
data = model.loads(data)
else:
self.model_list = []
for _ in range(layer_size):
(data, model) = bb.object_loads(data)
self.model_list.append(model)
return data
@classmethod
def from_bytes(cls, data):
new_model = cls()
new_model.model_list = None
data = new_model.loads(data)
return (data, new_model)
|
class Switcher(Model):
"モデル切り替え用基底クラス\n \n 主に蒸留や転移学習などでレイヤー差し替えに用いる\n send_command から 'switch_model [name]' でも切り替え可能\n\n Args:\n model_dict (Dict{str: Model}): 切り替えるモデルの辞書\n init_model_name (str): 初期選択するモデルの名前\n "
def __init__(self, model_dict=None, init_model_name=None, *, input_shape=None, name=None):
if (model_dict is None):
model_dict = {}
self.model_dict = model_dict
self.current_model_name = None
self.current_model = None
super(Switcher, self).__init__(input_shape=input_shape, name=name)
self.switch_model(init_model_name)
def switch_model(self, model_name: str):
'モデルを切り替える\n \n Args:\n model_dict (Dict{str: Model}): 切り替えるモデルの辞書\n '
if ((self.model_dict is not None) and (model_name is not None)):
if (model_name in self.model_dict):
self.current_model_name = model_name
self.current_model = self.model_dict[model_name]
def __getitem__(self, key):
return self.model_dict[key]
def __setitem__(self, key, value):
self.model_dict[key] = value
def get_model_list(self):
return self.model_dict.values()
def get_current_model(self):
return self.current_model
def get_current_model_name(self):
return self.current_model_name
def get_core(self):
current_model = self.get_current_model()
if (current_model is not None):
return current_model.get_core()
return None
def get_info(self, depth: int=0, *, columns: int=70, nest: int=0) -> str:
current_model = self.get_current_model()
if (current_model is not None):
return current_model.get_info(depth=depth, columns=columns, nest=nest)
return ''
def send_command(self, command, send_to='all'):
if ((send_to == 'all') or (send_to == self.get_name()) or (send_to == self.get_model_name())):
args = command.split()
if ((len(args) == 2) and (args[0] == 'switch_model')):
self.switch_model(args[1])
current_model = self.get_current_model()
if (current_model is not None):
return current_model.send_command(command=command, send_to=send_to)
def set_input_shape(self, input_shape: List[int]):
output_shape = None
for name in self.model_dict:
shape = self.model_dict[name].set_input_shape(input_shape)
assert ((output_shape is None) or (shape == output_shape))
output_shape = shape
return output_shape
def get_input_shape(self) -> List[int]:
return self.get_current_model().get_input_shape()
def get_output_shape(self) -> List[int]:
return self.get_current_model().get_output_shape()
def get_input_node_size(self) -> int:
return self.get_current_model().get_input_node_size()
def get_output_node_size(self) -> int:
return self.get_current_model().get_output_node_size()
def get_parameters(self):
return self.get_current_model().get_parameters()
def get_gradients(self):
return self.get_current_model().get_gradients()
def forward(self, x_buf, train=True):
return self.get_current_model().forward(x_buf=x_buf, train=train)
def backward(self, dy_buf):
return self.get_current_model().backward(dy_buf=dy_buf)
def dumps(self):
data = b''
data += core.Object.write_header('Switcher')
ver = 1
data += bb.int_to_bytes(ver)
data += bb.string_to_bytes(self.current_model_name)
layer_size = len(self.model_dict)
data += bb.int_to_bytes(layer_size)
for (name, model) in self.model_dict.items():
data += bb.string_to_bytes(name)
data += model.dumps()
return data
def loads(self, data):
(load_size, name) = core.Object.read_header(data)
data = data[load_size:]
assert (name == 'Switcher')
(data, ver) = bb.int_from_bytes(data)
assert (ver == 1)
(data, model_name) = bb.string_from_bytes(data)
(data, layer_size) = bb.int_from_bytes(data)
if (self.model_dict is not None):
assert (layer_size == len(self.model_dict))
for _ in range(layer_size):
(data, name) = bb.string_from_bytes(data)
assert (name in self.model_dict)
data = self.model_dict[name].loads(data)
else:
self.model_dict = {}
for _ in range(layer_size):
(data, name) = bb.string_from_bytes(data)
(data, model) = bb.object_loads(data)
self.model_dict[name] = model
self.switch_model(model_name)
return data
def dump_bytes(self):
bytes_dict = {}
for name in self.model_dict:
bytes_dict[name] = self.model_dict[name].dump_bytes()
return pickle.dumps(bytes_dict)
def load_bytes(self, data):
bytes_dict = pickle.loads(data)
for name in self.model_dict:
if (name in bytes_dict):
self.model_dict[name].load_bytes(bytes_dict[name])
@classmethod
def from_bytes(cls, data):
new_model = cls()
new_model.model_dict = None
data = new_model.loads(data)
return (data, new_model)
|
class RealToBinary(Model):
'RealToBinary class\n 実数値をバイナリ値に変換する。\n バイナリ変調機能も有しており、フレーム方向に変調した場合フレーム数(=ミニバッチサイズ)が\n 増える。\n またここでビットパッキングが可能であり、32フレームのbitをint32に詰め込みメモリ節約可能である\n\n Args:\n frame_modulation_size (int): フレーム方向への変調数(フレーム数が増える)\n depth_modulation_size (int): Depth方向への変調数(チャンネル数が増える)\n framewise (bool): Trueで変調閾値をフレーム単位とする(Falseでピクセル単位)\n bin_dtype (DType): 出力の型を bb.DType.FP32 もしくは bb.DType.BIT で指定可能\n '
def __init__(self, *, input_shape=None, frame_modulation_size=1, depth_modulation_size=1, value_generator=None, framewise=False, input_range_lo=0.0, input_range_hi=1.0, name=None, bin_dtype=bb.DType.FP32, real_dtype=bb.DType.FP32, core_model=None):
if (core_model is None):
core_creator = search_core_model('RealToBinary', [bin_dtype, real_dtype]).create
core_model = core_creator(frame_modulation_size, depth_modulation_size, value_generator, framewise, input_range_lo, input_range_hi)
super(RealToBinary, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class BinaryToReal(Model):
'BinaryToReal class\n バイナリ値を実数値に戻す。その際にフレーム方向に変調されたデータを積算して\n 元に戻すことが可能である\n\n Args:\n frame_integration_size (int): フレーム方向の積算サイズ数(フレーム変調の統合)\n depth_integration_size (int): チャンネル方向の積算サイズ(0の時はoutput_shape優先)\n output_shape (List[int]): 出力のシェイプ(指定が無ければ入力と同じshape)\n bin_dtype (DType): 入力の型を bb.DType.FP32 もしくは bb.DType.BIT で指定可能\n '
def __init__(self, *, frame_integration_size=1, depth_integration_size=1, output_shape=None, input_shape=None, name=None, bin_dtype=bb.DType.FP32, real_dtype=bb.DType.FP32, core_model=None):
if (output_shape is None):
output_shape = []
if (core_model is None):
core_creator = search_core_model('BinaryToReal', [bin_dtype, real_dtype]).create
core_model = core_creator(frame_integration_size=frame_integration_size, depth_integration_size=depth_integration_size, output_shape=output_shape)
super(BinaryToReal, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class BitEncode(Model):
'BitEncode class\n 実数値をバイナリ表現としてdepth方向に展開する\n\n Args:\n bit_size (int): エンコードするbit数\n '
def __init__(self, bit_size=1, *, output_shape=None, input_shape=None, name=None, bin_dtype=bb.DType.FP32, real_dtype=bb.DType.FP32, core_model=None):
if (output_shape is None):
output_shape = []
if (core_model is None):
core_creator = search_core_model('BitEncode', [bin_dtype, real_dtype]).create
core_model = core_creator(bit_size, output_shape)
super(BitEncode, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class InsertBitError(Model):
'InsertBitError class\n ビットエラーを挿入する\n\n Args:\n error_rate (float): エラー率\n '
def __init__(self, error_rate, *, input_shape=None, name=None, bin_dtype=bb.DType.FP32, real_dtype=bb.DType.FP32, core_model=None):
if (core_model is None):
core_creator = search_core_model('InsertBitError', [bin_dtype, real_dtype]).create
core_model = core_creator(error_rate)
super(InsertBitError, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class Reduce(Model):
'Reduce class\n 多重化されている出力を折り返して積和する\n\n Args:\n output_shape ([int]): 出力のシェイプ\n integration_size (int): 積算するサイズ\n '
def __init__(self, output_shape=None, integration_size=0, *, input_shape=None, name=None, bin_dtype=bb.DType.FP32, real_dtype=bb.DType.FP32, core_model=None):
if (output_shape is None):
output_shape = []
if (core_model is None):
core_creator = search_core_model('Reduce', [bin_dtype, real_dtype]).create
core_model = core_creator(output_shape, integration_size)
super(Reduce, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class DenseAffine(Model):
'DenseAffine class\n 普通のDenseAffine\n\n Args:\n output_shape (List[int]): 出力のシェイプ\n initialize_std (float) : 重み初期化乱数の標準偏差\n initializer (str): 変数の初期化アルゴリズム選択(default/normal/uniform/He/Xavier)。\n seed (int): 変数初期値などの乱数シード\n '
def __init__(self, output_shape=None, *, input_shape=None, initialize_std=0.01, initializer='', seed=1, name=None, dtype=bb.DType.FP32, core_model=None):
if (output_shape is None):
output_shape = []
if (core_model is None):
core_creator = search_core_model('DenseAffine', [dtype]).create
core_model = core_creator(output_shape=output_shape, initialize_std=initialize_std, initializer=initializer, seed=seed)
super(DenseAffine, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
def W(self):
return bb.Tensor(core_tensor=self.get_core().W())
def b(self):
return bb.Tensor(core_tensor=self.get_core().b())
def dW(self):
return bb.Tensor(core_tensor=self.get_core().dW())
def db(self):
return bb.Tensor(core_tensor=self.get_core().db())
|
class DenseAffineQuantize(Model):
'DenseAffineQuantize class\n DenseAffine に量子化のサポートを付けたもの\n\n Args:\n output_shape (List[int]): 出力のシェイプ\n initialize_std (float) : 重み初期化乱数の標準偏差\n initializer (str): 変数の初期化アルゴリズム選択(default/normal/uniform/He/Xavier)。\n quantize (bool): 量子化の有効状態の初期値\n weight_bits(int): 重みの量子化bit数 (0で量子化しない)\n output_bits(int): 入力の量子化bit数 (0で量子化しない)\n input_bits(int): 出力の量子化bit数 (0で量子化しない)\n weight_scale(float): 重みの量子化スケール(0でbit数に合わせる)\n output_scale(float): 入力の量子化スケール(0でbit数に合わせる)\n input_scale(float): 出力の量子化スケール(0でbit数に合わせる)\n seed (int): 変数初期値などの乱数シード\n '
def __init__(self, output_shape=None, *, input_shape=None, quantize=True, weight_bits=8, output_bits=16, input_bits=0, weight_scale=(1 / (1 << 8)), output_scale=(1 / (1 << 8)), input_scale=(1 / (1 << 8)), initialize_std=0.01, initializer='', seed=1, name=None, dtype=bb.DType.FP32, core_model=None):
if (output_shape is None):
output_shape = []
if (core_model is None):
core_creator = search_core_model('DenseAffineQuantize', [dtype]).create
core_model = core_creator(output_shape=output_shape, quantize=quantize, weight_bits=weight_bits, output_bits=output_bits, input_bits=input_bits, weight_scale=weight_scale, output_scale=output_scale, input_scale=input_scale, initialize_std=initialize_std, initializer=initializer, seed=seed)
super(DenseAffineQuantize, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
def W(self):
return bb.Tensor(core_tensor=self.get_core().W())
def b(self):
return bb.Tensor(core_tensor=self.get_core().b())
def dW(self):
return bb.Tensor(core_tensor=self.get_core().dW())
def db(self):
return bb.Tensor(core_tensor=self.get_core().db())
def WQ(self):
return bb.Tensor(core_tensor=self.get_core().WQ())
def bQ(self):
return bb.Tensor(core_tensor=self.get_core().bQ())
|
class DepthwiseDenseAffine(Model):
'DepthwiseDenseAffine class\n 普通のDepthwiseDenseAffine\n \n Args:\n output_shape (List[int]): 出力のシェイプ\n input_point_size (int): 入力のpoint数\n depth_size (int): depthサイズ\n initialize_std (float) : 重み初期化乱数の標準偏差\n initializer (str): 変数の初期化アルゴリズム選択(default/normal/uniform/He/Xavier)。\n seed (int): 変数初期値などの乱数シード\n '
def __init__(self, output_shape=None, *, input_shape=None, input_point_size=0, depth_size=0, initialize_std=0.01, initializer='', seed=1, name=None, dtype=bb.DType.FP32, core_model=None):
if (output_shape is None):
output_shape = []
if (core_model is None):
core_creator = search_core_model('DepthwiseDenseAffine', [dtype]).create
core_model = core_creator(output_shape=output_shape, input_point_size=input_point_size, depth_size=depth_size, initialize_std=initialize_std, initializer=initializer, seed=seed)
super(DepthwiseDenseAffine, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
def W(self):
return bb.Tensor(core_tensor=self.get_core().W())
def b(self):
return bb.Tensor(core_tensor=self.get_core().b())
def dW(self):
return bb.Tensor(core_tensor=self.get_core().dW())
def db(self):
return bb.Tensor(core_tensor=self.get_core().db())
|
class DepthwiseDenseAffineQuantize(Model):
'DepthwiseDenseAffineQuantize class\n DepthwiseDenseAffine に量子化のサポートを付けたもの\n\n Args:\n output_shape (List[int]): 出力のシェイプ\n input_point_size (int): 入力のpoint数\n depth_size (int): depthサイズ\n weight_bits(int): 重みの量子化bit数 (0で量子化しない)\n output_bits(int): 入力の量子化bit数 (0で量子化しない)\n input_bits(int): 出力の量子化bit数 (0で量子化しない)\n weight_scale(float): 重みの量子化スケール(0でbit数に合わせる)\n output_scale(float): 入力の量子化スケール(0でbit数に合わせる)\n input_scale(float): 出力の量子化スケール(0でbit数に合わせる)\n initialize_std (float) : 重み初期化乱数の標準偏差\n initializer (str): 変数の初期化アルゴリズム選択(default/normal/uniform/He/Xavier)。\n seed (int): 変数初期値などの乱数シード\n '
def __init__(self, output_shape=None, *, input_shape=None, input_point_size=0, depth_size=0, quantize=True, weight_bits=8, output_bits=16, input_bits=0, weight_scale=(1 / (1 << 8)), output_scale=(1 / (1 << 8)), input_scale=(1 / (1 << 8)), initialize_std=0.01, initializer='', seed=1, name=None, dtype=bb.DType.FP32, core_model=None):
if (output_shape is None):
output_shape = []
if (core_model is None):
core_creator = search_core_model('DepthwiseDenseAffineQuantize', [dtype]).create
core_model = core_creator(output_shape=output_shape, input_point_size=input_point_size, depth_size=depth_size, quantize=quantize, weight_bits=weight_bits, output_bits=output_bits, input_bits=input_bits, weight_scale=weight_scale, output_scale=output_scale, input_scale=input_scale, initialize_std=initialize_std, initializer=initializer, seed=seed)
super(DepthwiseDenseAffineQuantize, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
def W(self):
return bb.Tensor(core_tensor=self.get_core().W())
def b(self):
return bb.Tensor(core_tensor=self.get_core().b())
def dW(self):
return bb.Tensor(core_tensor=self.get_core().dW())
def db(self):
return bb.Tensor(core_tensor=self.get_core().db())
def WQ(self):
return bb.Tensor(core_tensor=self.get_core().WQ())
def bQ(self):
return bb.Tensor(core_tensor=self.get_core().bQ())
|
class BinaryDenseAffine(Model):
'Binary DenseAffine class\n バイナリ出力なDenseAffine\n\n Args:\n output_shape (List[int]): 出力のシェイプ\n initialize_std (float) : 重み初期化乱数の標準偏差\n initializer (str): 変数の初期化アルゴリズム選択(default/normal/uniform/He/Xavier)。\n momentum (float): 学習モーメント\n gamma (float): gamma 初期値\n beta (float): beta 初期値\n fix_gamma (bool): gamma を固定する(学習させない)\n fix_beta (bool): beta を固定する(学習させない)\n bin_dtype (DType)): バイナリ型を bb.DType.FP32 と bb.DType.BIT から指定\n seed (int): 変数初期値などの乱数シード\n memory_saving (bool): メモリ節約するか\n '
def __init__(self, output_shape=None, *, input_shape=None, batch_norm=True, activation=True, initialize_std=0.01, initializer='', momentum=0.9, gamma=1.0, beta=0.0, fix_gamma=False, fix_beta=False, binary_th=0.0, binary_low=(- 1.0), binary_high=(+ 1.0), hardtanh_min=(- 1.0), hardtanh_max=(+ 1.0), seed=1, memory_saving=True, name=None, bin_dtype=bb.DType.FP32, real_dtype=bb.DType.FP32, core_model=None):
if (output_shape is None):
output_shape = []
if (core_model is None):
core_creator = search_core_model('BinaryDenseAffine', [bin_dtype, real_dtype]).create
core_model = core_creator(output_shape=output_shape, batch_norm=batch_norm, activation=activation, initialize_std=initialize_std, initializer=initializer, momentum=momentum, gamma=gamma, beta=beta, fix_gamma=fix_gamma, fix_beta=fix_beta, binary_th=binary_th, binary_low=binary_low, binary_high=binary_high, hardtanh_min=hardtanh_min, hardtanh_max=hardtanh_max, seed=seed, memory_saving=memory_saving)
super(BinaryDenseAffine, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
def W(self):
return bb.Tensor(core_tensor=self.get_core().W())
def b(self):
return bb.Tensor(core_tensor=self.get_core().b())
def dW(self):
return bb.Tensor(core_tensor=self.get_core().dW())
def db(self):
return bb.Tensor(core_tensor=self.get_core().db())
def gamma(self):
return bb.Tensor(core_tensor=self.get_core().gamma())
def beta(self):
return bb.Tensor(core_tensor=self.get_core().beta())
def dgamma(self):
return bb.Tensor(core_tensor=self.get_core().dgamma())
def dbeta(self):
return bb.Tensor(core_tensor=self.get_core().dbeta())
def mean(self):
return bb.Tensor(core_tensor=self.get_core().mean())
def rstd(self):
return bb.Tensor(core_tensor=self.get_core().rstd())
def running_mean(self):
return bb.Tensor(core_tensor=self.get_core().running_mean())
def running_var(self):
return bb.Tensor(core_tensor=self.get_core().running_var())
|
class SparseModel(Model):
'疎結合の基底モデル\n '
def get_node_connection_size(self, output_node):
return self.get_core().get_node_connection_size(output_node)
def set_node_connection_index(self, output_node, connection, input_node):
self.get_core().set_node_connection_index(output_node, connection, input_node)
def get_node_connection_index(self, output_node, connection):
return self.get_core().get_node_connection_index(output_node, connection)
def get_lut_table_size(self, node):
return self.get_core().get_lut_table_size(node)
def get_lut_table(self, node, bitpos):
return self.get_core().get_lut_table(node, bitpos)
def get_connection_list(self):
'接続リスト取得\n \n 各出力ノードの入力に対する接続を二次元リストで返す\n 入出力のシェイプにかかわらず両者が flatten された状態で処理される\n\n Returns:\n connection_list (List[List[int]]) : 接続リスト\n '
connection_list = []
rows = self.get_output_node_size()
for i in range(rows):
node_list = []
cols = self.get_node_connection_size(i)
for j in range(cols):
node_list.append(self.get_node_connection_index(i, j))
connection_list.append(node_list)
return connection_list
def set_connection_list(self, connection_list):
'接続行列設定\n \n 各出力ノードの入力に対する接続を二次元リストで設定する\n 入出力のシェイプにかかわらず両者が flatten された状態で2次元リストとする\n\n Args:\n connection_list (List[List[int]]) : 接続リスト\n '
input_node_size = self.get_input_node_size()
rows = self.get_output_node_size()
assert (len(connection_list) == rows)
for i in range(rows):
cols = self.get_node_connection_size(i)
assert (len(connection_list[i]) == cols)
for j in range(cols):
index = int(connection_list[i][j])
assert ((index >= 0) and (index < input_node_size))
self.set_node_connection_index(i, j, index)
def get_lut_table_list(self):
'LUTテーブルのリスト取得\n\n Returns:\n lut_list (List[List[int]]) : 接続行列\n '
lut_list = []
rows = self.get_output_node_size()
for i in range(rows):
bit_list = []
cols = self.get_lut_table_size(i)
for j in range(cols):
bit_list.append(self.get_lut_table(i, j))
lut_list.append(bit_list)
return lut_list
|
class DifferentiableLut(SparseModel):
"DifferentiableLut class\n 微分可能LUTモデル\n\n 内部計算的には StocasticLUT + BatchNormalization + Binarize(HardTanh) で構成される\n\n FPGA合成するためのルックアップテーブル型のモデルを学習することができる\n 純粋な Stochastic 演算のみを行いたい場合は binarize と batch_norm の両方を False にすればよい。\n \n Args:\n output_shape (List[int]): 出力のシェイプ\n connection(str): 結線ルールを 'random', 'serial', 'depthwise' から指定可能\n batch_norm (bool): BatchNormalization を有効にするか\n binarize (bool): 二値化出力を有効にするか\n momentum (float): BatchNormalization の momentum\n gamma (float): BatchNormalization の gamma\n beta (float): BatchNormalization の beta\n N (int): LUTの入力数\n seed (int): 変数初期値などの乱数シード\n bin_dtype (DType)): バイナリ出力の型を bb.DType.FP32 と bb.DType.BIT から指定(bb.DType.BIT は binarize=True 時のみ)\n "
def __init__(self, output_shape=None, *, input_shape=None, connection='random', binarize=True, batch_norm=True, momentum=0.0, gamma=0.3, beta=0.5, seed=1, name=None, N=6, bin_dtype=bb.DType.FP32, real_dtype=bb.DType.FP32, core_model=None):
if (output_shape is None):
output_shape = []
if (core_model is None):
core_creator = search_core_model(('DifferentiableLut' + str(N)), [bin_dtype, real_dtype]).create
core_model = core_creator(output_shape, batch_norm, binarize, connection, momentum, gamma, beta, seed)
super(DifferentiableLut, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
def W(self):
'重み行列取得\n \n コピーではなくスライス参照を得ており、本体の値を書き換え可能\n\n Returns:\n W (Tensor): 重み行列を指すTensor\n '
return bb.Tensor.from_core(self.get_core().W())
def dW(self):
'重みの勾配行列取得\n\n コピーではなくスライス参照を得ており、本体の値を書き換え可能\n\n Returns:\n W (Tensor): 重みの勾配を指すTensor\n '
return bb.Tensor.from_core(self.get_core().dW())
def get_mean(self):
return bb.Tensor.from_core(self.get_core().get_mean())
def get_var(self):
return bb.Tensor.from_core(self.get_core().get_var())
def get_gamma(self):
return self.get_core().get_gamma()
def get_beta(self):
return self.get_core().get_beta()
|
class AverageLut(SparseModel):
"AverageLut class\n 入力値の平均を出力するLUT型のモデル\n バイナリの場合、bitをカウントして1の方が多ければ1を出力するテーブル固定のLUTと考える事ができる\n\n Args:\n output_shape ([int]): 出力のシェイプ\n connection(str): 結線ルールを 'random', 'serial', 'depthwise' から指定可能\n binarize (bool): 二値化出力を有効にするか\n binarize_input (bool): 入力を二値化してから使うようにするか\n N (int): LUTの入力数\n seed (int): 変数初期値などの乱数シード\n bin_dtype (DType)): バイナリ出力の型を bb.DType.FP32 と bb.DType.BIT から指定(bb.DType.BIT は binarize=True 時のみ)\n "
def __init__(self, output_shape=None, *, input_shape=None, name=None, N=6, connection='serial', binarize=True, binarize_input=False, seed=1, bin_dtype=bb.DType.FP32, real_dtype=bb.DType.FP32, core_model=None):
if (output_shape is None):
output_shape = []
if (core_model is None):
core_creator = search_core_model('AverageLut', [bin_dtype, real_dtype]).create
core_model = core_creator(n=N, output_shape=output_shape, connection=connection, binarize=binarize, binarize_input=binarize_input, seed=seed)
super(AverageLut, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class MaxLut(SparseModel):
"MaxLut class\n 入力値の最大値を出力するLUT型のモデル\n バイナリの場合、論理和をの形となるモデル\n\n Args:\n output_shape ([int]): 出力のシェイプ\n connection(str): 結線ルールを 'random', 'serial', 'depthwise' から指定可能\n binarize (bool): 二値化出力を有効にするか\n binarize_input (bool): 入力を二値化してから使うようにするか\n N (int): LUTの入力数\n seed (int): 変数初期値などの乱数シード\n bin_dtype (DType)): バイナリ出力の型を bb.DType.FP32 と bb.DType.BIT から指定(bb.DType.BIT は binarize=True 時のみ)\n "
def __init__(self, output_shape=None, *, input_shape=None, name=None, N=6, connection='serial', binarize=True, binarize_input=False, seed=1, bin_dtype=bb.DType.FP32, real_dtype=bb.DType.FP32, core_model=None):
if (output_shape is None):
output_shape = []
if (core_model is None):
core_creator = search_core_model('MaxLut', [bin_dtype, real_dtype]).create
core_model = core_creator(n=N, output_shape=output_shape, connection=connection, binarize=binarize, binarize_input=binarize_input, seed=seed)
super(MaxLut, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class BinaryLut(SparseModel):
"バイナリLUTモデル\n\n 一般的なFPGAのLUTと同等の機能をするモデル。\n 学習能力はなく、他のモデルで学習した結果をインポートしてモデル評価を行うためのもの\n \n Args:\n output_shape (List[int]): 出力のシェイプ\n connection(str): 結線ルールを 'random', 'serial', 'depthwise' から指定可能(未実装)\n N (int): LUTの入力数\n seed (int): 変数初期値などの乱数シード\n fw_dtype (DType)): forwardの型を bb.DType.FP32 と bb.DType.BIT から指定\n "
def __init__(self, output_shape=None, *, input_shape=None, connection='random', seed=1, name=None, N=6, fw_dtype=bb.DType.FP32, bw_dtype=bb.DType.FP32, core_model=None):
if (output_shape is None):
output_shape = []
if (core_model is None):
core_creator = search_core_model(('BinaryLut' + str(N)), [fw_dtype, bw_dtype]).create
core_model = core_creator(output_shape, connection, seed)
super(BinaryLut, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
def import_layer(self, leyaer):
'他のモデルからからインポート\n\n インポート元は入出力が同じ形状をしている必要があり、デジタル値の入力に対して\n 出力を 0.5 を閾値として、バイナリテーブルを構成して取り込む\n\n Args:\n leyaer (Model): インポート元のモデル\n '
self.get_core().import_layer(leyaer.get_core())
@staticmethod
def from_sparse_model(layer, *, fw_dtype=bb.DType.FP32):
'他のモデルを元に生成\n\n インポート元は入出力が同じ形状をしている必要があり、デジタル値の入力に対して\n 出力を 0.5 を閾値として、バイナリテーブルを構成して取り込む\n\n Args:\n leyaer (Model): インポート元のモデル\n '
N = layer.get_core().get_node_connection_size(0)
new_model = BinaryLut(output_shape=layer.get_output_shape(), input_shape=layer.get_input_shape(), N=N, fw_dtype=fw_dtype)
new_model.import_layer(layer)
return new_model
|
class ConvolutionIm2Col(Model):
'ConvolutionIm2Col class\n 畳み込みの lowering における im2col 層\n '
def __init__(self, filter_size=(1, 1), stride=(1, 1), *, padding='valid', border_mode='reflect_101', border_value=0.0, input_shape=None, name=None, fw_dtype=bb.DType.FP32, bw_dtype=bb.DType.FP32, core_model=None):
if (core_model is None):
core_creator = search_core_model('ConvolutionIm2Col', [fw_dtype, bw_dtype]).create
core_model = core_creator(filter_size[0], filter_size[1], stride[0], stride[1], padding, border_mode)
super(ConvolutionIm2Col, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
def get_filter_size(self):
core_model = self.get_core()
return [core_model.get_filter_size_h(), core_model.get_filter_size_w()]
def get_stride(self):
core_model = self.get_core()
return [core_model.get_stride_y(), core_model.get_stride_x()]
def get_padding(self):
return self.get_core().get_padding()
def get_border_mode(self):
return self.get_core().get_border_mode()
def get_border_value(self):
return self.get_core().get_border_value()
|
class ConvolutionCol2Im(Model):
'ConvolutionCol2Im class\n 畳み込みの lowering における col2im 層\n '
def __init__(self, output_size=(1, 1), *, input_shape=None, name=None, fw_dtype=bb.DType.FP32, bw_dtype=bb.DType.FP32, core_model=None):
if (core_model is None):
core_creator = search_core_model('ConvolutionCol2Im', [fw_dtype, bw_dtype]).create
core_model = core_creator(output_size[0], output_size[1])
super(ConvolutionCol2Im, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
def set_output_size(self, output_size):
self.get_core().set_output_size(output_size[0], output_size[1])
|
class Convolution2d(Sequential):
"Convolution class\n Lowering による畳み込み演算をパッキングするクラス\n\n sub_layer で指定した演算レイヤーを畳み込み計算するためのモデル\n 例えば sub_layer に DenseAffineレイヤーを指定すると一般的なCNN用の畳み込み層となるが、\n BinaryBrain ではここに DifferentiableLut モデルを組み合わせて作った複合レイヤーを\n 指定することでFPGA化に適した畳み込み層を学習させることができる。\n\n sub_layer で指定したサブレイヤーが im2col と col2im で挟み込まれ、一般に\n Lowering と呼ばれる方法で畳み込み演算が実行される\n\n Args:\n sub_layer (Model): 畳み込みを行うサブレイヤー(このレイヤが im2col と col2im で挟み込まれる)\n filter_size ((int, int)): 2次元のタプルでフィルタサイズを指定する\n stride ((int, int)): 2次元のタプルでストライドサイズを指定する\n batch_norm (bool): BatchNormalization を有効にするか\n padding (str)): パディングの方法を 'valid' と 'same' で指定する\n border_mode (Border)): 'same' 時のボーダー処理を指定する\n border_value (float): 'same' 時のボーダー処理が CONSTANT の場合にパディング値を指定する\n fw_dtype (DType)): forwarする型を bb.DType.FP32 と bb.DType.BIT から指定\n "
def __init__(self, sub_layer, filter_size=(1, 1), stride=(1, 1), *, input_shape=None, padding='valid', border_mode='reflect_101', border_value=0.0, name=None, fw_dtype=bb.DType.FP32, bw_dtype=bb.DType.FP32):
self.fw_dtype = fw_dtype
self.bw_dtype = bw_dtype
self.shapes = []
self.im2col = ConvolutionIm2Col(filter_size=filter_size, stride=stride, padding=padding, border_mode=border_mode, border_value=border_value, fw_dtype=fw_dtype, bw_dtype=bw_dtype)
self.sub_layer = sub_layer
self.col2im = ConvolutionCol2Im(fw_dtype=fw_dtype, bw_dtype=bw_dtype)
model_list = [self.im2col, self.sub_layer, self.col2im]
super(Convolution2d, self).__init__(model_list=model_list, name=name, input_shape=input_shape)
def send_command(self, command, send_to='all'):
self.im2col.send_command(command=command, send_to=send_to)
self.sub_layer.send_command(command=command, send_to=send_to)
self.col2im.send_command(command=command, send_to=send_to)
def get_core(self):
core_creator = search_core_model('Convolution2d', [self.fw_dtype, self.bw_dtype]).create
core_model = core_creator(self.im2col.get_core(), self.sub_layer.get_core(), self.col2im.get_core())
if (self.name is not None):
core_model.set_name(self.name)
return core_model
def get_sub_layer(self):
return self.sub_layer
def set_input_shape(self, shape):
self.input_shape = shape
input_h_size = shape[1]
input_w_size = shape[2]
padding = self.im2col.get_padding()
filter_size = self.im2col.get_filter_size()
stride = self.im2col.get_stride()
if (padding == 'valid'):
output_h_size = ((((input_h_size - filter_size[0]) + 1) + (stride[0] - 1)) // stride[0])
output_w_size = ((((input_w_size - filter_size[1]) + 1) + (stride[1] - 1)) // stride[1])
elif (padding == 'same'):
output_h_size = ((input_h_size + (stride[0] - 1)) // stride[0])
output_w_size = ((input_w_size + (stride[1] - 1)) // stride[0])
else:
raise ValueError('illegal padding value')
self.col2im.set_output_size(output_size=[output_h_size, output_w_size])
return super(Convolution2d, self).set_input_shape(shape)
def forward(self, x_buf, train=True):
shape = x_buf.get_node_shape()
self.set_input_shape(shape)
if train:
self.shapes.append(shape)
return super(Convolution2d, self).forward(x_buf, train=train)
def backward(self, dy_buf):
shape = self.shapes.pop()
self.set_input_shape(shape)
return super(Convolution2d, self).backward(dy_buf)
def clear(self):
self.shapes = []
return super(Convolution2d, self).clear()
def get_object_name(self):
return ((('Convolution2d_' + bb.dtype_to_name(self.fw_dtype)) + '_') + bb.dtype_to_name(self.bw_dtype))
def dumps(self):
data = b''
data += core.Object.write_header(self.get_object_name())
ver = 1
data += bb.int_to_bytes(ver)
data += self.im2col.dumps()
data += self.col2im.dumps()
if self.sub_layer:
data += bb.bool_to_bytes(True)
data += self.sub_layer.dumps()
else:
data += bb.bool_to_bytes(False)
return data
def loads(self, data):
(data, name) = bb.load_object_header(data)
type_names = re.match('Convolution2d_(.+)_(.+)', name)
assert type_names
self.fw_dtype = bb.dtype_from_name(type_names[1])
self.bw_dtype = bb.dtype_from_name(type_names[2])
(data, ver) = bb.int_from_bytes(data)
assert (ver == 1)
data = self.im2col.loads(data)
data = self.col2im.loads(data)
(data, has_layer) = bb.bool_from_bytes(data)
if has_layer:
if self.sub_layer:
data = self.sub_layer.loads(data)
else:
(data, model) = bb.object_loads(data)
self.sub_layer = model
self.set_model_list([self.im2col, self.sub_layer, self.col2im])
return data
@classmethod
def from_bytes(cls, data):
(_, object_name) = bb.load_object_header(data)
dtypes = object_name.split('_')
new_model = cls(sub_layer=None, fw_dtype=bb.dtype_from_name(dtypes[1]), bw_dtype=bb.dtype_from_name(dtypes[2]))
data = new_model.loads(data)
return (data, new_model)
|
class MaxPooling(Model):
'MaxPooling class\n\n Args:\n filter_size ((int, int)): 2次元のタプルでフィルタサイズを指定する\n fw_dtype (DType)): forwarする型を bb.DType.FP32 と bb.DType.BIT から指定\n '
def __init__(self, filter_size=(2, 2), *, input_shape=None, name=None, fw_dtype=bb.DType.FP32, bw_dtype=bb.DType.FP32, core_model=None):
if (core_model is None):
core_creator = search_core_model('MaxPooling', [fw_dtype, bw_dtype]).create
core_model = core_creator(filter_size[0], filter_size[1])
super(MaxPooling, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class StochasticMaxPooling(Model):
'StochasticMaxPooling class\n\n Stochastic 演算として OR 演算で Pooling 層を構成するモデル\n\n Args:\n filter_size ((int, int)): 2次元のタプルでフィルタサイズを指定する(現在2x2のみ)\n fw_dtype (DType)): forwarする型を bb.DType.FP32 と bb.DType.BIT から指定\n '
def __init__(self, filter_size=(2, 2), *, input_shape=None, name=None, fw_dtype=bb.DType.FP32, bw_dtype=bb.DType.FP32, core_model=None):
assert (len(filter_size) == 2)
if (core_model is None):
if ((filter_size[0] == 2) and (filter_size[1] == 2)):
core_creator = search_core_model('StochasticMaxPooling2x2', [fw_dtype, bw_dtype]).create
core_model = core_creator()
else:
core_creator = search_core_model('StochasticMaxPooling', [fw_dtype, bw_dtype]).create
core_model = core_creator(filter_size[0], filter_size[1])
super(StochasticMaxPooling, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class UpSampling(Model):
'UpSampling class\n\n 畳み込みの逆方向にアップサンプリングを行うモデル\n\n Args:\n filter_size ((int, int)): 2次元のタプルでフィルタサイズを指定する(現在2x2のみ)\n fw_dtype (DType)): forwarする型を bb.DType.FP32 と bb.DType.BIT から指定\n '
def __init__(self, filter_size=(2, 2), *, fill=True, input_shape=None, name=None, fw_dtype=bb.DType.FP32, bw_dtype=bb.DType.FP32, core_model=None):
if (core_model is None):
core_creator = search_core_model('UpSampling', [fw_dtype, bw_dtype]).create
core_model = core_creator(filter_size[0], filter_size[1], fill)
super(UpSampling, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class Binarize(Model):
'Binarize class\n\n 2値化(活性化層)\n backward は hard-tanh となる\n\n Args:\n bin_dtype (DType)): バイナリ型を bb.DType.FP32 と bb.DType.BIT から指定\n '
def __init__(self, *, input_shape=None, binary_th=0.0, binary_low=(- 1.0), binary_high=(+ 1.0), hardtanh_min=(- 1.0), hardtanh_max=(+ 1.0), name=None, bin_dtype=bb.DType.FP32, real_dtype=bb.DType.FP32, core_model=None):
if (core_model is None):
core_creator = search_core_model('Binarize', [bin_dtype, real_dtype]).create
core_model = core_creator(binary_th=binary_th, binary_low=binary_low, binary_high=binary_high, hardtanh_min=hardtanh_min, hardtanh_max=hardtanh_max)
super(Binarize, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class Sigmoid(Model):
'Sigmoid class\n\n Sigmoid 活性化層\n send_command で "binary true" とすることで、Binarize に切り替わる\n 多値で学習を進めて、途中から Binarize に切り替える実験などが可能である\n '
def __init__(self, *, input_shape=None, name=None, bin_dtype=bb.DType.FP32, real_dtype=bb.DType.FP32, core_model=None):
if (core_model is None):
core_creator = search_core_model('Sigmoid', [bin_dtype, real_dtype]).create
core_model = core_creator()
super(Sigmoid, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class ReLU(Model):
'ReLU class\n\n ReLU 活性化層\n send_command で "binary true" とすることで、Binarize に切り替わる\n 多値で学習を進めて、途中から Binarize に切り替える実験などが可能である\n '
def __init__(self, *, input_shape=None, name=None, bin_dtype=bb.DType.FP32, real_dtype=bb.DType.FP32, core_model=None):
if (core_model is None):
core_creator = search_core_model('ReLU', [bin_dtype, real_dtype]).create
core_model = core_creator()
super(ReLU, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class HardTanh(Model):
'HardTanh class\n\n HardTanh 活性化層\n send_command で "binary true" とすることで、Binarize に切り替わる\n 多値で学習を進めて、途中から Binarize に切り替える実験などが可能である\n '
def __init__(self, *, input_shape=None, name=None, bin_dtype=bb.DType.FP32, real_dtype=bb.DType.FP32, core_model=None):
if (core_model is None):
core_creator = search_core_model('HardTanh', [bin_dtype, real_dtype]).create
core_model = core_creator()
super(HardTanh, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class Softmax(Model):
'Softmax class\n\n Softmax 活性化層\n '
def __init__(self, *, input_shape=None, name=None, dtype=bb.DType.FP32, core_model=None):
if (core_model is None):
core_creator = search_core_model('Softmax', [dtype]).create
core_model = core_creator()
super(Softmax, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class BatchNormalization(Model):
'BatchNormalization class\n\n Args:\n momentum (float): 学習モーメント\n gamma (float): gamma 初期値\n beta (float): beta 初期値\n fix_gamma (bool): gamma を固定する(学習させない)\n fix_beta (bool): beta を固定する(学習させない)\n bin_dtype (DType)): バイナリ型を bb.DType.FP32 と bb.DType.BIT から指定\n '
def __init__(self, *, input_shape=None, momentum=0.9, gamma=1.0, beta=0.0, fix_gamma=False, fix_beta=False, name=None, dtype=bb.DType.FP32, core_model=None):
if (core_model is None):
core_creator = search_core_model('BatchNormalization', [dtype]).create
core_model = core_creator(momentum=momentum, gamma=gamma, beta=beta, fix_gamma=fix_gamma, fix_beta=fix_beta)
super(BatchNormalization, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
def gamma(self):
return bb.Tensor(core_tensor=self.get_core().gamma())
def beta(self):
return bb.Tensor(core_tensor=self.get_core().beta())
def dgamma(self):
return bb.Tensor(core_tensor=self.get_core().dgamma())
def dbeta(self):
return bb.Tensor(core_tensor=self.get_core().dbeta())
def mean(self):
return bb.Tensor(core_tensor=self.get_core().mean())
def rstd(self):
return bb.Tensor(core_tensor=self.get_core().rstd())
def running_mean(self):
return bb.Tensor(core_tensor=self.get_core().running_mean())
def running_var(self):
return bb.Tensor(core_tensor=self.get_core().running_var())
|
class Dropout(Model):
'Dropout class\n\n Args:\n rate (float): Drop率\n seed (int): 乱数シード\n fw_dtype (DType): forwardの型を bb.DType.FP32 と bb.DType.BIT から指定\n '
def __init__(self, *, rate=0.5, input_shape=None, seed=1, name=None, fw_dtype=bb.DType.FP32, bw_dtype=bb.DType.FP32, core_model=None):
if (core_model is None):
core_creator = search_core_model('Dropout', [fw_dtype, bw_dtype]).create
core_model = core_creator(rate, seed)
super(Dropout, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class Shuffle(Model):
'Shuffle class\n\n 所謂 ShuffleNet のようなシャッフルを行うモデル\n 入力ノードが shuffle_unit 個のグループに分割されるようにシャッフルする\n\n\n Args:\n shuffle_unit (int): シャッフルする単位\n '
def __init__(self, shuffle_unit, *, output_shape=None, input_shape=None, name=None, core_model=None):
if (output_shape is None):
output_shape = []
if (core_model is None):
core_creator = search_core_model('Shuffle', []).create
core_model = core_creator(shuffle_unit, output_shape)
super(Shuffle, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class Concatenate(Model):
'Concatenate class\n\n 複数の入力をConcatenateするクラス\n '
def __init__(self, *, input_shape=None, name=None, core_model=None):
if (core_model is None):
core_creator = search_core_model('Concatenate', []).create
core_model = core_creator()
super(Concatenate, self).__init__(core_model=core_model, input_shape=input_shape, name=name)
|
class DifferentiableLutBlock(Sequential):
def __init__(self, output_shape, depth, name=None, batch_norm=True, binarize=True, bin_dtype=bb.DType.FP32):
self.layers = []
for i in range(depth):
if (name is None):
layer_name = None
else:
layer_name = ((name + '_') + str(i))
connection = ('serial' if (i < (depth - 1)) else 'random')
if (i == 0):
self.layers.insert(0, bb.AverageLut(output_shape, connection=connection, binarize=binarize, name=layer_name, bin_dtype=bin_dtype))
else:
self.layers.insert(0, bb.DifferentiableLut(output_shape, connection=connection, batch_norm=batch_norm, binarize=binarize, name=layer_name, bin_dtype=bin_dtype))
output_shape[0] *= 6
super(DifferentiableLutBlock, self).__init__(self.layers, name=name)
|
def get_model_list(net, flatten: bool=False):
' Get model list from networks\n ネットから構成するモデルのリストを取り出す\n \n Args:\n net (Model): 検索するパス\n flatten (bool): 階層をフラットにするかどうか\n Returns:\n list of models\n '
if (type(net) is not list):
net = [net]
if (not flatten):
return net
def flatten_list(in_list, out_list):
for model in in_list:
if hasattr(model, 'get_model_list'):
flatten_list(model.get_model_list(), out_list)
else:
out_list.append(model)
out_list = []
flatten_list(net, out_list)
return out_list
|
def get_model_list_for_rtl(net):
if (type(net) is not list):
net = [net]
def flatten_list(in_list, out_list):
for model in in_list:
if issubclass(type(model), Switcher):
model = model.get_current_model()
if ((type(model) != Convolution2d) and hasattr(model, 'get_model_list')):
flatten_list(model.get_model_list(), out_list)
else:
out_list.append(model)
out_list = []
flatten_list(net, out_list)
return out_list
|
def int_to_bytes(value: int):
return value.to_bytes(8, 'little')
|
def int_from_bytes(data: bytes) -> (bytes, int):
value = int.from_bytes(data[0:8], 'little')
return (data[8:], value)
|
def bool_to_bytes(value: bool):
return value.to_bytes(1, 'little')
|
def bool_from_bytes(data: bytes) -> (bytes, bool):
value = bool.from_bytes(data[0:1], 'little')
return (data[1:], value)
|
def string_to_bytes(value: str):
value = value.encode(encoding='utf-8')
data = int_to_bytes(len(value))
data += value
return data
|
def string_from_bytes(data: bytes) -> (bytes, str):
(data, str_len) = int_from_bytes(data)
value = data[0:str_len].decode(encoding='utf-8')
return (data[str_len:], value)
|
def dump_object_header(object_name):
return core.Object.write_header(object_name)
|
def load_object_header(data):
(load_size, object_name) = core.Object.read_header(data)
return (data[load_size:], object_name)
|
def get_core_class_list():
return _core_class_list
|
def get_core_class_dict():
return _core_class_dict
|
def search_core_class(class_name):
return _core_class_dict[class_name]
|
def get_core_subclass_list(superclass):
class_list = []
for c in get_core_class_list():
if issubclass(c[1], superclass):
class_list.append(c)
return class_list
|
def get_core_subclass_dict(superclass):
return {k: v for (k, v) in get_core_subclass_list(superclass)}
|
def make_core_object_name(object_name, dtypes):
for dtype in dtypes:
object_name = ((object_name + '_') + bb.dtype_to_name(dtype))
return object_name
|
def split_core_object_name(core_object_name):
args = core_object_name.split('_')
dtypes = []
for dtype_name in args[1:]:
dtypes.append(bb.dtype_from_name(dtype_name))
return (args[0], dtypes)
|
def get_core_object_list():
return _core_object_list
|
def get_core_object_dict():
return _core_object_dict
|
def search_core_object(object_name, dtypes):
core_object_name = make_core_object_name(object_name, dtypes)
return _core_object_dict[core_object_name]
|
def core_object_loads(data):
(load_size, core_object) = core.object_load(data)
return (data[load_size:], core_object)
|
def object_creator_regist(creator):
_object_creator_list.append(creator)
|
def object_loads(data: bytes):
'バイト列からオブジェクトを再構築する\n\n Args:\n data(bytes): バイト列\n \n Returns:\n obj (Object): 再構築したオブジェクト\n '
(_, object_name) = core.Object.read_header(data)
split_name = object_name.split('_')
name = split_name[0]
dtypes = []
for dtype_name in split_name[1:]:
dtypes.append(bb.dtype_from_name(dtype_name))
for creator in _object_creator_list:
(data, obj) = creator(data, name, dtypes)
if (obj is not None):
return (data, obj)
(load_size, obj) = core.object_load(data)
if (obj is not None):
return (data[load_size:], obj)
print(('object_loads not object found : %s' % object_name))
return (data, None)
|
def object_load(filename: str):
'ファイルからオブジェクトを再構築する\n\n Args:\n filename(str): ファイル名\n \n Returns:\n obj (Object): 再構築したオブジェクト\n '
with open(filename, 'rb') as f:
(data, obj) = bb.object_loads(f.read())
if (data != b''):
print('[object_loads] warrning: data is too long')
return obj
|
class Object():
'各クラスの基底クラス\n \n 本クラスから派生する各種のクラスにはシリアライズの機能がサポートされる\n\n '
def __init__(self, core_object=None):
self.core_object = core_object
def set_core(self, core_object):
self.core_object = core_object
def get_core(self):
return self.core_object
def get_object_name(self):
core_object = self.get_core()
if (core_object is not None):
return core_object.get_object_name()
return ''
def dumps(self) -> bytes:
'バイトデータにシリアライズ\n\n モデルのデータをシリアライズして保存するためのバイト配列を生成\n \n Returns:\n data (bytes): Serialize data\n '
core_model = self.get_core()
if (core_model is not None):
return core_model.dump_object()
return b''
def loads(self, data: bytes) -> bytes:
'バイトデータをロード\n\n モデルのデータをシリアライズして復帰のバイト配列ロード\n \n Args:\n data (bytes): Serialize data\n '
core_model = self.get_core()
if (core_model is not None):
size = core_model.load_object(data)
return data[size:]
return data
def dump(self, filename: str):
'ファイルに保存\n\n モデルのデータをシリアライズしてファイルに保存\n \n Args:\n filename (str): ファイル名\n '
with open(filename, 'wb') as f:
f.write(self.dumps())
def load(self, filename: str):
'ファイルからロード\n\n ファイルからロード\n \n Args:\n filename (str): ファイル名\n '
with open(filename, 'rb') as f:
data = self.loads(f.read())
if (data != b''):
print('[Model.loads] warrning: data is too long')
|
class Optimizer(bb.Object):
'Optimizer の基本クラス\n '
def __init__(self, core_optimizer=None):
super(Optimizer, self).__init__(core_object=core_optimizer)
def set_variables(self, params, grads):
'変数設定\n\n Args:\n params (Variables): 学習対象のパラメータ変数\n grads (Variables): paramsに対応する勾配変数\n '
self.get_core().set_variables(params.get_core(), grads.get_core())
def update(self):
'パラメータ更新＆勾配ゼロクリア\n\n set_variablesで設定された勾配変数に基づいた学習をset_variablesで\n 設定されたパラメータ変数に適用して、勾配をゼロクリアする\n '
return self.get_core().update()
def zero_grad(self):
'勾配のゼロクリア\n\n set_variablesで設定された勾配変数をゼロクリアする\n '
return self.get_core().zero_grad()
def step(self):
'パラメータ更新\n\n set_variablesで設定された勾配変数に基づいた学習をset_variablesで\n 設定されたパラメータ変数に適用する\n '
return self.get_core().step()
def set_learning_rate(self, learning_rate):
'学習率設定\n '
self.get_core().set_learning_rate(learning_rate)
|
class OptimizerSgd(Optimizer):
'SGD 最適化クラス\n\n Args:\n learning_rate (float): 学習率\n '
def __init__(self, learning_rate=0.001, dtype=bb.DType.FP32):
core_optimizer = bb.search_core_object('OptimizerSgd', [dtype]).create(learning_rate=learning_rate)
super(OptimizerSgd, self).__init__(core_optimizer=core_optimizer)
|
class OptimizerAdaGrad(Optimizer):
'AdaGrad 最適化クラス\n\n Args:\n learning_rate (float): 学習率\n '
def __init__(self, learning_rate=0.01, dtype=bb.DType.FP32):
core_optimizer = bb.search_core_object('OptimizerAdaGrad', [dtype]).create(learning_rate=learning_rate)
super(OptimizerAdaGrad, self).__init__(core_optimizer=core_optimizer)
|
class OptimizerAdam(Optimizer):
'Adam 最適化クラス\n\n Args:\n learning_rate (float): 学習率\n beta1 (float): beta1\n beta2 (float): beta2\n '
def __init__(self, learning_rate=0.001, beta1=0.9, beta2=0.999, dtype=bb.DType.FP32):
core_optimizer = bb.search_core_object('OptimizerAdam', [dtype]).create(learning_rate=learning_rate, beta1=beta1, beta2=beta2)
super(OptimizerAdam, self).__init__(core_optimizer=core_optimizer)
|
def get_date_string():
return datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
|
def is_date_string(text: str):
' Check if the string is a date\n データ保存パス用の日付文字列かどうか判定\n \n Args:\n text (str): 判定する文字列\n \n Returns:\n Boolean.\n '
if re.fullmatch('[12][0-9]{3}[01][0-9][0-3][0-9]_[0-2][0-9][0-5][0-9][0-5][0-9]', text):
return True
return False
|
def get_latest_path(path: str) -> str:
' Get latest data path\n 最新のデータ保存パスを取得\n \n Args:\n path (str): 検索するパス\n \n Returns:\n 見つかったパス. 見つからなければ None\n '
if (not os.path.exists(path)):
return None
files = os.listdir(path)
dirs = [f for f in files if os.path.isdir(os.path.join(path, f))]
targets = []
for d in dirs:
if is_date_string(d):
targets.append(d)
if (not targets):
return None
targets.sort(reverse=True)
return os.path.join(path, targets[0])
|
def remove_backups(path: str, keeps: int=(- 1)):
' Get latest data path\n 最新のデータ保存パスを取得\n \n Args:\n path (str): 検索するパス\n keeps (int): 削除せずに残す数\n '
if (keeps < 0):
return
files = os.listdir(path)
dirs = [f for f in files if os.path.isdir(os.path.join(path, f))]
targets = []
for d in dirs:
if is_date_string(d):
no_delete_file = os.path.join(path, d, '__no_delete__')
if (not os.path.exists(no_delete_file)):
targets.append(d)
targets.sort(reverse=True)
del targets[:keeps]
for t in targets:
shutil.rmtree(os.path.join(path, t))
|
def _save_net_file(path: str, name: str, net, file_format=None):
if ((file_format == 'bin') or (file_format == 'all')):
net_file_name = os.path.join(path, (name + '.bin'))
with open(net_file_name, 'wb') as f:
f.write(net.dump_bytes())
elif ((file_format == 'pickle') or (file_format == 'all')):
net_file_name = os.path.join(path, (name + '.pickle'))
with open(net_file_name, 'wb') as f:
f.write(pickle.dumps(net))
else:
net_file_name = os.path.join(path, (name + '.bb_net'))
with open(net_file_name, 'wb') as f:
f.write(net.dumps())
|
def _load_net_file(path: str, name: str, net, file_format=None) -> bool:
if ((file_format is None) or (file_format == 'bb_net')):
net_file_name = os.path.join(path, (name + '.bb_net'))
if os.path.exists(net_file_name):
with open(net_file_name, 'rb') as f:
net.loads(f.read())
return True
if ((file_format is None) or (file_format == 'bin')):
net_file_name = os.path.join(path, (name + '.bin'))
if os.path.exists(net_file_name):
with open(net_file_name, 'rb') as f:
net.load_bytes(f.read())
return True
if ((file_format is None) or (file_format == 'pickle')):
net_file_name = os.path.join(path, (name + '.pickle'))
if os.path.exists(net_file_name):
with open(net_file_name, 'rb') as f:
tmp_net = pickle.loads(f.read())
net.loads(tmp_net.dumps())
return True
return False
|
def save_models(path: str, net, *, write_layers=True, file_format=None):
' save networks\n ネットを構成するモデルの保存\n \n Args:\n path (str): 保存するパス\n net (Model): 保存するネット\n write_layers (bool) : レイヤー別にも出力するかどうか\n '
os.makedirs(path, exist_ok=True)
net_name = net.get_name()
_save_net_file(path, net_name, net, file_format=file_format)
if write_layers:
models = bb.get_model_list(net, flatten=True)
fname_list = []
for (i, model) in enumerate(models):
name = model.get_name()
if model.is_named():
if (name in fname_list):
print(('[warrning] duplicate model name : %s' % name))
fname = ('%04d_%s' % (i, name))
else:
fname = ('%s' % name)
else:
fname = ('%04d_%s' % (i, name))
fname_list.append(fname)
_save_net_file(path, fname, model, file_format=file_format)
|
def load_models(path: str, net, *, read_layers: bool=False, file_format=None, verbose=True):
' load networks\n ネットを構成するモデルの保存\n \n Args:\n path (str): 読み出すパス\n net (Model): 読み込むネット\n read_layers (bool) : レイヤー別に読み込むか\n verbose (bool) : 詳しく表示する\n '
if (not read_layers):
net_name = net.get_name()
res = _load_net_file(path, net_name, net, file_format=file_format)
if ((not res) and verbose):
print(('file not found : %s' % os.path.join(path, net_name)))
return res
models = bb.get_model_list(net, flatten=True)
fname_list = []
for (i, model) in enumerate(models):
name = model.get_name()
if model.is_named():
if (name in fname_list):
print(('[warrning] duplicate model name : %s' % name))
fname = ('%04d_%s' % (i, name))
else:
fname = ('%s' % name)
else:
fname = ('%04d_%s' % (i, name))
fname_list.append(fname)
res = _load_net_file(path, fname, model, file_format=file_format)
if ((not res) and verbose):
print(('file not found : %s' % fname))
return True
|
def save_networks(path: str, net, name=None, *, backups: int=10, write_layers: bool=False, file_format=None):
' save networks\n ネットを構成するモデルの保存\n \n 指定したパスの下にさらに日付でディレクトリを作成して保存\n 古いものから削除する機能あり\n 名前を指定すれば日付ではなく名前で記録可能\n \n Args:\n path (str) : 保存するパス\n net (Model) : 保存するネット\n name (str) : 保存名(指定しなければ日時で保存)\n backups (int) : 残しておく古いデータ数(-1ですべて残す)\n write_layers(bool) : レイヤー別に出力\n \n Returns:\n name (str) : 保存名を返す\n '
os.makedirs(path, exist_ok=True)
if (name is None):
name = get_date_string()
data_path = os.path.join(path, name)
save_models(data_path, net, write_layers=write_layers, file_format=file_format)
if (backups >= 0):
remove_backups(path, keeps=backups)
return name
|
def load_networks(path: str, net, name=None, *, read_layers: bool=False, file_format=None, verbose=True):
' load network\n ネットを構成するモデルの読み込み\n \n 最新のデータを探して読み込み\n 名前を指定した場合はそれを読み込み\n \n Args:\n path (str) : 読み込むパス\n net (Model) : 読み込むネット\n file_format (str) : 読み込む形式(Noneがデフォルト)\n verbose (bool) : 詳しく表示する\n '
if (name is None):
data_path = get_latest_path(path)
else:
data_path = os.path.join(path, name)
if (data_path is None):
print('not loaded : file not found')
return False
ret = load_models(data_path, net, read_layers=read_layers, file_format=file_format, verbose=verbose)
return ret
|
def get_load_networks_path(path: str, net, name=None):
'ネットワークをロードするパスを取得'
if (name is None):
return get_latest_path(path)
else:
return os.path.join(path, name)
|
def copy_network_files(data_path, dst_name, src_name, wildcard='*', exist_ok=False, verbose=1):
'ネットワークファイルのコピー'
dst_path = os.path.join(data_path, dst_name)
src_name = os.path.join(data_path, src_name)
if os.path.exists(dst_path):
if (not exist_ok):
print(('already exists: %s' % dst_path))
return False
else:
os.makedirs(dst_path, exist_ok=exist_ok)
files = glob.glob(os.path.join(src_name, wildcard))
for file in files:
if (verbose >= 1):
print(file)
shutil.copy(file, dst_path)
return True
|
def get_version_string():
'バージョン文字列取得\n \n Returns:\n version (str) : バージョン文字列\n '
return core.get_version_string()
|
def omp_set_num_threads(threads: int):
'omp_set_num_threads\n \n omp_set_num_threadsを呼び出す\n バックグランドで学習する場合など、Host側のCPUをすべて使うと\n 逆に性能が落ちる場合や、運用上不便なケースなどで個数制限できる\n\n Args:\n threads (int) : OpenMPでのスレッド数\n '
core.omp_set_num_threads(threads)
|
def is_device_available():
'デバイス(GPU)が有効かの確認\n\n Returns:\n device_available (bool) : デバイス(GPU)が利用可能なら True を返す\n '
return core.Manager.is_device_available()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.