def __init__(self):
super(GoogLeNet,
self).__init__(conv1=F.Convolution2D(3, 64, 7, stride=2, pad=3),
conv2_reduce=F.Convolution2D(64, 64, 1),
conv2=F.Convolution2D(64, 192, 3, stride=1,
pad=1),
inc3a=F.Inception(192, 64, 96, 128, 16, 32, 32),
inc3b=F.Inception(256, 128, 128, 192, 32, 96, 64),
inc4a=F.Inception(480, 192, 96, 208, 16, 48, 64),
inc4b=F.Inception(512, 160, 112, 224, 24, 64, 64),
inc4c=F.Inception(512, 128, 128, 256, 24, 64, 64),
inc4d=F.Inception(512, 112, 144, 288, 32, 64, 64),
inc4e=F.Inception(528, 256, 160, 320, 32, 128,
128),
inc5a=F.Inception(832, 256, 160, 320, 32, 128,
128),
inc5b=F.Inception(832, 384, 192, 384, 48, 128,
128),
loss3_fc=F.Linear(1024, 1000),
loss1_conv=F.Convolution2D(512, 128, 1),
loss1_fc1=F.Linear(4 * 4 * 128, 1024),
loss1_fc2=F.Linear(1024, 1000),
loss2_conv=F.Convolution2D(528, 128, 1),
loss2_fc1=F.Linear(4 * 4 * 128, 1024),
loss2_fc2=F.Linear(1024, 1000))
def __init__(self):
w = math.sqrt(2)
super(CNN4, self).__init__(
conv1=F.Convolution2D(1,
24,
7,
wscale=w,
stride=3,
dtype=np.float32),
conv2=F.Convolution2D(24,
48,
5,
wscale=w,
stride=2,
dtype=np.float32),
conv3=F.Convolution2D(48,
96,
5,
wscale=w,
stride=1,
dtype=np.float32),
conv4=F.Convolution2D(96,
144,
5,
wscale=w,
stride=1,
dtype=np.float32),
ln4=F.Linear(144, 3),
)
def __init__(self):
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)))
self.model.l1.W = np.load('elite/l1_W.npy')
self.model.l1.b = np.load('elite/l1_b.npy')
self.model.l2.W = np.load('elite/l2_W.npy')
self.model.l2.b = np.load('elite/l2_b.npy')
self.model.l3.W = np.load('elite/l3_W.npy')
self.model.l3.b = np.load('elite/l3_b.npy')
def __init__(self,
n_in,
n_out,
ksize,
stride=1,
pad=0,
wscale=1,
bias=0,
nobias=False):
super(ConvolutionalAutoencoder,
self).__init__(encoder=F.Convolution2D(n_in,
n_out,
ksize,
stride=stride,
pad=pad,
wscale=wscale,
bias=bias,
nobias=nobias),
decoder=F.Convolution2D(n_out,
n_in,
ksize,
stride=stride,
pad=pad,
wscale=wscale,
bias=bias,
nobias=nobias))
def __init__(self,n_act):
N_output = n_act
self.model = FunctionSet(
conv1=F.Convolution2D(1, 16, 3, pad=1),
conv2=F.Convolution2D(16, 16, 3, pad=1),
l1=F.Linear(1024, 256),
l2=F.Linear(256, N_output))
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,
wscale=np.sqrt(2)))
if on_gpu:
self.to_gpu()
def __init__(self, output_dim):
super(C2fc2, self).__init__(
#Convolution2D(入力チャンネル数,出力チャンネル数,カーネルサイズ)
conv1=F.Convolution2D(1, 32, 5, pad=2),
conv2=F.Convolution2D(32, 64, 5, pad=2),
#Linear(入力次元,出力次元)
fc1=F.Linear(3136, 512),
fc2=F.Linear(512, output_dim))
def __init__(self):
super(SiameseNetwork, self).__init__(
conv1=F.Convolution2D(1, 20, ksize=5, stride=1),
conv2=F.Convolution2D(20, 50, ksize=5, stride=1),
fc3=F.Linear(800, 500),
fc4=F.Linear(500, 10),
fc5=F.Linear(10, 2),
)
def __init__(self, data_dim, output_dim):
self.data_dim = data_dim
self.output_dim = output_dim
super(tsCNN_net_multi,
self).__init__(conv1=F.Convolution2D(1, 20, (1, 5)),
conv2=F.Convolution2D(20, 50, (1, 5)),
l1=L.Linear(250, 500),
l2=L.Linear(500, self.output_dim))
def __init__(self):
super(clf_bake, self).__init__(
conv1=F.Convolution2D(3, 16, 5, pad=2),
conv2=F.Convolution2D(16, 32, 5, pad=2),
l3=F.Linear(6272, 256),
l4=F.Linear(256, 10) #10 class classification
)
def __init__(self, n_history, n_act):
super(ActionValue, self).__init__(
l1=F.Convolution2D(n_history, 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, n_act,
initialW=0.0*np.random.randn(n_act, 512).astype(np.float32))
)
def __init__(self, input_size=32):
super(CNN3_Model, self).__init__()
# F.Convolution2D(in_channel, out_channel, filter_size)
self.model = FunctionSet( # 1*32*32 -(conv)-> 20*28*28 -(pool)-> 20*14*14
conv1=F.Convolution2D(1, 20, 5),
# 20*14*14 -(conv)-> 50*10*10 -(pool)-> 50*5*5=1250
conv2=F.Convolution2D(20, 50, 5),
l1=F.Linear(1250, 300),
l2=F.Linear(300, 2))
def __init__(self):
super(CalibNet48, self).__init__(
conv1=F.Convolution2D(3, 64, ksize=4, stride=1),
ln1=F.LocalResponseNormalization(n=9),
conv2=F.Convolution2D(64, 64, ksize=4, stride=1),
ln2=F.LocalResponseNormalization(n=9),
fc1=F.Linear(23104, 256),
fc2=F.Linear(256, 45), ## 384 = 256 + 128
)
def __init__(self):
super(myNet, self).__init__(
conv1=F.Convolution2D(1, 20, 5),
norm1=F.BatchNormalization(20),
conv2=F.Convolution2D(20, 50, 5),
norm2=F.BatchNormalization(50),
ip1=F.Linear(4050, 1000),
ip2=F.Linear(1000, 799),
)
self.train = True
def __init__(self):
super(FaceNet48, self).__init__(
net24 = FaceNet24(),
conv1=F.Convolution2D(3, 64, ksize=4, stride=1),
ln1=F.LocalResponseNormalization(n=9),
conv2=F.Convolution2D(64,64, ksize=4, stride=1),
ln2=F.LocalResponseNormalization(n=9),
fc1=F.Linear(5184, 256),
fc2=F.Linear(384, 2), ## 384 = 256 + 128
)
def __init__(self, output_dim):
super(C3fc2, self).__init__(
#Convolution2D(入力チャンネル数,出力チャンネル数,カーネルサイズ)
conv1 = F.Convolution2D(3, 32, 5, pad=2),
conv2 = F.Convolution2D(32, 32, 5, pad=2),
conv3 = F.Convolution2D(32, 32, 5, pad=2),
#Linear(入力次元,出力次元)
fc1 = F.Linear(8192, 2048),
fc2 = F.Linear(2048, output_dim)
)
def __init__(self):
super(AlexNet_mpii, self).__init__(
conv1=F.Convolution2D(3, 96, 11, stride=4, pad=1),
conv2=F.Convolution2D(96, 256, 5, stride=1, pad=2),
conv3=F.Convolution2D(256, 384, 3, stride=1, pad=1),
conv4=F.Convolution2D(384, 384, 3, stride=1, pad=1),
conv5=F.Convolution2D(384, 256, 3, stride=1, pad=1),
fc6=F.Linear(9216, 4096),
fc7=F.Linear(4096, 4096),
fc8=F.Linear(4096, 32)
)
def __init__(self):
super(Overfeat, self).__init__(
conv1=F.Convolution2D(3, 96, 11, stride=4),
conv2=F.Convolution2D(96, 256, 5),
conv3=F.Convolution2D(256, 512, 3, pad=1),
conv4=F.Convolution2D(512, 1024, 3, pad=1),
conv5=F.Convolution2D(1024, 1024, 3, pad=1),
fc6=F.Linear(36864, 3072),
fc7=F.Linear(3072, 4096),
fc8=F.Linear(4096, 1000)
)
def __init__(self):
super(Alex, self).__init__(
conv1=F.Convolution2D(3, 64, 11, stride=4),
conv2=F.Convolution2D(64, 192, 5, pad=2),
conv3=F.Convolution2D(192, 384, 3, pad=1),
conv4=F.Convolution2D(384, 256, 3, pad=1),
conv5=F.Convolution2D(256, 256, 3, pad=1),
fc6=F.Linear(256 * 6 * 6, 4096),
fc7=F.Linear(4096, 4096),
fc8=F.Linear(4096, 1000),
)
def __init__(self):
super(MLP, self).__init__(
c1=F.Convolution2D(3, 32, 3,
pad=1), # color, features, filter size
c2=F.Convolution2D(32, 32, 3,
pad=1), # color, features, filter size
l1=F.Linear(32 * 10 * 10, 1000),
l2=F.Linear(1000, 100),
l3=F.Linear(100, 100),
l4=F.Linear(100, len(y_uniq)))
self.Train = True
self.DropRatio = 0.5
def __init__(self):
super(VGG_mini, self).__init__(conv1_1=F.Convolution2D(3,
64,
3,
stride=1,
pad=1),
conv1_2=F.Convolution2D(64,
256,
3,
stride=1,
pad=1),
fc=F.Linear(16384, 10))
def __init__(self, enable_controller=[0, 3, 4]):
self.num_of_actions = len(enable_controller)
self.enable_controller = enable_controller # Default setting : "Pong"
print "Initializing DQN..."
# 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()
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]
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)
]
def __init__(self, enable_controller=[0, 3, 4]):
self.num_of_actions = len(enable_controller)
self.enable_controller = enable_controller # Default setting : "Pong"
print "Initializing DQN..."
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()
self.model.l1.W = np.load('elite/l1_W.npy')
self.model.l1.b = np.load('elite/l1_b.npy')
self.model.l2.W = np.load('elite/l2_W.npy')
self.model.l2.b = np.load('elite/l2_b.npy')
self.model.l3.W = np.load('elite/l3_W.npy')
self.model.l3.b = np.load('elite/l3_b.npy')
self.model.l4.W = np.load('elite/l4_W.npy')
self.model.l4.b = np.load('elite/l4_b.npy')
self.model.q_value.W = np.load('elite/q_value_W.npy')
self.model.q_value.b = np.load('elite/q_value_b.npy')
self.model_target = copy.deepcopy(self.model)
# History Data : D=[s, a, r, s_dash, end_episode_flag]
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)
]
def __init__(self):
super(VGG, self).__init__(
conv1=F.Convolution2D(3, 96, 7, stride=2, pad=0),
conv2=F.Convolution2D(96, 256, 5, stride=2, pad=1),
conv3=F.Convolution2D(256, 512, 3, stride=1, pad=1),
conv4=F.Convolution2D(512, 512, 3, stride=1, pad=1),
conv5=F.Convolution2D(512, 512, 3, stride=1, pad=1),
fc6=F.Linear(4608, 4096),
fc7=F.Linear(4096, 1024),
cls_score=F.Linear(4096, 21),
bbox_pred=F.Linear(4096, 84)
)
def __init__(self):
super(AlexNet_flic_BN, self).__init__(
conv1=F.Convolution2D(3, 96, 11, stride=4, pad=1),
bn1=F.BatchNormalization(96),
conv2=F.Convolution2D(96, 256, 5, stride=1, pad=2),
bn2=F.BatchNormalization(256),
conv3=F.Convolution2D(256, 384, 3, stride=1, pad=1),
conv4=F.Convolution2D(384, 384, 3, stride=1, pad=1),
conv5=F.Convolution2D(384, 256, 3, stride=1, pad=1),
fc6=F.Linear(9216, 4096),
fc7=F.Linear(4096, 4096),
fc8=F.Linear(4096, 14)
)
def __init__(self):
super(CaffeNet, self).__init__(
conv1=F.Convolution2D(3, 96, 11, stride=4, pad=5),
bn1=F.BatchNormalization(96),
conv2=F.Convolution2D(96, 256, 5, stride=1, pad=2),
bn2=F.BatchNormalization(256),
conv3=F.Convolution2D(256, 384, 3, stride=1, pad=1),
conv4=F.Convolution2D(384, 384, 3, stride=1, pad=1),
conv5=F.Convolution2D(384, 256, 3, stride=1, pad=1),
fc6=F.Linear(9216, 4096),
fc7=F.Linear(4096, 4096),
cls_score=F.Linear(4096, 21),
bbox_pred=F.Linear(4096, 84)
)
def __init__(self, batchsize, use_cudnn):
super(Overfeat, self).__init__(
conv1=F.Convolution2D(3, 96, 11, stride=4, use_cudnn=use_cudnn),
conv2=F.Convolution2D(96, 256, 5, use_cudnn=use_cudnn),
conv3=F.Convolution2D(256, 512, 3, pad=1, use_cudnn=use_cudnn),
conv4=F.Convolution2D(512, 1024, 3, pad=1, use_cudnn=use_cudnn),
conv5=F.Convolution2D(1024, 1024, 3, pad=1, use_cudnn=use_cudnn),
fc6=F.Linear(36864, 3072),
fc7=F.Linear(3072, 4096),
fc8=F.Linear(4096, 1000)
)
self.use_cudnn = use_cudnn
if batchsize is not None:
self.batchsize = batchsize
def main():
if P.use_mean_var:
conv6_output = 126
else:
conv6_output = 128
if P.model_name is None:
model = FunctionSet(conv1=F.Convolution2D(1, 128, 3, stride=1),
conv2=F.Convolution2D(128, 128, 3, stride=1),
conv3=F.Convolution2D(128, 128, 3, stride=1),
conv4=F.Convolution2D(128, 128, 3, stride=1),
conv5=F.Convolution2D(128, 128, 3, stride=1),
conv6=F.Convolution2D(128,
conv6_output,
3,
stride=1),
conv7=F.Convolution2D(128, 128, 1, stride=1),
conv8=F.Convolution2D(128, 1, 1, stride=1))
if P.gpu >= 0:
cuda.init(P.gpu)
model.to_gpu()
else:
if P.gpu >= 0:
cuda.init(P.gpu)
model = pickle.load(open(os.path.join(P.model_dir, P.model_name),
'rb'))
optimizer = optimizers.MomentumSGD(lr=P.lr, momentum=P.momentum)
optimizer.setup(model.collect_parameters())
train(model, optimizer)
return
def define_model(self):
# Model1
self.model = chainer.FunctionSet(conv1=F.Convolution2D(1, 20, 5),
conv2=F.Convolution2D(20, 50, 5),
l1=F.Linear(200, 1000),
l2=F.Linear(1000, 1000))
# Model2
self.model2 = chainer.FunctionSet(l1=F.Linear(1000, 10000),
l2=F.Linear(10000, 10))
# Assign models to GPU
self.model.to_gpu(GPU1)
self.model2.to_gpu(GPU2)
def __init__(self):
super(MLP, self).__init__(
conv1=F.Convolution2D(1, 30, 5,
stride=1), # 入力3 枚、出力30枚、フィルタサイズ5ピクセル
conv2=F.Convolution2D(30, 30, 6,
stride=1), # 入力30>枚、出力30枚、フィルタサイズ5ピクセル
conv3=F.Convolution2D(30, 30, 5,
stride=1), # 入力30>枚、出力30枚、フィルタサイズ6ピクセル
conv4=F.Convolution2D(30, 30, 5,
stride=1), # 入力30>枚、出力30枚、フィルタサイズ5ピクセル
conv5=F.Convolution2D(30, 30, 6,
stride=1), # 入力30>枚、出力30枚、フィルタサイズ6ピクセル
l1=F.Linear(None, 500), # 入力960ユニット、出力500ユニット
l2=F.Linear(500, 20), # 入力500ユニット、出力3ユニット
l3=F.Linear(20, 3))
