Python chainer.functions 模块，Convolution2D() 实例源码

def __init__(self, n_history, n_action, on_gpu=False):
        self.n_history = n_history
        self.n_action = n_action
        self.on_gpu = on_gpu
        super(Q, self).__init__(
            l1=F.Convolution2D(n_history, 32, ksize=8, stride=4, nobias=False, wscale=np.sqrt(2)),
            l2=F.Convolution2D(32, 64, ksize=3, stride=2, nobias=False, wscale=np.sqrt(2)),
            l3=F.Convolution2D(64, 64, ksize=3, stride=1, nobias=False, wscale=np.sqrt(2)),
            l4=F.Linear(3136, 512, wscale=np.sqrt(2)),
            out=F.Linear(512, self.n_action, initialW=np.zeros((n_action, 512), dtype=np.float32))
        )
        if on_gpu:
            self.to_gpu()

def testplot_p4(im=None, r=0):
    if im is None:
        im = np.zeros((5, 5), dtype='float32')
        im[0:5, 1] = 1.
        im[0, 1:4] = 1.
        im[2, 1:3] = 1.

    from groupy.gfunc.z2func_array import Z2FuncArray
    from groupy.garray.C4_array import C4Array
    def rotate_z2_func(im, r):
        imf = Z2FuncArray(im)
        rot = C4Array([r], 'int')
        rot_imf = rot * imf
        return rot_imf.v

    im = rotate_z2_func(im, r)

    filter1 = np.array([[-1., 0., 1.],
                        [-2., 0., 2.],
                        [-1., 0., 1.]]).astype(np.float32)
    filter2 = rotate_z2_func(filter1, 1)
    filter3 = rotate_z2_func(filter1, 2)
    filter4 = rotate_z2_func(filter1, 3)

    from chainer.functions import Convolution2D
    from chainer import Variable
    im = im.astype(np.float32)
    pad = 2
    imf1 = Convolution2D(in_channels=1, out_channels=1, ksize=3, bias=0., pad=pad, initialW=filter1)(
        Variable(im[None, None])).data[0, 0]
    imf2 = Convolution2D(in_channels=1, out_channels=1, ksize=3, bias=0., pad=pad, initialW=filter2)(
        Variable(im[None, None])).data[0, 0]
    imf3 = Convolution2D(in_channels=1, out_channels=1, ksize=3, bias=0., pad=pad, initialW=filter3)(
        Variable(im[None, None])).data[0, 0]
    imf4 = Convolution2D(in_channels=1, out_channels=1, ksize=3, bias=0., pad=pad, initialW=filter4)(
        Variable(im[None, None])).data[0, 0]

    return im, np.r_[[imf1, imf2, imf3, imf4]]

def __init__(self, num_blocks=18, nc32=6, nc16=11, nc8=23):
        """
        :param num_blocks: the number of resnet blocks per stage. There are 3 stages, for feature map width 32, 16, 8.
        Total number of layers is 6 * num_blocks + 2
        :param nc32: the number of feature maps in the first stage (where feature maps are 32x32)
        :param nc16: the number of feature maps in the second stage (where feature maps are 16x16)
        :param nc8: the number of feature maps in the third stage (where feature maps are 8x8)
        """
        ksize = 3
        pad = 1
        ws = sqrt(2.)  # This makes the initialization equal to that of He et al.

        super(P4MResNet, self).__init__()

        # The first layer is always a convolution.
        self.add_link(
            P4MConvZ2(in_channels=3, out_channels=nc32, ksize=ksize, stride=1, pad=pad, wscale=ws)
        )

        # Add num_blocks ResBlocks (2 * num_blocks layers) for the size 32x32 feature maps
        for i in range(num_blocks):
            self.add_link(
                ResBlock2D(
                    in_channels=nc32, out_channels=nc32, ksize=ksize,
                    fiber_map='id', conv_link=P4MConvP4M, stride=1, pad=pad, wscale=ws
                )
            )

        # Add num_blocks ResBlocks (2 * num_blocks layers) for the size 16x16 feature maps
        # The first convolution uses stride 2
        for i in range(num_blocks):
            stride = 1 if i > 0 else 2
            fiber_map = 'id' if i > 0 else 'linear'
            nc_in = nc16 if i > 0 else nc32
            self.add_link(
                ResBlock2D(
                    in_channels=nc_in, out_channels=nc16, ksize=ksize,
                    fiber_map=fiber_map, conv_link=P4MConvP4M, stride=stride, pad=pad, wscale=ws
                )
            )

        # Add num_blocks ResBlocks (2 * num_blocks layers) for the size 8x8 feature maps
        # The first convolution uses stride 2
        for i in range(num_blocks):
            stride = 1 if i > 0 else 2
            fiber_map = 'id' if i > 0 else 'linear'
            nc_in = nc8 if i > 0 else nc16
            self.add_link(
                ResBlock2D(
                    in_channels=nc_in, out_channels=nc8, ksize=ksize,
                    fiber_map=fiber_map, conv_link=P4MConvP4M, stride=stride, pad=pad, wscale=ws
                )
            )

        # Add BN and final layer
        # We do ReLU and average pooling between BN and final layer,
        # but since these are stateless they don't require a Link.
        self.add_link(F.BatchNormalization(size=nc8))
        self.add_link(F.Convolution2D(in_channels=nc8 * 8, out_channels=10, ksize=1, stride=1, pad=0, wscale=ws))

