예제 #1
0
    def build(input_shape, num_outputs, block_type, repetitions):
        '''ResNet モデルを作成する Factory クラス

        Arguments:
            input_shape: 入力の形状
            num_outputs: ネットワークの出力数
            block_type : residual block の種類 ('basic' or 'bottleneck')
            repetitions: 同じ residual block を何個反復させるか
        '''
        # block_type に応じて、residual block を生成する関数を選択する。
        if block_type == 'basic':
            block_fn = basic_block
        elif block_type == 'bottleneck':
            block_fn = bottleneck_block

        # モデルを作成する。
        ##############################################
        input = Input(shape=input_shape)

        # conv1 (batch normalization -> ReLU -> conv)
        conv1 = compose(
            ResNetConv2D(filters=64,
                         kernel_size=(7, 7),
                         strides=(2, 2),
                         name="7x7_conv_64_/2"),
            BatchNormalization(),
            Activation('relu'),
        )(input)

        # pool
        pool1 = MaxPooling2D(pool_size=(3, 3),
                             strides=(2, 2),
                             padding='same',
                             name="pool_/2")(conv1)

        # conv2_x, conv3_x, conv4_x, conv5_x
        block = pool1
        filters = 64
        for i, r in enumerate(repetitions):
            block = residual_blocks(block_fn,
                                    filters=filters,
                                    repetitions=r,
                                    is_first_layer=(i == 0))(block)
            filters *= 2

        # batch normalization -> ReLU
        block = compose(BatchNormalization(), Activation('relu'))(block)

        # global average pooling
        pool2 = GlobalAveragePooling2D(name="avg_pool")(block)

        # dense
        fc1 = Dense(units=num_outputs,
                    kernel_initializer='he_normal',
                    activation='softmax',
                    name="fc")(pool2)

        return Model(inputs=input, outputs=fc1)
예제 #2
0
def table(M):
    n = len(M)
    M = list(M)
    T = [[-1 for x in range(n)] for x in xrange(n)]
    for i, a in enumerate(M):
        for j, b in enumerate(M):
            T[i][j] = M.index(funcs.compose(a, b))
    return T
예제 #3
0
def table(M):
  n = len(M)
  M = list(M)
  T = [[-1 for x in range(n)] for x in xrange(n)]
  for i, a in enumerate(M):
    for j, b in enumerate(M):
      T[i][j] = M.index( funcs.compose(a,b) )
  return T
예제 #4
0
def generate(perms):
    grp = set(perms)
    while True:
        n = len(grp)
        for (a, b) in itertools.product(grp, grp):
            grp.add(funcs.compose(a, b))
        if len(grp) == n:
            break
    return grp
예제 #5
0
def generate(perms):
  grp = set(perms)
  while True:
    n = len(grp)
    for (a,b) in itertools.product(grp, grp):
      grp.add( funcs.compose(a,b) )
    if len(grp) == n:
      break
  return grp
예제 #6
0
from funcs import compose, pipe

if __name__ == '__main__':
    ff = compose(lambda a: a + 1, lambda a: a * 1000, lambda a: a - 10)
    print(ff(11))
    ff = pipe(lambda a: a + 1, lambda a: a * 1000, lambda a: a - 10)
    print(ff(11))
예제 #7
0
def isAbelian(M):
    for a, b in itertools.combinations(M, 2):
        if funcs.compose(a, b) != funcs.compose(b, a):
            return False
    return True
예제 #8
0
def isAbelian(M):
  for a, b in itertools.combinations(M, 2):
    if funcs.compose(a,b) != funcs.compose(b,a):
      return False
  return True