def setUp(self):
super(TestNestedFunctionSet, self).setUp()
self.fs1 = chainer.FunctionSet(
a=SimpleLink((1, 2)))
self.fs2 = chainer.FunctionSet(
fs1=self.fs1,
b=SimpleLink((3, 4)))
def __init__(self):
self.state = xp.array([[0.0, 0.0]], dtype=np.float32)
self.next_state = xp.array([[0.0, 0.0]], dtype=np.float32)
self.reward = 0.0
self.action = 0.0
self.critic_model = chainer.FunctionSet(
l1=F.Linear(2, 100),
l2=F.Linear(100, 1, initialW=np.zeros((1, 100), dtype=np.float32)),
)
self.actor_model = chainer.FunctionSet(
l1=F.Linear(2, 100),
l2=F.Linear(100, 1, initialW=np.zeros((1, 100), dtype=np.float32)),
)
if args.gpu >= 0:
self.critic_model.to_gpu()
self.actor_model.to_gpu()
self.critic_optimizer = optimizers.SGD(self.ALPHA)
self.critic_optimizer.setup(self.critic_model)
self.actor_optimizer = optimizers.SGD(self.ALPHA)
self.actor_optimizer.setup(self.actor_model)
self.oldact = 0.0
self.sigma = 10.0
self.limit_action = 5.0
self.min_action = -5.0
self.max_action = 5.0
def __init__(self):
self.init_theta = 0.0
self.init_omega = 0.0
self.episode_time = 10.0
self.hz = 20.0
self.evaluation_freq = 100
self.critic_model = chainer.FunctionSet(
l1=F.Linear(2, 100),
l2=F.Linear(100, 100),
l3=F.Linear(100, 1, initialW=np.zeros((1, 100), dtype=np.float32)),
)
self.target_critic_model = copy.deepcopy(self.critic_model)
self.actor_model = chainer.FunctionSet(
l1=F.Linear(2, 100),
l2=F.Linear(100, 100),
l3=F.Linear(100, 1, initialW=np.zeros((1, 100), dtype=np.float32)),
)
if args.gpu >= 0:
self.critic_model.to_gpu()
self.target_critic_model.to_gpu()
self.actor_model.to_gpu()
# self.critic_optimizer = optimizers.SGD(self.ALPHA)
self.critic_optimizer = optimizers.Adam(self.ALPHA)
self.critic_optimizer.setup(self.critic_model)
# self.actor_optimizer = optimizers.SGD(self.ALPHA)
self.actor_optimizer = optimizers.Adam(self.ALPHA)
self.actor_optimizer.setup(self.actor_model)
#history data : D = [state(theta, omega), action, old_action, reward, next_state(theta, omega), episode_end_flag]
self.D = [
xp.zeros((self.data_size, 1, 2), dtype=xp.float32),
xp.zeros(self.data_size, dtype=xp.float32),
xp.zeros(self.data_size, dtype=xp.float32),
xp.zeros((self.data_size, 1), dtype=xp.float32),
xp.zeros((self.data_size, 1, 2), dtype=xp.float32),
xp.zeros((self.data_size, 1), dtype=np.bool)
]
# print "D : ", self.D
self.D_actor = [
xp.zeros((self.data_size, 1, 2), dtype=xp.float32),
xp.zeros(self.data_size, dtype=xp.float32),
xp.zeros(self.data_size, dtype=xp.float32),
xp.zeros((self.data_size, 1), dtype=xp.float32),
xp.zeros((self.data_size, 1, 2), dtype=xp.float32),
xp.zeros((self.data_size, 1), dtype=np.bool)
]
# print "D_actor : ", self.D_actor
self.sigma = 10.0
self.limit_action = 5.0
self.min_action = -5.0
self.max_action = 5.0
self.data_index_actor = 0
def init_model():
#Make models
if use_pre2 == 'pre': pre_unit = 4
else: pre_unit = 0
if use_null == 'null': null_unit = 6
else: null_unit = 0
if args.phrase == 'phrase':
phrase_unit = 4
model = chainer.FunctionSet(
trainable=chainer.FunctionSet(
w0=F.Linear(n_units * 2 + null_unit * 2, n_label),
ww0=F.Linear(
n_units * 2 + pre_unit + null_unit * 2 + phrase_unit,
n_units + null_unit),
ww1=F.Linear(
n_units * 2 + pre_unit + null_unit * 2 + phrase_unit,
n_units + null_unit),
),
w1_f=F.Linear(n_units * 2 + null_unit * 2,
n_units + null_unit), #source input
w2_f=F.Linear(n_units + null_unit,
n_units * 2 + null_unit * 2), #source output
w1_e=F.Linear(n_units * 2 + null_unit * 2,
n_units + null_unit), #target input
w2_e=F.Linear(n_units + null_unit,
n_units * 2 + null_unit * 2), #target output
embed_f=F.EmbedID(vocab_f['len_vocab'],
n_units), #source word embedding
embed_e=F.EmbedID(vocab_e['len_vocab'],
n_units), #target word embedding
)
else:
model = chainer.FunctionSet(
trainable=chainer.FunctionSet(w0=F.Linear(
n_units * 4 + null_unit * 4, n_label), ),
w1_f=F.Linear(n_units * 2 + null_unit * 2,
n_units + null_unit), #source input
w2_f=F.Linear(n_units + null_unit,
n_units * 2 + null_unit * 2), #source output
w1_e=F.Linear(n_units * 2 + null_unit * 2,
n_units + null_unit), #target input
w2_e=F.Linear(n_units + null_unit,
n_units * 2 + null_unit * 2), #target output
embed_f=F.EmbedID(vocab_f['len_vocab'],
n_units), #source word embedding
embed_e=F.EmbedID(vocab_e['len_vocab'],
n_units), #target word embedding
)
if opt_name == 'SGD':
optimizer = optimizers.SGD(lr=0.02) # (lr=opt_score) # lr=0.01
elif opt_name == 'AdaGrad':
optimizer = optimizers.AdaGrad(lr=0.001) # (lr=opt_score) # lr=0.001
elif opt_name == 'AdaDelta':
optimizer = optimizers.AdaDelta(rho=0.9) # (rho=opt_score) # rho=0.9
elif opt_name == 'Adam':
optimizer = optimizers.Adam(
alpha=0.0001) # (alpha=opt_score) # alpha=0.0001
optimizer.setup(model) # .collect_parameters()
return model, optimizer
def __init__(self):
# self.init_theta = math.pi
self.init_theta = 0.0
self.init_omega = 0.0
self.episode_time = 10.0 * 2.0
self.hz = 10.0 * 2.0
self.evaluation_freq = 100
self.state = xp.array([[self.init_theta, self.init_omega]],
dtype=np.float32)
self.next_state = xp.array([[self.init_theta, self.init_omega]],
dtype=np.float32)
self.reward = 0.0
self.action = 0.0
self.critic_model = chainer.FunctionSet(
l1=F.Linear(2, 1000),
l2=F.Linear(1000, 500),
l3=F.Linear(500, 250),
l4=F.Linear(250, 125),
l5=F.Linear(125, 60),
l6=F.Linear(60, 30),
l7=F.Linear(30, 1, initialW=np.zeros((1, 30), dtype=np.float32)),
)
self.actor_model = chainer.FunctionSet(
l1=F.Linear(2, 1000),
l2=F.Linear(1000, 500),
l3=F.Linear(500, 250),
l4=F.Linear(250, 125),
l5=F.Linear(125, 60),
l6=F.Linear(60, 30),
l7=F.Linear(30, 1, initialW=np.zeros((1, 30), dtype=np.float32)),
)
"""
self.critic_model = chainer.FunctionSet(
l1 = F.Linear(2, 1, initialW=np.zeros((1, 2), dtype=np.float32)),
)
self.actor_model = chainer.FunctionSet(
l1 = F.Linear(2, 1, initialW=np.zeros((1, 2), dtype=np.float32))
)
"""
if args.gpu >= 0:
self.critic_model.to_gpu()
self.actor_model.to_gpu()
self.critic_optimizer = optimizers.SGD(self.ALPHA)
self.critic_optimizer.setup(self.critic_model)
self.actor_optimizer = optimizers.SGD(self.ALPHA_actor)
self.actor_optimizer.setup(self.actor_model)
self.oldact = 0.0
self.limit_action = 5.0
self.min_action = -5.0
self.max_action = 5.0
def setUp(self):
self.fs1 = chainer.FunctionSet(
a=MockFunction((1, 2)))
self.fs2 = chainer.FunctionSet(
fs1=self.fs1,
b=MockFunction((3, 4)))
self.p_b = np.zeros((3, 4)).astype(np.float32)
self.p_a = np.zeros((1, 2)).astype(np.float32)
self.gp_b = np.ones((3, 4)).astype(np.float32)
self.gp_a = np.ones((1, 2)).astype(np.float32)
def define_model(self):
# Model1
self.model = chainer.FunctionSet(l1=F.Linear(784, 1000),
l2=F.Linear(1000, 1000),
l3=F.Linear(1000, 100))
# Model2
self.model2 = chainer.FunctionSet(l1=F.Linear(100, 1000),
l2=F.Linear(1000, 10))
# Assign models to GPU
self.model.to_gpu(GPU1)
self.model2.to_gpu(GPU2)
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, n_units, vocab_in, vocab_out, loadpath=None, gpu=-1):
self.xp = np
self.tagger = igo.tagger.Tagger(self.DIC_DIR)
self.vocab_in = vocab_in
self.vocab_out = vocab_out
self.n_units = n_units
if loadpath:
with open(loadpath, 'rb') as f:
self.model = pickle.load(f)
else:
self.model = chainer.FunctionSet(
embed=F.EmbedID(len(self.vocab_in), n_units),
l1_x=F.Linear(self.n_units, 4 * self.n_units),
l1_h=F.Linear(self.n_units, 4 * self.n_units),
l2_x=F.Linear(self.n_units, 4 * self.n_units),
l2_h=F.Linear(self.n_units, 4 * self.n_units),
l3=F.Linear(self.n_units, len(self.vocab_out)),
)
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
def __init__(self):
self.joint_state = np.zeros((3), dtype=np.float32)
# print self.joint_state
self.action_num = 0
self.reward = 0.0
self.num_state = 0
self.num_step = 0
self.state = 0
self.next_state = 0
self.model = chainer.FunctionSet(
l1 = F.Linear(3, 120),
l2 = F.Linear(120, 80),
l3 = F.Linear(80, 40),
l4 = F.Linear(40, 27, initialW=np.zeros((27, 40), dtype=np.float32)),
)
if args.gpu >= 0:
self.model.to_gpu()
self.optimizer = optimizers.SGD()
self.optimizer.setup(self.model)
self.q_list = chainer.Variable(xp.zeros((1, 27), dtype=xp.float32))
self.action = 0
self.state = 0
self.next_state = 0
self.joint1 = self.init_state_joint1
self.joint3 = self.init_state_joint3
self.joint5 = self.init_state_joint5
self.next_joint1 = self.init_state_joint1
self.next_joint3 = self.init_state_joint3
self.next_joint5 = self.init_state_joint5
def create_model():
model = chainer.FunctionSet(
l1=F.Linear(4, pnum),
l2=F.Linear(pnum, 3),
)
return model
def __init__(self, optimizer):
self.model = chainer.FunctionSet(l=F.Linear(self.UNIT_NUM, 2))
self.optimizer = optimizer
# true parameters
self.w = np.random.uniform(-1, 1,
(self.UNIT_NUM, 1)).astype(np.float32)
self.b = np.random.uniform(-1, 1, (1, )).astype(np.float32)
def __init__(self):
self.joint_state = np.zeros((3), dtype=np.float32)
# print self.joint_state
self.action_num = 0
self.reward = 0.0
self.num_step = 0
self.num_episode = 0
self.model = chainer.FunctionSet(
l1=F.Linear(3, 1024),
l2=F.Linear(1024, 512),
l3=F.Linear(512, 256),
l4=F.Linear(256, 128),
l5=F.Linear(128, 64),
l6=F.Linear(64, 27, initialW=np.zeros((27, 64), dtype=np.float32)),
)
if args.gpu >= 0:
self.model.to_gpu()
self.optimizer = optimizers.SGD()
self.optimizer.setup(self.model)
self.q_list = chainer.Variable(xp.zeros((1, 27), dtype=xp.float32))
self.action = 0
self.joint1 = self.init_state_joint1
self.joint3 = self.init_state_joint3
self.joint5 = self.init_state_joint5
self.next_joint1 = self.init_state_joint1
self.next_joint3 = self.init_state_joint3
self.next_joint5 = self.init_state_joint5
def __init__(self, image):
self.image = image
self.CNNmodel = chainer.FunctionSet(conv1=L.Convolution2D(1, 64, 6),
conv2=L.Convolution2D(64, 256, 6),
conv3=L.Convolution2D(256, 512, 5),
l1=L.Linear(18432, 8192),
l2=L.Linear(8192, 6605))
def set_order(self, encl, decl):
if len(encl) != len(decl):
raise TypeError('Encode/Decode layers mismatch')
self.depth = len(encl)
for (el, dl) in zip(encl, reversed(decl)):
self.sublayer.append(
chainer.FunctionSet(enc=self.model[el], dec=self.model[dl]))
def set_order(encl, decl):
if len(encl) != len(decl):
raise TypeError('Encode/Decode layers mismatch')
#depth = len(encl)
for (el, dl) in zip(encl, reversed(decl)):
submodel = chainer.FunctionSet(enc=model[el], dec=model[dl])
sublayer.append(submodel)
def init_model(vocab_size):
model = chainer.FunctionSet(
embed=F.EmbedID(vocab_size, embed_units),
hidden1=F.Linear(window * embed_units, hidden_units),
output=F.Linear(hidden_units, label_num),
)
opt = optimizers.AdaGrad(lr=learning_rate)
opt.setup(model)
return model, opt
def __init__(self,
emb_dim,
vocab_size,
layers,
suppress_output=False,
lstm=False,
irnn=False,
active=F.relu,
eos_id=0):
"""
Recurrent Neural Network with multiple layers.
in_dim -> layers[0] -> ... -> layers[-1] -> out_dim (optional)
:param int emb_dim: dimension of embeddings
:param int vocab_size: size of vocabulary
:param layers: dimensions of hidden layers
:type layers: list of int
:param bool suppress_output: suppress output
:param bool lstm: whether to use LSTM
:param bool irnn: whether to use IRNN
:param chainer.Function active: activation function between layers of vanilla RNN
:param int eos_id: ID of <BOS> and <EOS>
"""
assert not (lstm and irnn)
self.emb_dim = emb_dim
self.vocab_size = vocab_size
self.layers = layers
self.suppress_output = suppress_output
self.lstm = lstm
self.irnn = irnn
self.active = active
self.eos_id = eos_id
# set up NN architecture
model = chainer.FunctionSet(emb=F.EmbedID(vocab_size, emb_dim), )
# add hidden layers
layer_dims = [emb_dim] + layers
for i in range(len(layers)):
in_dim = layer_dims[i]
out_dim = layer_dims[i + 1]
if lstm:
linear = F.Linear(in_dim, out_dim * 4)
hidden = F.Linear(out_dim, out_dim * 4)
else:
linear = F.Linear(in_dim, out_dim)
hidden = F.Linear(out_dim, out_dim)
if irnn:
# initialize hidden connection with identity matrix
hidden.W = np.eye(out_dim)
setattr(model, 'l{}_x'.format(i + 1), linear)
setattr(model, 'l{}_h'.format(i + 1), hidden)
if not suppress_output:
# add output layer
setattr(model, 'l_y', F.Linear(layer_dims[-1], vocab_size))
self.model = model
def main():
global par
par = 100
dn = 10000
global x_e, h1_e, h2_e, h3_e, h4_e, y_e
k = int(dn / par)
x_e = np.zeros(k)
h1_e = np.zeros(k)
h2_e = np.zeros(k)
h3_e = np.zeros(k)
h4_e = np.zeros(k)
y_e = np.zeros(k)
model = chainer.FunctionSet(conv1=chainer.links.Convolution2D(1, 32, 5),
conv2=chainer.links.Convolution2D(32, 64, 4),
conv3=chainer.links.Convolution2D(64, 128, 3),
fully1=F.Linear(512, 256),
fully2=F.Linear(256, 10))
optimizer = optimizers.SGD()
optimizer.setup(model)
for i in range(dn):
print i
data = mnist.img()
label = mnist.label()
x = chainer.Variable(data.reshape(1, 1, 28, 28).astype(np.float32))
t = chainer.Variable(np.array([label]).reshape(1).astype(np.int32))
y = forward(model, x, i)
optimizer.zero_grads()
loss = F.softmax_cross_entropy(y, t)
loss.backward()
optimizer.update()
print "plotting..."
x = (np.arange(k) + 1) * par
plt.plot(x, x_e / par, label="x")
plt.plot(x, h1_e / par, label="h1")
plt.plot(x, h2_e / par, label="h2")
plt.plot(x, h3_e / par, label="h3")
plt.plot(x, h4_e / par, label="h4")
plt.plot(x, y_e / par, label="y")
plt.legend(loc="lower left")
plt.xlabel("learned data")
plt.ylabel("entropy")
plt.savefig("./fig01.png")
plt.show()
def make_model():
model = chainer.FunctionSet(conv1=F.Convolution2D(3, 32, 2, pad=1),
conv2=F.Convolution2D(32, 32, 2, pad=1),
conv3=F.Convolution2D(32, 32, 2, pad=1),
conv4=F.Convolution2D(32, 32, 2, pad=1),
conv5=F.Convolution2D(32, 32, 2, pad=1),
conv6=F.Convolution2D(32, 32, 2, pad=1),
l1=F.Linear(512, 512),
l2=F.Linear(512, 10))
return model
def setUp(self):
self.fs = chainer.FunctionSet(a=L.Linear(3, 2), b=L.Linear(3, 2))
self.aW = self.fs.a.W.data
self.ab = self.fs.a.b.data
self.bW = self.fs.b.W.data
self.bb = self.fs.b.b.data
self.agW = self.fs.a.W.grad
self.agb = self.fs.a.b.grad
self.bgW = self.fs.b.W.grad
self.bgb = self.fs.b.b.grad
def defineModel(self):
lstm_unit = self.unit_num
self.model = chainer.FunctionSet(
conv=F.Convolution2D(self.input_num,
self.hidden_num, (self.k_w, self.k_h),
pad=0),
line1=F.Linear(self.unit_num, lstm_unit),
lstm=L.LSTM(lstm_unit, lstm_unit),
line2=F.Linear(lstm_unit, self.unit_num),
deconv=L.Deconvolution2D(self.hidden_num,
self.output_num, (self.k_w, self.k_h),
pad=0))
def __init__(self, encoder, decoder):
"""
:param rnn.Rnn encoder: encoder RNN
:param rnn.Rnn decoder: decoder RNN
:return:
"""
assert encoder.suppress_output
assert not decoder.suppress_output
self.encoder = encoder
self.decoder = decoder
self.model = chainer.FunctionSet(encoder=encoder.model,
decoder=decoder.model)
def setUp(self):
self.fs = chainer.FunctionSet(
a=F.Linear(3, 2),
b=F.Linear(3, 2)
)
self.aW = self.fs.a.W
self.ab = self.fs.a.b
self.bW = self.fs.b.W
self.bb = self.fs.b.b
self.agW = self.fs.a.gW
self.agb = self.fs.a.gb
self.bgW = self.fs.b.gW
self.bgb = self.fs.b.gb
def init_model(args):
input_layer = 36
ans_num = 3
model = chainer.FunctionSet(
w1=F.Linear(input_layer, args.hidden), #source input
w2=F.Linear(args.hidden, args.hidden), #hidden
w3=F.Linear(args.hidden, ans_num), #target output
)
optimizer = optimizers.SGD(lr=0.01) # (lr=opt_score) # lr=0.01
#optimizer = optimizers.AdaGrad(lr=0.001)
#optimizer = optimizers.AdaDelta(rho=0.9)
#optimizer = optimizers.Adam(alpha=0.0001)
optimizer.setup(model) # .collect_parameters()
return model, optimizer
def rnn(io_size, fast_hidden_size, slow_hidden_size):
model = chainer.FunctionSet(x_to_fh=F.Linear(io_size, fast_hidden_size),
fh_to_fh=F.Linear(fast_hidden_size,
fast_hidden_size),
fh_to_sh=F.Linear(fast_hidden_size,
slow_hidden_size),
sh_to_fh=F.Linear(slow_hidden_size,
fast_hidden_size),
sh_to_sh=F.Linear(slow_hidden_size,
slow_hidden_size),
fh_to_y=F.Linear(fast_hidden_size, io_size))
for param in model.parameters:
param[:] = np.random.uniform(-0.1, 0.1, param.shape)
return model
def __init__(self):
self.joint_state = np.zeros((3), dtype=np.float32)
self.action_num = 0
self.reward = 0.0
self.target_point = PointCloud()
self.target_init_y = 0.000
# self.target_init_x = 0.680
self.target_init_x = math.sqrt(self.L_2**2 -
self.target_init_y**2) + 0.270
self.target_init_z = 0.900
self.num_step = 0
self.num_episode = 0
self.model = chainer.FunctionSet(
l1=F.Linear(6, 2560),
l2=F.Linear(2560, 1280),
l3=F.Linear(1280, 640),
l4=F.Linear(640, 320),
l5=F.Linear(320, 160),
l6=F.Linear(160, 80),
l7=F.Linear(80, 27, initialW=np.zeros((27, 80), dtype=np.float32)),
)
self.model_target = copy.deepcopy(self.model)
if args.gpu >= 0:
self.model.to_gpu()
self.model_target.to_gpu()
self.optimizer = optimizers.SGD(self.ALPHA)
self.optimizer.setup(self.model)
self.q_list = chainer.Variable(xp.zeros((1, 27), dtype=xp.float32))
self.action = 0
self.joint1 = self.init_joint1
self.joint2 = self.init_joint2
self.joint3 = self.init_joint3
self.next_joint1 = self.init_next_joint1
self.next_joint2 = self.init_next_joint2
self.next_joint3 = self.init_next_joint3
# history data : D = [s(joint1, joint2, joint3, goal_x, goal_y, goal_z), a, reward, s_dash(joint1', joint2', joint3', x_goal, y_goal, z_goal), end_episode_flag]
self.D = [
xp.zeros((self.data_size, 1, 6), dtype=xp.float32),
xp.zeros(self.data_size, dtype=xp.uint8),
xp.zeros((self.data_size, 1), dtype=xp.float32),
xp.zeros((self.data_size, 1, 6), dtype=xp.float32),
xp.zeros((self.data_size, 1), dtype=np.bool)
]
def _create_and_initialize_model(self, tags, vocab):
# The model is feed-forward LSTM:
# (word_id -> word_emb)_t -> LSTM -> (distribution over tag_id)_t
self.model = chainer.FunctionSet()
self.model.embed = F.EmbedID(len(vocab), self.n_lstm_cells)
self.model.lstm_x_to_h = F.Linear(self.n_lstm_cells,
4 * self.n_lstm_cells)
self.model.lstm_h_to_h = F.Linear(self.n_lstm_cells,
4 * self.n_lstm_cells)
self.model.yclf = F.Linear(self.n_lstm_cells, len(tags))
# Randomly initialize the parameters.
for param in self.model.parameters:
param[:] = np.random.uniform(-0.1, 0.1, param.shape)
def init_model(vocab_size, char_type_size):
model = chainer.FunctionSet(
embed=F.EmbedID(vocab_size, embed_units),
char_type_embed = F.EmbedID(char_type_size, char_type_embed_units),
hidden1=F.Linear(window * (embed_units + char_type_embed_units) + hidden_units, hidden_units),
i_gate=F.Linear(window * (embed_units + char_type_embed_units) + hidden_units, hidden_units),
f_gate=F.Linear(window * (embed_units + char_type_embed_units) + hidden_units, hidden_units),
o_gate=F.Linear(window * (embed_units + char_type_embed_units) + hidden_units, hidden_units),
output=F.Linear(hidden_units, label_num),
)
#opt = optimizers.AdaGrad(lr=learning_rate)
#opt = optimizers.SGD()
opt = optimizers.Adam()
opt.setup(model)
return model, opt
def __init__(self):
self.joint_state = np.zeros((3), dtype=np.float32)
# print self.joint_state
self.action_num = 0
self.reward = 0.0
self.target_point = PointCloud()
self.target_init_x = 0.91
self.target_init_y = 0.00
self.target_init_z = 0.84
self.num_state = 0
self.num_step = 0
self.num_episode = 0
self.state = 0
self.next_state = 0
self.model = chainer.FunctionSet(
l1 = F.Linear(6, 1536),
l2 = F.Linear(1536, 768),
l3 = F.Linear(768, 384),
l4 = F.Linear(384, 192),
l5 = F.Linear(192, 96),
l6 = F.Linear(96, 27, initialW=np.zeros((27, 96), dtype=np.float32)),
)
if args.gpu >= 0:
self.model.to_gpu()
# self.optimizer = optimizers.RMSpropGraves(lr=0.00025, alpha=0.95, momentum=0.95, eps=0.0001)
self.optimizer = optimizers.SGD()
self.optimizer.setup(self.model)
self.q_list = chainer.Variable(xp.zeros((1, 27), dtype=xp.float32))
self.action = 0
self.state = 0
self.next_state = 0
self.joint1 = self.init_state_joint1
self.joint3 = self.init_state_joint3
self.joint5 = self.init_state_joint5
self.next_joint1 = self.init_state_joint1
self.next_joint3 = self.init_state_joint3
self.next_joint5 = self.init_state_joint5