def __init__(self):
        ksize = 3
        bn = True
        act = F.relu
        self.dr = 0.3
        super(Z2CNN, self).__init__(

            l1=ConvBNAct(
                conv=F.Convolution2D(in_channels=1, out_channels=20, ksize=ksize, stride=1, pad=0),
                bn=bn,
                act=act
            ),

            l2=ConvBNAct(
                conv=F.Convolution2D(in_channels=20, out_channels=20, ksize=ksize, stride=1, pad=0),
                bn=bn,
                act=act
            ),

            l3=ConvBNAct(
                conv=F.Convolution2D(in_channels=20, out_channels=20, ksize=ksize, stride=1, pad=0),
                bn=bn,
                act=act
            ),

            l4=ConvBNAct(
                conv=F.Convolution2D(in_channels=20, out_channels=20, ksize=ksize, stride=1, pad=0),
                bn=bn,
                act=act
            ),

            l5=ConvBNAct(
                conv=F.Convolution2D(in_channels=20, out_channels=20, ksize=ksize, stride=1, pad=0),
                bn=bn,
                act=act
            ),

            l6=ConvBNAct(
                conv=F.Convolution2D(in_channels=20, out_channels=20, ksize=ksize, stride=1, pad=0),
                bn=bn,
                act=act
            ),

            top=F.Convolution2D(in_channels=20, out_channels=10, ksize=4, stride=1, pad=0),
        )

def __init__(self, enable_controller=[0, 1, 3, 4]):
        self.num_of_actions = len(enable_controller)
        self.enable_controller = enable_controller  # Default setting : "Breakout"

        print "Initializing DDQN..."
#   Initialization of Chainer 1.1.0 or older.
#        print "CUDA init"
#        cuda.init()

        print "Model Building"
        self.model = FunctionSet(
            l1=F.Convolution2D(4, 32, ksize=8, stride=4, nobias=False, wscale=np.sqrt(2)),
            l2=F.Convolution2D(32, 64, ksize=4, stride=2, nobias=False, wscale=np.sqrt(2)),
            l3=F.Convolution2D(64, 64, ksize=3, stride=1, nobias=False, wscale=np.sqrt(2)),
            l4=F.Linear(3136, 512, wscale=np.sqrt(2)),
            q_value=F.Linear(512, self.num_of_actions,
                             initialW=np.zeros((self.num_of_actions, 512),
                                               dtype=np.float32))
        ).to_gpu()

        if args.resumemodel:
            # load saved model
            serializers.load_npz(args.resumemodel, self.model)
            print "load model from resume.model"


        self.model_target = copy.deepcopy(self.model)

        print "Initizlizing Optimizer"
        self.optimizer = optimizers.RMSpropGraves(lr=0.00025, alpha=0.95, momentum=0.95, eps=0.0001)
        self.optimizer.setup(self.model.collect_parameters())

        # History Data :  D=[s, a, r, s_dash, end_episode_flag]
        if args.resumeD1 and args.resumeD2:
            # load saved D1 and D2
            npz_tmp1 = np.load(args.resumeD1)
            npz_tmp2 = np.load(args.resumeD2)
            self.D = [npz_tmp1['D0'],
                      npz_tmp1['D1'],
                      npz_tmp1['D2'],
                      npz_tmp2['D3'],
                      npz_tmp2['D4']]
            npz_tmp1.close()
            npz_tmp2.close()
            print "loaded stored D1 and D2"
        else:
            self.D = [np.zeros((self.data_size, 4, 84, 84), dtype=np.uint8),
                      np.zeros(self.data_size, dtype=np.uint8),
                      np.zeros((self.data_size, 1), dtype=np.int8),
                      np.zeros((self.data_size, 4, 84, 84), dtype=np.uint8),
                      np.zeros((self.data_size, 1), dtype=np.bool)]
            print "initialize D data"