class TestFunctionSet(TestCase):
def setUp(self):
self.fs = FunctionSet(
a = Linear(3, 2),
b = Linear(3, 2)
)
def test_get_sorted_funcs(self):
self.assertItemsEqual([k for (k, v) in self.fs._get_sorted_funcs()], ('a', 'b'))
def check_equal_fs(self, fs1, fs2):
self.assertTrue((fs1.a.W == fs2.a.W).all())
self.assertTrue((fs1.a.b == fs2.a.b).all())
self.assertTrue((fs1.b.W == fs2.b.W).all())
self.assertTrue((fs1.b.b == fs2.b.b).all())
def test_pickle_cpu(self):
s = pickle.dumps(self.fs)
fs2 = pickle.loads(s)
self.check_equal_fs(self.fs, fs2)
@attr.gpu
def test_pickle_gpu(self):
self.fs.to_gpu()
s = pickle.dumps(self.fs)
fs2 = pickle.loads(s)
self.fs.to_cpu()
fs2.to_cpu()
self.check_equal_fs(self.fs, fs2)
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
class TestFunctionSet(TestCase):
def setUp(self):
self.fs = FunctionSet(a=Linear(3, 2), b=Linear(3, 2))
def test_get_sorted_funcs(self):
assertCountEqual(self, [k for (k, v) in self.fs._get_sorted_funcs()],
('a', 'b'))
def check_equal_fs(self, fs1, fs2):
self.assertTrue((fs1.a.W == fs2.a.W).all())
self.assertTrue((fs1.a.b == fs2.a.b).all())
self.assertTrue((fs1.b.W == fs2.b.W).all())
self.assertTrue((fs1.b.b == fs2.b.b).all())
def test_pickle_cpu(self):
s = pickle.dumps(self.fs)
fs2 = pickle.loads(s)
self.check_equal_fs(self.fs, fs2)
@attr.gpu
def test_pickle_gpu(self):
self.fs.to_gpu()
s = pickle.dumps(self.fs)
fs2 = pickle.loads(s)
self.fs.to_cpu()
fs2.to_cpu()
self.check_equal_fs(self.fs, fs2)
class TestFunctionSet(TestCase):
def setUp(self):
self.fs = FunctionSet(
a = Linear(3, 2),
b = Linear(3, 2)
)
def check_equal_fs(self, fs1, fs2):
self.assertTrue((fs1.a.W == fs2.a.W).all())
self.assertTrue((fs1.a.b == fs2.a.b).all())
self.assertTrue((fs1.b.W == fs2.b.W).all())
self.assertTrue((fs1.b.b == fs2.b.b).all())
def test_pickle_cpu(self):
s = pickle.dumps(self.fs)
fs2 = pickle.loads(s)
self.check_equal_fs(self.fs, fs2)
def test_pickle_gpu(self):
self.fs.to_gpu()
s = pickle.dumps(self.fs)
fs2 = pickle.loads(s)
self.fs.to_cpu()
fs2.to_cpu()
self.check_equal_fs(self.fs, fs2)
def init_model(model_params):
wscale1 = model_params.wscale1 # math.sqrt(5 * 5 * 3) * 0.0001
wscale2 = model_params.wscale2 # math.sqrt(5 * 5 * 32) * 0.01
wscale3 = model_params.wscale3 # math.sqrt(5 * 5 * 32) * 0.01
wscale4 = model_params.wscale4 # math.sqrt(576) * 0.1
wscale5 = model_params.wscale5 # math.sqrt(64) * 0.1
# wscale1, wscale2, wscale3, wscale4, wscale5 = [math.sqrt(2)] * 5
model = FunctionSet(conv1=F.Convolution2D(3,
32,
5,
wscale=wscale1,
stride=1,
pad=2),
conv2=F.Convolution2D(32,
32,
5,
wscale=wscale2,
stride=1,
pad=2),
conv3=F.Convolution2D(32,
64,
5,
wscale=wscale3,
stride=1,
pad=2),
fl4=F.Linear(576, 64, wscale=wscale4),
fl5=F.Linear(64, 10, wscale=wscale5))
if params.gpu_flag:
model.to_gpu()
return model
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
class FTCS_Y:
def __init__(self):
self.model0 = FunctionSet(l=F.Convolution2D(1, 1, 3, pad=1, nobias=True))
self.model0.l.W[0,0,:,:] = np.array([[0,-1,0],[0,0,0],[0,1,0]]).astype(np.float32)/2
self.model0.to_gpu()
def forward(self, x_data):
y0 = self.model0.l(x_data)
return y0
class ConvolutionalDenoisingAutoencoder():
def __init__(self, imgsize, n_in_channels, n_out_channels, ksize, stride=1, pad=0, use_cuda=False):
self.model = FunctionSet(
encode=F.Convolution2D(n_in_channels, n_out_channels, ksize, stride, pad),
decode=F.Linear(n_out_channels*(math.floor((imgsize+2*pad-ksize)/stride)+1)**2, n_in_channels*imgsize**2)
)
self.use_cuda = use_cuda
if self.use_cuda:
self.model.to_gpu()
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model.collect_parameters())
def encode(self, x_var):
return F.sigmoid(self.model.encode(x_var))
def decode(self, x_var):
return self.model.decode(x_var)
def predict(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
x = Variable(x_data)
p = self.encode(x)
if self.use_cuda:
return cuda.to_cpu(p.data)
else:
return p.data
def cost(self, x_data):
x = Variable(x_data)
t = Variable(x_data.reshape(x_data.shape[0], x_data.shape[1]*x_data.shape[2]*x_data.shape[3]))
h = F.dropout(x)
h = self.encode(h)
y = self.decode(h)
return F.mean_squared_error(y, t)
def train(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
self.optimizer.zero_grads()
loss = self.cost(x_data)
loss.backward()
self.optimizer.update()
if self.use_cuda:
return float(cuda.to_cpu(loss.data))
else:
return loss.data
def test(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
loss = self.cost(x_data)
return float(cuda.to_cpu(loss.data))
class FTCS_Y:
def __init__(self):
self.model0 = FunctionSet(
l=F.Convolution2D(1, 1, 3, pad=1, nobias=True))
self.model0.l.W[0, 0, :, :] = np.array(
[[0, -1, 0], [0, 0, 0], [0, 1, 0]]).astype(np.float32) / 2
self.model0.to_gpu()
def forward(self, x_data):
y0 = self.model0.l(x_data)
return y0
def init_model(model_params):
wscale1 = model_params.wscale1 # math.sqrt(5 * 5 * 3) * 0.0001
wscale2 = model_params.wscale2 # math.sqrt(5 * 5 * 32) * 0.01
wscale3 = model_params.wscale3 # math.sqrt(5 * 5 * 32) * 0.01
wscale4 = model_params.wscale4 # math.sqrt(576) * 0.1
wscale5 = model_params.wscale5 # math.sqrt(64) * 0.1
# wscale1, wscale2, wscale3, wscale4, wscale5 = [math.sqrt(2)] * 5
model = FunctionSet(conv1=F.Convolution2D(3, 32, 5, wscale=wscale1, stride=1, pad=2),
conv2=F.Convolution2D(32, 32, 5, wscale=wscale2, stride=1, pad=2),
conv3=F.Convolution2D(32, 64, 5, wscale=wscale3, stride=1, pad=2),
fl4=F.Linear(576, 64, wscale=wscale4),
fl5=F.Linear(64, 10, wscale=wscale5))
if params.gpu_flag:
model.to_gpu()
return model
class Kawamura_Y:
def __init__(self):
self.model0 = FunctionSet(l=F.Convolution2D(1, 1, 5, stride=1, pad=2, nobias=True))
self.model1 = FunctionSet(l=F.Convolution2D(1, 1, 5, stride=1, pad=2, nobias=True))
#print self.model.l.W.shape
self.model0.l.W[0,0,:,:] = np.array([[0,0,2,0,0],[0,0,-12,0,0],[0,0,6,0,0],[0,0,4,0,0],[0,0,0,0,0]]).astype(np.float32)/12.0
self.model1.l.W[0,0,:,:] = np.array([[0,0,0,0,0],[0,0,-4,0,0],[0,0,-6,0,0],[0,0,12,0,0],[0,0,-2,0,0]]).astype(np.float32)/12.0
#print self.model.l.W.shape
self.model0.to_gpu()
self.model1.to_gpu()
def forward(self, x_data):
y0 = self.model0.l(x_data)
y1 = self.model1.l(x_data)
return y0,y1
class DenoisingAutoEncoder():
def __init__(self, n_in, n_hidden, use_cuda=False):
self.model = FunctionSet(encode=F.Linear(n_in, n_hidden),
decode=F.Linear(n_hidden, n_in))
self.use_cuda = use_cuda
if self.use_cuda:
self.model.to_gpu()
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model.collect_parameters())
def encode(self, x_var):
return F.sigmoid(self.model.encode(x_var))
def decode(self, x_var):
return F.sigmoid(self.model.decode(x_var))
def predict(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
x = Variable(x_data)
p = self.encode(x)
return cuda.to_cpu(p.data)
def cost(self, x_data):
x = Variable(x_data)
t = Variable(x_data)
x_n = F.dropout(x)
h = self.encode(x_n)
y = self.decode(h)
return F.mean_squared_error(y, t)
def train(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
self.optimizer.zero_grads()
loss = self.cost(x_data)
loss.backward()
self.optimizer.update()
return float(cuda.to_cpu(loss.data))
def test(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
loss = self.cost(x_data)
return float(cuda.to_cpu(loss.data))
class TestNestedFunctionSet(TestCase):
def setUp(self):
self.fs1 = FunctionSet(
a = MockFunction((1, 2)))
self.fs2 = FunctionSet(
fs1 = self.fs1,
b = MockFunction((3, 4)))
def test_get_sorted_funcs(self):
self.assertItemsEqual([k for (k, v) in self.fs2._get_sorted_funcs()], ('b', 'fs1'))
def test_collect_parameters(self):
p_b = np.zeros((3, 4)).astype(np.float32)
p_a = np.zeros((1, 2)).astype(np.float32)
gp_b = np.ones((3, 4)).astype(np.float32)
gp_a = np.ones((1, 2)).astype(np.float32)
actual = self.fs2.collect_parameters()
self.assertTrue(map(len, actual) == [2, 2])
self.assertTrue((actual[0][0] == p_b).all())
self.assertTrue((actual[0][1] == p_a).all())
self.assertTrue((actual[1][0] == gp_b).all())
self.assertTrue((actual[1][1] == gp_a).all())
def test_pickle_cpu(self):
fs2_serialized = pickle.dumps(self.fs2)
fs2_loaded = pickle.loads(fs2_serialized)
self.assertTrue((self.fs2.b.p == fs2_loaded.b.p).all())
self.assertTrue((self.fs2.fs1.a.p == fs2_loaded.fs1.a.p).all())
@attr.gpu
def test_pickle_gpu(self):
self.fs2.to_gpu()
fs2_serialized = pickle.dumps(self.fs2)
fs2_loaded = pickle.loads(fs2_serialized)
fs2_loaded.to_cpu()
self.fs2.to_cpu()
self.assertTrue((self.fs2.b.p == fs2_loaded.b.p).all())
self.assertTrue((self.fs2.fs1.a.p == fs2_loaded.fs1.a.p).all())
class Perceptron():
def __init__(self, n_in, n_out, use_cuda=False):
self.model = FunctionSet(transform=F.Linear(n_in, n_out))
self.use_cuda = use_cuda
if self.use_cuda:
self.model.to_gpu()
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model.collect_parameters())
def predict(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
x = Variable(x_data)
y = F.softmax(self.model.transform(x))
return cuda.to_cpu(y.data)
def cost(self, x_data, y_data):
x = Variable(x_data)
t = Variable(y_data)
y = self.model.transform(x)
return F.softmax_cross_entropy(y, t), F.accuracy(y, t)
def train(self, x_data, y_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
y_data = cuda.to_gpu(y_data)
self.optimizer.zero_grads()
loss, acc = self.cost(x_data, y_data)
loss.backward()
self.optimizer.update()
return float(cuda.to_cpu(loss.data)), float(cuda.to_cpu(acc.data))
def test(self, x_data, y_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
y_data = cuda.to_gpu(y_data)
loss, acc = self.cost(x_data, y_data)
return float(cuda.to_cpu(loss.data)), float(cuda.to_cpu(acc.data))
class Kawamura_Y:
def __init__(self):
self.model0 = FunctionSet(
l=F.Convolution2D(1, 1, 5, stride=1, pad=2, nobias=True))
self.model1 = FunctionSet(
l=F.Convolution2D(1, 1, 5, stride=1, pad=2, nobias=True))
#print self.model.l.W.shape
self.model0.l.W[0, 0, :, :] = np.array(
[[0, 0, 2, 0, 0], [0, 0, -12, 0, 0], [0, 0, 6, 0, 0],
[0, 0, 4, 0, 0], [0, 0, 0, 0, 0]]).astype(np.float32) / 12.0
self.model1.l.W[0, 0, :, :] = np.array(
[[0, 0, 0, 0, 0], [0, 0, -4, 0, 0], [0, 0, -6, 0, 0],
[0, 0, 12, 0, 0], [0, 0, -2, 0, 0]]).astype(np.float32) / 12.0
#print self.model.l.W.shape
self.model0.to_gpu()
self.model1.to_gpu()
def forward(self, x_data):
y0 = self.model0.l(x_data)
y1 = self.model1.l(x_data)
return y0, y1
def getResult(self, data, batch_size=100):
"""
入力データをネットワークに与え、結果を取得する。
batch_size は一度にネットワークに投げるデータ数。マシン性能により調整。
"""
self.logger.info("Get result start.")
### Model 設定
model = FunctionSet()
for num, f_layer in enumerate(self.f_layers, 1):
name = "l_f{0}".format(num)
model.__setattr__(name, f_layer)
if self.use_gpu:
model = model.to_gpu()
self.optimizer.setup(model)
### forward 処理設定
def forward(x_data):
x = Variable(x_data)
t = Variable(x_data)
h = x
for num in xrange(1, len(self.f_layers)):
h = self.activation(model.__getitem__("l_f{0}".format(num))(h))
y = model.__getitem__("l_f{0}".format(num + 1))(h)
return y.data
### 結果取得
test_data = data
test_size = len(test_data)
batch_max = int(math.ceil(test_size / float(batch_size)))
y_data = np.zeros((test_size, self.layer_sizes[len(self.layer_sizes) - 1]), dtype=test_data.dtype)
for i in xrange(batch_max):
start = i * batch_size
end = (i + 1) * batch_size
x_batch = test_data[start:end]
self.logger.debug("Index {0} => {1}, data count = {2}".format(start, end, len(x_batch)))
if self.use_gpu:
x_batch = cuda.to_gpu(x_batch)
y_batch = forward(x_batch)
if self.use_gpu:
y_batch = cuda.to_cpu(y_batch)
y_data[start:end] = y_batch
self.logger.info("Complete get result.")
return y_data
class TestNestedFunctionSet(TestCase):
def setUp(self):
self.fs1 = FunctionSet(a=MockFunction((1, 2)))
self.fs2 = FunctionSet(fs1=self.fs1, b=MockFunction((3, 4)))
def test_get_sorted_funcs(self):
assertCountEqual(self, [k for (k, v) in self.fs2._get_sorted_funcs()],
('b', 'fs1'))
def test_collect_parameters(self):
p_b = np.zeros((3, 4)).astype(np.float32)
p_a = np.zeros((1, 2)).astype(np.float32)
gp_b = np.ones((3, 4)).astype(np.float32)
gp_a = np.ones((1, 2)).astype(np.float32)
actual = self.fs2.collect_parameters()
self.assertTrue(list(map(len, actual)) == [2, 2])
self.assertTrue((actual[0][0] == p_b).all())
self.assertTrue((actual[0][1] == p_a).all())
self.assertTrue((actual[1][0] == gp_b).all())
self.assertTrue((actual[1][1] == gp_a).all())
def test_pickle_cpu(self):
fs2_serialized = pickle.dumps(self.fs2)
fs2_loaded = pickle.loads(fs2_serialized)
self.assertTrue((self.fs2.b.p == fs2_loaded.b.p).all())
self.assertTrue((self.fs2.fs1.a.p == fs2_loaded.fs1.a.p).all())
@attr.gpu
def test_pickle_gpu(self):
self.fs2.to_gpu()
fs2_serialized = pickle.dumps(self.fs2)
fs2_loaded = pickle.loads(fs2_serialized)
fs2_loaded.to_cpu()
self.fs2.to_cpu()
self.assertTrue((self.fs2.b.p == fs2_loaded.b.p).all())
self.assertTrue((self.fs2.fs1.a.p == fs2_loaded.fs1.a.p).all())
class DQN_class:
# Hyper-Parameters
gamma = 0.99 # Discount factor
initial_exploration = 100 #10**4 # Initial exploratoin. original: 5x10^4
replay_size = 32 # Replay (batch) size
target_model_update_freq = 10**4 # Target update frequancy. original: 10^4
data_size = 10**5 #10**5 # Data size of history. original: 10^6
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.CNN_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 = FunctionSet(
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()
d = 'elite/'
self.CNN_model.l1.W.data = np.load(d +
'l1_W.npy') #.astype(np.float32)
self.CNN_model.l1.b.data = np.load(d +
'l1_b.npy') #.astype(np.float32)
self.CNN_model.l2.W.data = np.load(d +
'l2_W.npy') #.astype(np.float32)
self.CNN_model.l2.b.data = np.load(d +
'l2_b.npy') #.astype(np.float32)
self.CNN_model.l3.W.data = np.load(d +
'l3_W.npy') #.astype(np.float32)
self.CNN_model.l3.b.data = np.load(d +
'l3_b.npy') #.astype(np.float32)
self.CNN_model = self.CNN_model.to_gpu()
self.CNN_model_target = copy.deepcopy(self.CNN_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]
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),
np.zeros((self.data_size, 1), dtype=np.uint8)
]
def forward(self, state, action, Reward, state_dash, episode_end):
num_of_batch = state.shape[0]
s = Variable(state)
s_dash = Variable(state_dash)
Q = self.Q_func(s) # Get Q-value
# Generate Target Signals
tmp = self.Q_func_target(s_dash) # Q(s',*)
tmp = list(map(np.max, tmp.data.get())) # max_a Q(s',a)
max_Q_dash = np.asanyarray(tmp, dtype=np.float32)
target = np.asanyarray(Q.data.get(), dtype=np.float32)
for i in xrange(num_of_batch):
if not episode_end[i][0]:
tmp_ = np.sign(Reward[i]) + self.gamma * max_Q_dash[i]
else:
tmp_ = np.sign(Reward[i])
action_index = self.action_to_index(action[i])
target[i, action_index] = tmp_
# TD-error clipping
td = Variable(cuda.to_gpu(target)) - Q # TD error
td_tmp = td.data + 1000.0 * (abs(td.data) <= 1) # Avoid zero division
td_clip = td * (abs(td.data) <= 1) + td / abs(td_tmp) * (abs(td.data) >
1)
zero_val = Variable(
cuda.to_gpu(
np.zeros((self.replay_size, self.num_of_actions),
dtype=np.float32)))
loss = F.mean_squared_error(td_clip, zero_val)
return loss, Q
def stockExperience(self, time, state, action, lstm_reward, state_dash,
episode_end_flag, ale_reward):
data_index = time % self.data_size
if episode_end_flag is True:
self.D[0][data_index] = state
self.D[1][data_index] = action
self.D[2][data_index] = lstm_reward
self.D[5][data_index] = ale_reward
else:
self.D[0][data_index] = state
self.D[1][data_index] = action
self.D[2][data_index] = lstm_reward
self.D[3][data_index] = state_dash
self.D[5][data_index] = ale_reward
self.D[4][data_index] = episode_end_flag
def experienceReplay(self, time):
if self.initial_exploration < time:
# Pick up replay_size number of samples from the Data
if time < self.data_size: # during the first sweep of the History Data
replay_index = np.random.randint(0, time,
(self.replay_size, 1))
else:
replay_index = np.random.randint(0, self.data_size,
(self.replay_size, 1))
s_replay = np.ndarray(shape=(self.replay_size, 4, 84, 84),
dtype=np.float32)
a_replay = np.ndarray(shape=(self.replay_size, 1), dtype=np.uint8)
r_replay = np.ndarray(shape=(self.replay_size, 1),
dtype=np.float32)
s_dash_replay = np.ndarray(shape=(self.replay_size, 4, 84, 84),
dtype=np.float32)
episode_end_replay = np.ndarray(shape=(self.replay_size, 1),
dtype=np.bool)
for i in xrange(self.replay_size):
s_replay[i] = np.asarray(self.D[0][replay_index[i]],
dtype=np.float32)
a_replay[i] = self.D[1][replay_index[i]]
r_replay[i] = self.D[2][replay_index[i]]
s_dash_replay[i] = np.array(self.D[3][replay_index[i]],
dtype=np.float32)
episode_end_replay[i] = self.D[4][replay_index[i]]
s_replay = cuda.to_gpu(s_replay)
s_dash_replay = cuda.to_gpu(s_dash_replay)
# Gradient-based update
self.optimizer.zero_grads()
loss, _ = self.forward(s_replay, a_replay, r_replay, s_dash_replay,
episode_end_replay)
loss.backward()
self.optimizer.update()
def Q_func(self, state):
h1 = F.relu(self.CNN_model.l1(state /
254.0)) # scale inputs in [0.0 1.0]
h2 = F.relu(self.CNN_model.l2(h1))
h3 = F.relu(self.CNN_model.l3(h2))
h4 = F.relu(self.model.l4(h3))
#test now
#print h3.data.shape
Q = self.model.q_value(h4)
return Q
def Q_func_LSTM(self, state):
h1 = F.relu(self.CNN_model.l1(state /
254.0)) # scale inputs in [0.0 1.0]
h2 = F.relu(self.CNN_model.l2(h1))
h3 = F.relu(self.CNN_model.l3(h2))
return h3.data.get()
def Q_func_target(self, state):
h1 = F.relu(self.CNN_model_target.l1(
state / 254.0)) # scale inputs in [0.0 1.0]
h2 = F.relu(self.CNN_model_target.l2(h1))
h3 = F.relu(self.CNN_model_target.l3(h2))
h4 = F.relu(self.model.l4(h3))
Q = self.model_target.q_value(h4)
return Q
def LSTM_reward(self, lstm_out, state_next):
lstm_reward = np.sign((self.lstm_loss - (lstm_out - state_next)**2))
return lstm_reward
def e_greedy(self, state, epsilon):
s = Variable(state)
Q = self.Q_func(s)
Q = Q.data
if np.random.rand() < epsilon:
index_action = np.random.randint(0, self.num_of_actions)
print "RANDOM"
else:
index_action = np.argmax(Q.get())
print "GREEDY"
return self.index_to_action(index_action), Q
def target_model_update(self):
self.model_target = copy.deepcopy(self.model)
def index_to_action(self, index_of_action):
return self.enable_controller[index_of_action]
def action_to_index(self, action):
return self.enable_controller.index(action)
def load_model():
# learning loop
model = FunctionSet(l1=F.Linear(2 * (dim * 2 + 1),
n_units,
initialW=initializer),
l2=F.Linear(n_units, n_units,
initialW=initializer),
l3=F.Linear(n_units, 1, initialW=initializer))
# Setup optimizer
optimizer = optimizers.Adam()
optimizer.setup(model)
model.to_gpu()
# Neural net architecture
def forward(x_data, y_data, ratio=0.5, train=True):
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.sigmoid(model.l1(x)), ratio=ratio, train=train)
h2 = F.dropout(F.sigmoid(model.l2(h1)), ratio=ratio, train=train)
y = model.l3(h2)
return F.mean_squared_error(y, t), y
with open('selectfrq_estimated_data/pretrain_write1.csv',
'r') as csvfile:
readfile = csv.reader(csvfile)
for row in readfile:
print len(row)
# print row
l1_W.append(row)
with open('selectfrq_estimated_data/pretrain_write2.csv',
"r") as csvfile:
reader = csv.reader(csvfile)
for row in reader:
# print row
l2_W.append(row)
with open('selectfrq_estimated_data/pretrain_write3.csv',
"r") as csvfile:
reader = csv.reader(csvfile)
for row in reader:
# print row
l3_W.append(row)
#test loop
SNRList = ["-10dB", "-5dB", "0dB", "5dB", "10dB", "-20dB"]
for SNRnum, SNR in enumerate(SNRList): #-10,-5,0,5,10,-20dB
loss_sum = np.zeros(testsize)
for idx in np.arange(learnsize + SNRnum * testsize,
learnsize + (SNRnum + 1) * testsize):
fs, signal_data = read(estimated_signal[idx], "r")
fs, noise_data = read(estimated_noise[idx], "r")
fs, teacher_data = read(
teacher_signal[idx - testsize * SNRnum], "r")
signal_data = signal_data / np.sqrt(np.mean(signal_data**2))
noise_data = noise_data / np.sqrt(np.mean(noise_data**2))
teacher_data = teacher_data / np.sqrt(np.mean(teacher_data**2))
Sspectrum_, synparam = FFTanalysis.FFTanalysis(signal_data)
Nspectrum_, synparam = FFTanalysis.FFTanalysis(noise_data)
Tspectrum_, synparam = FFTanalysis.FFTanalysis(teacher_data)
N_FRAMES = np.shape(Sspectrum_)[0]
HFFTL = np.shape(Sspectrum_)[1]
x_data = np.zeros((N_FRAMES, HFFTL * 2))
y_data = np.zeros((N_FRAMES, HFFTL))
for nframe in xrange(N_FRAMES):
spectrum = np.append(Sspectrum_[nframe],
Nspectrum_[nframe])
x_data[nframe] = [
np.sqrt(c.real**2 + c.imag**2) for c in spectrum
] #DNN indata
#phaseSpectrum = [np.arctan2(c.imag, c.real) for c in spectrum]
Spower = np.array([
np.sqrt(c.real**2 + c.imag**2)
for c in Sspectrum_[nframe]
])
Tpower = np.array([
np.sqrt(c.real**2 + c.imag**2)
for c in Tspectrum_[nframe]
])
for i, x in enumerate(Spower):
if x == 0:
Spower[i] = 1e-10
y_data[nframe] = Tpower / Spower
calcSNR = np.empty((N_FRAMES, 0), float)
totalloss = np.zeros(HFFTL, float)
# testing
for frq in xrange(HFFTL):
model.l1.W.data = cuda.to_gpu(l1_W[frq])
model.l2.W.data = cuda.to_gpu(l2_W[frq])
model.l3.W.data = cuda.to_gpu(l3_W[frq])
# testing
x_frqdata = np.zeros(
(np.shape(x_data)[0], 2 * (dim * 2 + 1)), float)
x_frqdata[:, dim] = x_data[:, frq]
x_frqdata[:, dim * 3 + 1] = x_data[:, frq + HFFTL]
for j in np.arange(1, dim + 1):
if (frq - j) >= 0:
x_frqdata[:, dim - j] = x_data[:, frq - j]
x_frqdata[:, dim * 3 + 1 - j] = x_data[:, frq +
HFFTL - j]
if ((HFFTL - 1) - (j + frq)) >= 0:
x_frqdata[:, dim + j] = x_data[:, frq + j]
x_frqdata[:, dim * 3 + 1 + j] = x_data[:, frq +
HFFTL + j]
y_frqdata = np.zeros((np.shape(y_data)[0], 1), float)
y_frqdata = y_data[:, frq].reshape(np.shape(y_data)[0], 1)
x_frqdata = x_frqdata.astype(np.float32)
y_frqdata = y_frqdata.astype(np.float32)
if args.gpu >= 0:
x_frqdata = cuda.to_gpu(x_frqdata)
y_frqdata = cuda.to_gpu(y_frqdata)
loss, pred = forward(x_frqdata, y_frqdata, train=False)
totalloss[frq] = cuda.to_cpu(loss.data)
pred = np.reshape(cuda.to_cpu(pred.data), (N_FRAMES, 1))
calcSNR = np.append(calcSNR, pred, axis=1)
fs, teacher_data = read(
teacher_signal[idx - testsize * SNRnum], "r")
if teacher_data.dtype == "int16":
teacher_data = teacher_data / norm
y_out = Sspectrum_ * calcSNR
wf_signal = FFTanalysis.Synth(y_out, synparam, BPFon=0)
wf_signal = wf_signal * np.sqrt(
np.mean(teacher_data**2) / np.mean(wf_signal**2))
write(
dir + SNR + "/dim{}_DNNbased_No{}.wav".format(
dim, idx - testsize * SNRnum), Fs, wf_signal)
class MLP(Base):
def __init__(self, data=None, target=None, n_inputs=784, n_hidden=784, n_outputs=10, gpu=-1):
self.excludes.append('xp')
self.model = FunctionSet(l1=F.Linear(n_inputs, n_hidden),
l2=F.Linear(n_hidden, n_hidden),
l3=F.Linear(n_hidden, n_outputs))
if gpu >= 0:
self.model.to_gpu()
self.xp = cuda.cupy
else:
self.xp = np
if not data is None:
self.x_train, self.x_test = data
else:
self.x_train, self.y_test = None, None
if not target is None:
self.y_train, self.y_test = target
self.n_train = len(self.y_train)
self.n_test = len(self.y_test)
else:
self.y_train, self.y_test = None, None
self.n_train = 0
self.n_test = 0
self.gpu = gpu
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
def forward(self, x_data, y_data, train=True):
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.relu(self.model.l1(x)), train=train)
h2 = F.dropout(F.relu(self.model.l2(h1)), train=train)
y = self.model.l3(h2)
return F.softmax_cross_entropy(y, t), F.accuracy(y, t)
def train_and_test(self, n_epoch=20, batchsize=100):
for epoch in xrange(1, n_epoch+1):
print 'epoch', epoch
perm = np.random.permutation(self.n_train)
sum_accuracy = 0
sum_loss = 0
for i in xrange(0, self.n_train, batchsize):
x_batch = self.xp.asarray(self.x_train[perm[i:i+batchsize]])
y_batch = self.xp.asarray(self.y_train[perm[i:i+batchsize]])
real_batchsize = len(x_batch)
self.optimizer.zero_grads()
loss, acc = self.forward(x_batch, y_batch)
loss.backward()
self.optimizer.update()
sum_loss += float(cuda.to_cpu(loss.data)) * real_batchsize
sum_accuracy += float(cuda.to_cpu(acc.data)) * real_batchsize
print 'train mean loss={}, accuracy={}'.format(sum_loss/self.n_train, sum_accuracy/self.n_train)
# evalation
sum_accuracy = 0
sum_loss = 0
for i in xrange(0, self.n_test, batchsize):
x_batch = self.xp.asarray(self.x_test[i:i+batchsize])
y_batch = self.xp.asarray(self.y_test[i:i+batchsize])
real_batchsize = len(x_batch)
loss, acc = self.forward(x_batch, y_batch, train=False)
sum_loss += float(cuda.to_cpu(loss.data)) * real_batchsize
sum_accuracy += float(cuda.to_cpu(acc.data)) * real_batchsize
print 'test mean loss={}, accuracy={}'.format(sum_loss/self.n_test, sum_accuracy/self.n_test)
def Main():
import argparse
import numpy as np
from chainer import cuda, Variable, FunctionSet, optimizers, utils
import chainer.functions as F
from loss_for_error import loss_for_error1, loss_for_error2
import six.moves.cPickle as pickle
parser = argparse.ArgumentParser(description='Chainer example: regression')
parser.add_argument('--gpu', '-g', default=-1, type=int,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
n_units = 200 #NOTE: should be the same as ones in regression2c
N_test= 100
x_test= np.array([[x] for x in FRange1(*Bound,num_div=N_test)]).astype(np.float32)
y_test= np.array([[TrueFunc(x[0])] for x in x_test]).astype(np.float32)
y_err_test= np.array([[0.0] for x in x_test]).astype(np.float32)
# Dump data for plot:
fp1= file('/tmp/smpl_test.dat','w')
for x,y in zip(x_test,y_test):
fp1.write('%s #%i# %s\n' % (' '.join(map(str,x)),len(x)+1,' '.join(map(str,y))))
fp1.close()
# Prepare multi-layer perceptron model
model = FunctionSet(l1=F.Linear(1, n_units),
l2=F.Linear(n_units, n_units),
l3=F.Linear(n_units, 1))
# Error model
model_err = FunctionSet(l1=F.Linear(1, n_units),
l2=F.Linear(n_units, n_units),
l3=F.Linear(n_units, 1))
# Load parameters from file:
model.copy_parameters_from(pickle.load(open('datak/reg2c_mean.dat', 'rb')))
model_err.copy_parameters_from(pickle.load(open('datak/reg2c_err.dat', 'rb')))
#model.copy_parameters_from(map(lambda e:np.array(e,np.float32),pickle.load(open('/tmp/nn_model.dat', 'rb')) ))
#model_err.copy_parameters_from(map(lambda e:np.array(e,np.float32),pickle.load(open('/tmp/nn_model_err.dat', 'rb')) ))
if args.gpu >= 0:
cuda.init(args.gpu)
model.to_gpu()
model_err.to_gpu()
# Neural net architecture
def forward(x_data, y_data, train=True):
#train= False #TEST: Turn off dropout
dratio= 0.2 #0.5 #TEST: Dropout ratio
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.relu(model.l1(x)), ratio=dratio, train=train)
h2 = F.dropout(F.relu(model.l2(h1)), ratio=dratio, train=train)
y = model.l3(h2)
return F.mean_squared_error(y, t), y
# Neural net architecture
def forward_err(x_data, y_data, train=True):
#train= False #TEST: Turn off dropout
dratio= 0.2 #0.5 #TEST: Dropout ratio
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.relu(model_err.l1(x)), ratio=dratio, train=train)
h2 = F.dropout(F.relu(model_err.l2(h1)), ratio=dratio, train=train)
y = model_err.l3(h2)
#return F.mean_squared_error(y, t), y
#return loss_for_error1(y, t, 0.1), y #TEST
return loss_for_error2(y, t, 0.1), y #TEST
#ReLU whose input is normal distribution variable.
# mu: mean, var: variance (square of std-dev).
# cut_sd: if abs(mu)>cut_sd*sigma, an approximation is used. Set None to disable this.
def relu_gauss(mu, var, epsilon=1.0e-6, cut_sd=4.0):
cast= type(mu)
sigma= math.sqrt(var)
if sigma<epsilon: return cast(max(0.0,mu)), cast(0.0)
#Approximation to speedup for abs(mu)>cut_sd*sigma.
if cut_sd!=None and mu>cut_sd*sigma: return cast(mu), cast(var)
if cut_sd!=None and mu<-cut_sd*sigma: return cast(0.0), cast(0.0)
sqrt2= math.sqrt(2.0)
sqrt2pi= math.sqrt(2.0*math.pi)
z= mu/(sqrt2*sigma)
E= math.erf(z)
X= math.exp(-z*z)
mu_out= sigma/sqrt2pi*X + mu/2.0*(1.0+E)
var_out= (1.0+E)/4.0*(mu*mu*(1.0-E)+2.0*var) - sigma*X/sqrt2pi*(sigma*X/sqrt2pi+mu*E)
if var_out<0.0:
if var_out>-epsilon: return mu_out, 0.0
else:
msg= 'ERROR in relu_gauss: %f, %f, %f, %f'%(mu, sigma, mu_out, var_out)
print msg
raise Exception(msg)
return cast(mu_out), cast(var_out)
relu_gaussv= np.vectorize(relu_gauss) #Vector version
#Gradient of ReLU whose input is normal distribution variable.
# mu: mean, var: variance (square of std-dev).
# cut_sd: if abs(mu)>cut_sd*sigma, an approximation is used. Set None to disable this.
def relu_gauss_grad(mu, var, epsilon=1.0e-6, cut_sd=4.0):
cast= type(mu)
sigma= math.sqrt(var)
if sigma<epsilon: return cast(1.0 if mu>0.0 else 0.0)
#Approximation to speedup for abs(mu)>cut_sd*sigma.
if cut_sd!=None and mu>cut_sd*sigma: return cast(1.0)
if cut_sd!=None and mu<-cut_sd*sigma: return cast(0.0)
sqrt2= math.sqrt(2.0)
z= mu/(sqrt2*sigma)
return cast(0.5*(1.0+math.erf(z)))
relu_gauss_gradv= np.vectorize(relu_gauss_grad) #Vector version
#Forward computation of neural net considering input distribution.
def forward_x(x, x_var=None):
zero= np.float32(0)
x= np.array(x,np.float32); x= x.reshape(x.size,1)
#Error model:
h0= x
for l in (model_err.l1, model_err.l2):
hl1= l.W.dot(h0) + l.b.reshape(l.b.size,1) #W h0 + b
h1= np.maximum(zero, hl1) #ReLU(hl1)
h0= h1
l= model_err.l3
y_err0= l.W.dot(h0) + l.b.reshape(l.b.size,1)
y_var0= np.diag((y_err0*y_err0).ravel())
if x_var in (0.0, None):
g= None #Gradient
h0= x
for l in (model.l1, model.l2):
hl1= l.W.dot(h0) + l.b.reshape(l.b.size,1) #W h0 + b
h1= np.maximum(zero, hl1) #ReLU(hl1)
g2= l.W.T.dot(np.diag((hl1>0.0).ravel().astype(np.float32))) #W diag(step(hl1))
g= g2 if g==None else g.dot(g2)
h0= h1
l= model.l3
y= l.W.dot(h0) + l.b.reshape(l.b.size,1)
g= g2 if g==None else g.dot(l.W.T)
return y, y_var0, g
else:
if isinstance(x_var, (float, np.float_, np.float16, np.float32, np.float64)):
x_var= np.diag(np.array([x_var]*x.size).astype(np.float32))
elif x_var.size==x.size:
x_var= np.diag(np.array(x_var.ravel(),np.float32))
else:
x_var= np.array(x_var,np.float32); x_var= x_var.reshape(x.size,x.size)
g= None #Gradient
h0= x
h0_var= x_var
for l in (model.l1, model.l2):
hl1= l.W.dot(h0) + l.b.reshape(l.b.size,1) #W h0 + b
#print 'l.W',l.W.shape
#print 'h0_var',h0_var.shape
hl1_dvar= np.diag( l.W.dot(h0_var.dot(l.W.T)) ).reshape(hl1.size,1) #diag(W h0_var W^T)
#print 'hl1',hl1.shape
#print 'hl1_dvar',hl1_dvar.shape
h1,h1_dvar= relu_gaussv(hl1,hl1_dvar) #ReLU_gauss(hl1,hl1_dvar)
#print 'h1_dvar',h1_dvar.shape
h1_var= np.diag(h1_dvar.ravel()) #To a full matrix
#print 'h1_var',h1_var.shape
#print 'relu_gauss_gradv(hl1,hl1_dvar)',relu_gauss_gradv(hl1,hl1_dvar).shape
g2= l.W.T.dot(np.diag(relu_gauss_gradv(hl1,hl1_dvar).ravel()))
g= g2 if g==None else g.dot(g2)
h0= h1
h0_var= h1_var
l= model.l3
y= l.W.dot(h0) + l.b.reshape(l.b.size,1)
y_var= l.W.dot(h0_var.dot(l.W.T))
g= g2 if g==None else g.dot(l.W.T)
return y, y_var+y_var0, g
'''
# testing all data
preds = []
x_batch = x_test[:]
y_batch = y_test[:]
y_err_batch = y_err_test[:]
if args.gpu >= 0:
x_batch = cuda.to_gpu(x_batch)
y_batch = cuda.to_gpu(y_batch)
y_err_batch = cuda.to_gpu(y_err_batch)
loss, pred = forward(x_batch, y_batch, train=False)
loss_err, pred_err = forward_err(x_batch, y_err_batch, train=False)
preds = cuda.to_cpu(pred.data)
preds_err = cuda.to_cpu(pred_err.data)
sum_loss = float(cuda.to_cpu(loss.data)) * len(y_test)
sum_loss_err = float(cuda.to_cpu(loss_err.data)) * len(y_test)
pearson = np.corrcoef(np.asarray(preds).reshape(len(preds),), np.asarray(y_test).reshape(len(preds),))
print 'test mean loss={}, corrcoef={}, error loss={}'.format(
sum_loss / N_test, pearson[0][1], sum_loss_err / N_test)
# Dump data for plot:
fp1= file('/tmp/nn_test0001.dat','w')
for x,y,yerr in zip(x_test,preds,preds_err):
fp1.write('%s #%i# %s %s\n' % (' '.join(map(str,x)),len(x)+1,' '.join(map(str,y)),' '.join(map(str,yerr))))
fp1.close()
#'''
# Dump data for plot:
fp1= file('/tmp/nn_test0001.dat','w')
for x in x_test:
y, var, g= forward_x(x, 0.0)
y, var, g= y.ravel(), var.ravel(), g.ravel()
yerr= np.sqrt(var)
fp1.write('%s %s %s %s\n' % (' '.join(map(str,x)),' '.join(map(str,y)),' '.join(map(str,yerr)),' '.join(map(str,g))))
fp1.close()
# Dump data for plot:
fp1= file('/tmp/nn_test0002.dat','w')
for x in x_test:
y, var, g= forward_x(x, 0.5**2)
y, var, g= y.ravel(), var.ravel(), g.ravel()
yerr= np.sqrt(var)
fp1.write('%s %s %s %s\n' % (' '.join(map(str,x)),' '.join(map(str,y)),' '.join(map(str,yerr)),' '.join(map(str,g))))
fp1.close()
class DQN_class:
# Hyper-Parameters
gamma = 0.99 # Discount factor
initial_exploration = 100#10**4 # Initial exploratoin. original: 5x10^4
replay_size = 32 # Replay (batch) size
target_model_update_freq = 10**4 # Target update frequancy. original: 10^4
data_size = 10**5 #10**5 # Data size of history. original: 10^6
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.CNN_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 = FunctionSet(
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()
d = 'elite/'
self.CNN_model.l1.W.data = np.load(d+'l1_W.npy')#.astype(np.float32)
self.CNN_model.l1.b.data = np.load(d+'l1_b.npy')#.astype(np.float32)
self.CNN_model.l2.W.data = np.load(d+'l2_W.npy')#.astype(np.float32)
self.CNN_model.l2.b.data = np.load(d+'l2_b.npy')#.astype(np.float32)
self.CNN_model.l3.W.data = np.load(d+'l3_W.npy')#.astype(np.float32)
self.CNN_model.l3.b.data = np.load(d+'l3_b.npy')#.astype(np.float32)
self.CNN_model = self.CNN_model.to_gpu()
self.CNN_model_target = copy.deepcopy(self.CNN_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]
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),
np.zeros((self.data_size, 1), dtype=np.uint8)]
def forward(self, state, action, Reward, state_dash, episode_end):
num_of_batch = state.shape[0]
s = Variable(state)
s_dash = Variable(state_dash)
Q = self.Q_func(s) # Get Q-value
# Generate Target Signals
tmp = self.Q_func_target(s_dash) # Q(s',*)
tmp = list(map(np.max, tmp.data.get())) # max_a Q(s',a)
max_Q_dash = np.asanyarray(tmp, dtype=np.float32)
target = np.asanyarray(Q.data.get(), dtype=np.float32)
for i in xrange(num_of_batch):
if not episode_end[i][0]:
tmp_ = np.sign(Reward[i]) + self.gamma * max_Q_dash[i]
else:
tmp_ = np.sign(Reward[i])
action_index = self.action_to_index(action[i])
target[i, action_index] = tmp_
# TD-error clipping
td = Variable(cuda.to_gpu(target)) - Q # TD error
td_tmp = td.data + 1000.0 * (abs(td.data) <= 1) # Avoid zero division
td_clip = td * (abs(td.data) <= 1) + td/abs(td_tmp) * (abs(td.data) > 1)
zero_val = Variable(cuda.to_gpu(np.zeros((self.replay_size, self.num_of_actions), dtype=np.float32)))
loss = F.mean_squared_error(td_clip, zero_val)
return loss, Q
def stockExperience(self, time,
state, action, lstm_reward, state_dash,
episode_end_flag, ale_reward):
data_index = time % self.data_size
if episode_end_flag is True:
self.D[0][data_index] = state
self.D[1][data_index] = action
self.D[2][data_index] = lstm_reward
self.D[5][data_index] = ale_reward
else:
self.D[0][data_index] = state
self.D[1][data_index] = action
self.D[2][data_index] = lstm_reward
self.D[3][data_index] = state_dash
self.D[5][data_index] = ale_reward
self.D[4][data_index] = episode_end_flag
def experienceReplay(self, time):
if self.initial_exploration < time:
# Pick up replay_size number of samples from the Data
if time < self.data_size: # during the first sweep of the History Data
replay_index = np.random.randint(0, time, (self.replay_size, 1))
else:
replay_index = np.random.randint(0, self.data_size, (self.replay_size, 1))
s_replay = np.ndarray(shape=(self.replay_size, 4, 84, 84), dtype=np.float32)
a_replay = np.ndarray(shape=(self.replay_size, 1), dtype=np.uint8)
r_replay = np.ndarray(shape=(self.replay_size, 1), dtype=np.float32)
s_dash_replay = np.ndarray(shape=(self.replay_size, 4, 84, 84), dtype=np.float32)
episode_end_replay = np.ndarray(shape=(self.replay_size, 1), dtype=np.bool)
for i in xrange(self.replay_size):
s_replay[i] = np.asarray(self.D[0][replay_index[i]], dtype=np.float32)
a_replay[i] = self.D[1][replay_index[i]]
r_replay[i] = self.D[2][replay_index[i]]
s_dash_replay[i] = np.array(self.D[3][replay_index[i]], dtype=np.float32)
episode_end_replay[i] = self.D[4][replay_index[i]]
s_replay = cuda.to_gpu(s_replay)
s_dash_replay = cuda.to_gpu(s_dash_replay)
# Gradient-based update
self.optimizer.zero_grads()
loss, _ = self.forward(s_replay, a_replay, r_replay, s_dash_replay, episode_end_replay)
loss.backward()
self.optimizer.update()
def Q_func(self, state):
h1 = F.relu(self.CNN_model.l1(state / 254.0)) # scale inputs in [0.0 1.0]
h2 = F.relu(self.CNN_model.l2(h1))
h3 = F.relu(self.CNN_model.l3(h2))
h4 = F.relu(self.model.l4(h3))
#test now
#print h3.data.shape
Q = self.model.q_value(h4)
return Q
def Q_func_LSTM(self, state):
h1 = F.relu(self.CNN_model.l1(state / 254.0)) # scale inputs in [0.0 1.0]
h2 = F.relu(self.CNN_model.l2(h1))
h3 = F.relu(self.CNN_model.l3(h2))
return h3.data.get()
def Q_func_target(self, state):
h1 = F.relu(self.CNN_model_target.l1(state / 254.0)) # scale inputs in [0.0 1.0]
h2 = F.relu(self.CNN_model_target.l2(h1))
h3 = F.relu(self.CNN_model_target.l3(h2))
h4 = F.relu(self.model.l4(h3))
Q = self.model_target.q_value(h4)
return Q
def LSTM_reward(self, lstm_out, state_next):
lstm_reward = np.sign((self.lstm_loss - (lstm_out - state_next)**2))
return lstm_reward
def e_greedy(self, state, epsilon):
s = Variable(state)
Q = self.Q_func(s)
Q = Q.data
if np.random.rand() < epsilon:
index_action = np.random.randint(0, self.num_of_actions)
print "RANDOM"
else:
index_action = np.argmax(Q.get())
print "GREEDY"
return self.index_to_action(index_action), Q
def target_model_update(self):
self.model_target = copy.deepcopy(self.model)
def index_to_action(self, index_of_action):
return self.enable_controller[index_of_action]
def action_to_index(self, action):
return self.enable_controller.index(action)
class Inception(Function):
"""Inception module of GoogLeNet.
It applies four different functions to the input array and concatenates
their outputs along the channel dimension. Three of them are 2D convolutions
of sizes 1x1, 3x3 and 5x5. Convolution paths of 3x3 and 5x5 sizes have 1x1
convolutions (called projections) ahead of them. The other path consists of
1x1 convolution (projection) and 3x3 max pooling.
The output array has the same spatial size as the input. In order to satisfy
this, Inception module uses appropriate padding for each convolution and
pooling.
See: `Going Deeper with Convolutions <http://arxiv.org/abs/1409.4842>`_.
Args:
in_channels (int): Number of channels of input arrays.
out1 (int): Output size of 1x1 convolution path.
proj3 (int): Projection size of 3x3 convolution path.
out3 (int): Output size of 3x3 convolution path.
proj5 (int): Projection size of 5x5 convolution path.
out5 (int): Output size of 5x5 convolution path.
proj_pool (int): Projection size of max pooling path.
Returns:
Variable: Output variable. Its array has the same spatial size and the
same minibatch size as the input array. The channel dimension has
size ``out1 + out3 + out5 + proj_pool``.
.. note::
This function inserts the full computation graph of the Inception module behind
the input array. This function itself is not inserted into the
computation graph.
"""
def __init__(self, in_channels, out1, proj3, out3, proj5, out5, proj_pool):
self.f = FunctionSet(
conv1=Convolution2D(in_channels, out1, 1),
proj3=Convolution2D(in_channels, proj3, 1),
conv3=Convolution2D(proj3, out3, 3, pad=1),
proj5=Convolution2D(in_channels, proj5, 1),
conv5=Convolution2D(proj5, out5, 5, pad=2),
projp=Convolution2D(in_channels, proj_pool, 1),
)
def forward(self, x):
self.x = Variable(x[0])
out1 = self.f.conv1(self.x)
out3 = self.f.conv3(relu(self.f.proj3(self.x)))
out5 = self.f.conv5(relu(self.f.proj5(self.x)))
pool = self.f.projp(max_pooling_2d(self.x, 3, stride=1, pad=1))
self.y = relu(concat((out1, out3, out5, pool), axis=1))
return self.y.data,
def backward(self, x, gy):
self.y.grad = gy[0]
self.y.backward()
return self.x.grad,
def to_gpu(self, device=None):
return self.f.to_gpu(device)
def to_cpu(self):
return self.f.to_cpu()
@property
def parameters(self):
return self.f.parameters
@parameters.setter
def parameters(self, params):
self.f.parameters = params
@property
def gradients(self):
return self.f.gradients
@gradients.setter
def gradients(self, grads):
self.f.gradients = grads
class dA(BaseEstimator):
"""
Denoising Autoencoder
reference:
http://deeplearning.net/tutorial/dA.html
https://github.com/pfnet/chainer/blob/master/examples/mnist/train_mnist.py
"""
def __init__(self, n_visible, n_hidden, noise_level=0.0, dropout_ratio=0.3,
batch_size=100, n_epoch=20, optimizer=optimizers.Adam(),
activation_func=F.relu, verbose=False, gpu=-1):
self.n_visible = n_visible
self.n_hidden = n_hidden
self.noise_level = noise_level
self.dropout_ratio = dropout_ratio
self.batch_size = batch_size
self.n_epoch = n_epoch
# construct model and setup optimizer
self.model = FunctionSet(
encoder=F.Linear(n_visible, n_hidden),
decoder=F.Linear(n_hidden, n_visible)
)
self.optimizer = optimizer
self.optimizer.setup(self.model)
self.activation_func = activation_func
self.verbose = verbose
# set gpu
self.gpu = gpu
if self.gpu >= 0:
cuda.get_device(self.gpu).use()
self.model.to_gpu()
def fit(self, X):
xp = cuda.cupy if self.gpu >= 0 else np
for epoch in range(self.n_epoch):
utils.disp('epoch: {}'.format(epoch + 1), self.verbose)
perm = np.random.permutation(len(X))
sum_loss = 0
for i in range(0, len(X), self.batch_size):
X_batch = xp.asarray(X[perm[i: i + self.batch_size]])
loss = self._fit(X_batch)
sum_loss += float(loss.data) * len(X_batch)
utils.disp('train mean loss={}'.format(sum_loss / len(X)), self.verbose)
return self
def _fit(self, X):
self.optimizer.zero_grads()
y_var = self._forward(X, train=True)
loss = F.mean_squared_error(y_var, Variable(X.copy()))
loss.backward()
self.optimizer.update()
return loss
def _forward(self, X, train):
X_var = Variable(dA.add_noise(X, self.noise_level, train))
h1 = self.encode(X_var, train)
y_var = self.model.decoder(h1)
return y_var
def predict(self, X):
return self._forward(X, train=False).data
@property
def encoder(self):
return self.model.encoder
def encode(self, X_var, train):
return F.dropout(self.activation_func(self.encoder(X_var)), ratio=self.dropout_ratio, train=train)
@staticmethod
def add_noise(X, noise_level, train):
return (np.random.binomial(size=X.shape, n=1, p=1 - (noise_level if train else 0.0)) * X).astype(np.float32)
class Inception(Function):
"""Inception module of GoogLeNet.
It applies four different functions to the input array and concatenates
their outputs along the channel dimension. Three of them are 2D convolutions
of sizes 1x1, 3x3 and 5x5. Convolution paths of 3x3 and 5x5 sizes have 1x1
convolutions (called projections) ahead of them. The other path consists of
1x1 convolution (projection) and 3x3 max pooling.
The output array has the same spatial size as the input. In order to satisfy
this, Inception module uses appropriate padding for each convolution and
pooling.
See: `Going Deeper with Convolutions <http://arxiv.org/abs/1409.4842>`_.
Args:
in_channels (int): Number of channels of input arrays.
out1 (int): Output size of 1x1 convolution path.
proj3 (int): Projection size of 3x3 convolution path.
out3 (int): Output size of 3x3 convolution path.
proj5 (int): Projection size of 5x5 convolution path.
out5 (int): Output size of 5x5 convolution path.
proj_pool (int): Projection size of max pooling path.
Returns:
Variable: Output variable. Its array has the same spatial size and the
same minibatch size as the input array. The channel dimension has
size ``out1 + out3 + out5 + proj_pool``.
.. note::
This function inserts the full computation graph of the Inception module behind
the input array. This function itself is not inserted into the
computation graph.
"""
def __init__(self, in_channels, out1, proj3, out3, proj5, out5, proj_pool):
self.f = FunctionSet(
conv1 = Convolution2D(in_channels, out1, 1),
proj3 = Convolution2D(in_channels, proj3, 1),
conv3 = Convolution2D(proj3, out3, 3, pad=1),
proj5 = Convolution2D(in_channels, proj5, 1),
conv5 = Convolution2D(proj5, out5, 5, pad=2),
projp = Convolution2D(in_channels, proj_pool, 1),
)
def forward(self, x):
self.x = Variable(x[0])
out1 = self.f.conv1(self.x)
out3 = self.f.conv3(relu(self.f.proj3(self.x)))
out5 = self.f.conv5(relu(self.f.proj5(self.x)))
pool = self.f.projp(max_pooling_2d(self.x, 3, stride=1, pad=1))
self.y = relu(concat((out1, out3, out5, pool), axis=1))
return self.y.data,
def backward(self, x, gy):
self.y.grad = gy[0]
self.y.backward()
return self.x.grad,
def to_gpu(self, device=None):
return self.f.to_gpu(device)
def to_cpu(self):
return self.f.to_cpu()
@property
def parameters(self):
return self.f.parameters
@parameters.setter
def parameters(self, params):
self.f.parameters = params
@property
def gradients(self):
return self.f.gradients
@gradients.setter
def gradients(self, grads):
self.f.gradients = grads
def Main():
import argparse
import numpy as np
from chainer import cuda, Variable, FunctionSet, optimizers
import chainer.functions as F
parser = argparse.ArgumentParser(description='Chainer example: regression')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
batchsize = 10
n_epoch = NEpoch
n_units = 1000 #TEST
# Prepare dataset
data_x, data_y = LoadData()
batchsize = max(1, min(batchsize,
len(data_y) / 20)) #TEST: adjust batchsize
#dx2,dy2=GenData(300, noise=0.0); data_x.extend(dx2); data_y.extend(dy2)
data = np.array(data_x).astype(np.float32)
target = np.array(data_y).astype(np.float32)
N = len(data) #batchsize * 30
x_train = data
y_train = target
#For test:
mi, ma, me = GetStat(data_x)
f_reduce = lambda xa: [xa[0], xa[2]]
f_repair = lambda xa: [xa[0], me[1], xa[1]]
nt = 25
N_test = nt * nt
x_test = np.array(
sum([[
f_repair([x1, x2])
for x2 in FRange1(f_reduce(mi)[1],
f_reduce(ma)[1], nt)
] for x1 in FRange1(f_reduce(mi)[0],
f_reduce(ma)[0], nt)], [])).astype(np.float32)
y_test = np.array([[0.0] * len(data_y[0])
for x in x_test]).astype(np.float32)
#No true test data (just for plotting)
print 'Num of samples for train:', len(y_train)
# Dump data for plot:
DumpData('/tmp/smpl_train.dat', x_train, y_train, f_reduce)
# Prepare multi-layer perceptron model
model = FunctionSet(l1=F.Linear(3, n_units),
l2=F.Linear(n_units, n_units),
l3=F.Linear(n_units, 2))
#TEST: Random bias initialization
#, bias=Rand()
#model.l1.b[:]= [Rand() for k in range(n_units)]
#model.l2.b[:]= [Rand() for k in range(n_units)]
#model.l3.b[:]= [Rand() for k in range(1)]
#print model.l2.__dict__
if args.gpu >= 0:
cuda.init(args.gpu)
model.to_gpu()
# Neural net architecture
def forward(x_data, y_data, train=True):
#train= False #TEST: Turn off dropout
dratio = 0.2 #0.5 #TEST: Dropout ratio
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.relu(model.l1(x)), ratio=dratio, train=train)
h2 = F.dropout(F.relu(model.l2(h1)), ratio=dratio, train=train)
#h1 = F.dropout(F.leaky_relu(model.l1(x),slope=0.2), ratio=dratio, train=train)
#h2 = F.dropout(F.leaky_relu(model.l2(h1),slope=0.2), ratio=dratio, train=train)
#h1 = F.dropout(F.sigmoid(model.l1(x)), ratio=dratio, train=train)
#h2 = F.dropout(F.sigmoid(model.l2(h1)), ratio=dratio, train=train)
#h1 = F.dropout(F.tanh(model.l1(x)), ratio=dratio, train=train)
#h2 = F.dropout(F.tanh(model.l2(h1)), ratio=dratio, train=train)
#h1 = F.dropout(model.l1(x), ratio=dratio, train=train)
#h2 = F.dropout(model.l2(h1), ratio=dratio, train=train)
#h1 = F.relu(model.l1(x))
#h2 = F.relu(model.l2(h1))
#h1 = model.l1(x)
#h2 = model.l2(h1)
y = model.l3(h2)
return F.mean_squared_error(y, t), y
# Setup optimizer
optimizer = optimizers.AdaDelta(rho=0.9)
#optimizer = optimizers.AdaGrad(lr=0.5)
#optimizer = optimizers.RMSprop()
#optimizer = optimizers.MomentumSGD()
#optimizer = optimizers.SGD(lr=0.8)
optimizer.setup(model.collect_parameters())
# Learning loop
for epoch in xrange(1, n_epoch + 1):
print 'epoch', epoch
# training
perm = np.random.permutation(N)
sum_loss = 0
for i in xrange(0, N, batchsize):
x_batch = x_train[perm[i:i + batchsize]]
y_batch = y_train[perm[i:i + batchsize]]
if args.gpu >= 0:
x_batch = cuda.to_gpu(x_batch)
y_batch = cuda.to_gpu(y_batch)
optimizer.zero_grads()
loss, pred = forward(x_batch, y_batch)
loss.backward() #Computing gradients
optimizer.update()
sum_loss += float(cuda.to_cpu(loss.data)) * batchsize
print 'train mean loss={}'.format(sum_loss / N)
if epoch in TestNEpochs:
#'''
# testing all data
preds = []
x_batch = x_test[:]
y_batch = y_test[:]
if args.gpu >= 0:
x_batch = cuda.to_gpu(x_batch)
y_batch = cuda.to_gpu(y_batch)
loss, pred = forward(x_batch, y_batch, train=False)
preds = cuda.to_cpu(pred.data)
sum_loss = float(cuda.to_cpu(loss.data)) * len(y_test)
#'''
print 'test mean loss={}'.format(sum_loss / N_test)
# Dump data for plot:
DumpData('/tmp/nn_test%04i.dat' % epoch,
x_test,
preds,
f_reduce,
lb=nt + 1)
class InceptionBN(Function):
"""Inception module in new GoogLeNet with BN."""
def __init__(self,
in_channels,
out1,
proj3,
out3,
proj33,
out33,
pooltype,
proj_pool=None,
stride=1):
if out1 > 0:
assert stride == 1
assert proj_pool is not None
self.f = FunctionSet(
proj3=F.Convolution2D(in_channels, proj3, 1, nobias=True),
conv3=F.Convolution2D(proj3,
out3,
3,
pad=1,
stride=stride,
nobias=True),
proj33=F.Convolution2D(in_channels, proj33, 1, nobias=True),
conv33a=F.Convolution2D(proj33, out33, 3, pad=1, nobias=True),
conv33b=F.Convolution2D(out33,
out33,
3,
pad=1,
stride=stride,
nobias=True),
proj3n=F.BatchNormalization(proj3),
conv3n=F.BatchNormalization(out3),
proj33n=F.BatchNormalization(proj33),
conv33an=F.BatchNormalization(out33),
conv33bn=F.BatchNormalization(out33),
)
if out1 > 0:
self.f.conv1 = F.Convolution2D(in_channels,
out1,
1,
stride=stride,
nobias=True)
self.f.conv1n = F.BatchNormalization(out1)
if proj_pool is not None:
self.f.poolp = F.Convolution2D(in_channels,
proj_pool,
1,
nobias=True)
self.f.poolpn = F.BatchNormalization(proj_pool)
if pooltype == 'max':
self.f.pool = MaxPooling2D(3, stride=stride, pad=1)
elif pooltype == 'avg':
self.f.pool = AveragePooling2D(3, stride=stride, pad=1)
else:
raise NotImplementedError()
def forward(self, x):
f = self.f
self.x = Variable(x[0])
outs = []
if hasattr(f, 'conv1'):
h1 = f.conv1(self.x)
h1 = f.conv1n(h1)
h1 = F.relu(h1)
outs.append(h1)
h3 = F.relu(f.proj3n(f.proj3(self.x)))
h3 = F.relu(f.conv3n(f.conv3(h3)))
outs.append(h3)
h33 = F.relu(f.proj33n(f.proj33(self.x)))
h33 = F.relu(f.conv33an(f.conv33a(h33)))
h33 = F.relu(f.conv33bn(f.conv33b(h33)))
outs.append(h33)
p = f.pool(self.x)
if hasattr(f, 'poolp'):
p = F.relu(f.poolpn(f.poolp(p)))
outs.append(p)
self.y = F.concat(outs, axis=1)
return self.y.data,
def backward(self, x, gy):
self.y.grad = gy[0]
self.y.backward()
return self.x.grad,
def to_gpu(self, device=None):
super(InceptionBN, self).to_gpu(device)
self.f.to_gpu(device)
@property
def parameters(self):
return self.f.parameters
@parameters.setter
def parameters(self, params):
self.f.parameters = params
@property
def gradients(self):
return self.f.gradients
@gradients.setter
def gradients(self, grads):
self.f.gradients = grads
class DA(object):
def __init__(self,
rng,
data,
n_inputs=784,
n_hidden=784,
corruption_level=0.3,
gpu=-1,
sparse=False):
"""Denoising AutoEncoder
data: data for train
n_inputs: a number of units of input layer and output layer
n_hidden: a number of units of hidden layer
corruption_level: a ratio of masking noise
"""
self.model = FunctionSet(encoder=F.Linear(n_inputs, n_hidden),
decoder=F.Linear(n_hidden, n_inputs))
if gpu >= 0:
self.model.to_gpu()
self.gpu = gpu
self.x_train, self.x_test = data
self.n_train = len(self.x_train)
self.n_test = len(self.x_test)
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model.collect_parameters())
self.corruption_level = corruption_level
self.rng = rng
self.sparse = sparse
def forward(self, x_data, train=True):
y_data = x_data
# add noise (masking noise)
# x_data = self.get_corrupted_inputs(x_data, train=train)
if self.gpu >= 0:
x_data = cuda.to_gpu(x_data)
y_data = cuda.to_gpu(y_data)
x, t = Variable(x_data), Variable(y_data)
# encode
h = self.encode(x)
# decode
y = self.decode(h)
# compute loss
if self.sparse:
loss = F.mean_squared_error(y, t) + .001 * np.linalg.norm(h.data)
else:
loss = F.mean_squared_error(y, t)
return loss
def compute_hidden(self, x_data):
if self.gpu >= 0:
x_data = cuda.to_gpu(x_data)
x = Variable(x_data)
h = self.encode(x)
return cuda.to_cpu(h.data)
def predict(self, x_data):
if self.gpu >= 0:
x_data = cuda.to_gpu(x_data)
x = Variable(x_data)
# encode
h = self.encode(x)
# decode
y = self.decode(h)
return cuda.to_cpu(y.data)
def encode(self, x):
return F.relu(self.model.encoder(x))
def decode(self, h):
return F.relu(self.model.decoder(h))
def encoder(self):
return self.model.encoder
def decoder(self):
return self.model.decoder
# masking noise
def get_corrupted_inputs(self, x_data, train=True):
if train:
ret = self.rng.binomial(
size=x_data.shape, n=1, p=1.0 - self.corruption_level) * x_data
return ret.astype(np.float32)
else:
return x_data
def train_and_test(self, n_epoch=5, batchsize=100):
for epoch in xrange(1, n_epoch + 1):
print 'epoch', epoch
perm = self.rng.permutation(self.n_train)
sum_loss = 0
for i in xrange(0, self.n_train, batchsize):
x_batch = self.x_train[perm[i:i + batchsize]]
real_batchsize = len(x_batch)
self.optimizer.zero_grads()
loss = self.forward(x_batch)
loss.backward()
self.optimizer.update()
sum_loss += float(cuda.to_cpu(loss.data)) * real_batchsize
logging.info('train mean loss={}'.format(sum_loss / self.n_train))
# evaluation
sum_loss = 0
for i in xrange(0, self.n_test, batchsize):
x_batch = self.x_test[i:i + batchsize]
real_batchsize = len(x_batch)
loss = self.forward(x_batch, train=False)
sum_loss += float(cuda.to_cpu(loss.data)) * real_batchsize
logging.info('test mean loss={}'.format(sum_loss / self.n_test))
# Setup optimizer (Optimizer の設定)
# optimizer = optimizers.SGD(LEARNIN_RATE)
optimizer = optimizers.Adam()
optimizer.setup(model)
# # Init/Resume
if args.initmodel:
print('Load model from', args.initmodel)
serializers.load_hdf5(args.initmodel, model)
if args.resume:
print('Load optimizer state from', args.resume)
serializers.load_hdf5(args.resume, optimizer)
if args.gpu >= 0:
model.to_gpu()
# プロット用に実行結果を保存する
train_loss = []
train_acc = []
test_loss = []
test_acc = []
# Learning loop
for epoch in xrange(1, n_epoch + 1):
# training
# N 個の順番をランダムに並び替える
perm = np.random.permutation(N)
sum_accuracy = 0
sum_loss = 0
def Main():
import argparse
import numpy as np
from chainer import cuda, Variable, FunctionSet, optimizers
import chainer.functions as F
from loss_for_error import loss_for_error1, loss_for_error2
import six.moves.cPickle as pickle
parser = argparse.ArgumentParser(description='Chainer example: regression')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
batchsize = 20
n_epoch = NEpoch
n_units = 200 #TEST
# Prepare dataset
data_x, data_y = GenData(200, noise=0.5) #TEST: n samples, noise
#batchsize= max(1,min(batchsize, len(data_y)/10)) #TEST: adjust batchsize
batchsize = max(1, min(batchsize, len(data_y))) #TEST: adjust batchsize
#dx2,dy2=GenData(300, noise=0.0); data_x.extend(dx2); data_y.extend(dy2)
data = np.array(data_x).astype(np.float32)
target = np.array(data_y).astype(np.float32)
N = len(data) #batchsize * 30
x_train = data
y_train = target
y_err_train = np.array([[0.0] * y_train.shape[1]] *
y_train.shape[0]).astype(np.float32)
N_test = 50
x_test = np.array([[x] for x in FRange1(*Bound, num_div=N_test)
]).astype(np.float32)
y_test = np.array([[TrueFunc(x[0])] for x in x_test]).astype(np.float32)
y_err_test = np.array([[0.0] for x in x_test]).astype(np.float32)
print 'Num of samples for train:', len(y_train)
# Dump data for plot:
fp1 = file('/tmp/smpl_train.dat', 'w')
for x, y in zip(x_train, y_train):
fp1.write('%s #%i# %s\n' %
(' '.join(map(str, x)), len(x) + 1, ' '.join(map(str, y))))
fp1.close()
# Dump data for plot:
fp1 = file('/tmp/smpl_test.dat', 'w')
for x, y in zip(x_test, y_test):
fp1.write('%s #%i# %s\n' %
(' '.join(map(str, x)), len(x) + 1, ' '.join(map(str, y))))
fp1.close()
# Prepare multi-layer perceptron model
model = FunctionSet(l1=F.Linear(1, n_units),
l2=F.Linear(n_units, n_units),
l3=F.Linear(n_units, 1))
#TEST: Random bias initialization
b2 = [b for b in Bound]
model.l1.b[:] = [Rand(*b2) for k in range(n_units)]
model.l2.b[:] = [Rand(*b2) for k in range(n_units)]
model.l3.b[:] = [Rand(*b2) for k in range(1)]
# Error model
model_err = FunctionSet(l1=F.Linear(1, n_units),
l2=F.Linear(n_units, n_units),
l3=F.Linear(n_units, 1))
#TEST: Random bias initialization
#b2= [b for b in Bound]
b2 = [0.0, 0.5]
model_err.l1.b[:] = [Rand(*b2) for k in range(n_units)]
model_err.l2.b[:] = [Rand(*b2) for k in range(n_units)]
model_err.l3.b[:] = [Rand(*b2) for k in range(1)]
#TEST: load parameters from file:
#model.copy_parameters_from(pickle.load(open('datak/reg2c_mean.dat', 'rb')))
#model_err.copy_parameters_from(pickle.load(open('datak/reg2c_err.dat', 'rb')))
if args.gpu >= 0:
cuda.init(args.gpu)
model.to_gpu()
model_err.to_gpu()
# Neural net architecture
def forward(x_data, y_data, train=True):
#train= False #TEST: Turn off dropout
dratio = 0.2 #0.5 #TEST: Dropout ratio
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.relu(model.l1(x)), ratio=dratio, train=train)
h2 = F.dropout(F.relu(model.l2(h1)), ratio=dratio, train=train)
#h1 = F.dropout(F.softplus(model.l1(x),beta=10.0), ratio=dratio, train=train)
#h2 = F.dropout(F.softplus(model.l2(h1),beta=10.0), ratio=dratio, train=train)
#h1 = F.dropout(F.leaky_relu(model.l1(x),slope=0.2), ratio=dratio, train=train)
#h2 = F.dropout(F.leaky_relu(model.l2(h1),slope=0.2), ratio=dratio, train=train)
#h1 = F.dropout(F.sigmoid(model.l1(x)), ratio=dratio, train=train)
#h2 = F.dropout(F.sigmoid(model.l2(h1)), ratio=dratio, train=train)
#h1 = F.dropout(F.tanh(model.l1(x)), ratio=dratio, train=train)
#h2 = F.dropout(F.tanh(model.l2(h1)), ratio=dratio, train=train)
#h1 = F.dropout(model.l1(x), ratio=dratio, train=train)
#h2 = F.dropout(model.l2(h1), ratio=dratio, train=train)
#h1 = F.relu(model.l1(x))
#h2 = F.relu(model.l2(h1))
#h1 = model.l1(x)
#h2 = model.l2(h1)
y = model.l3(h2)
return F.mean_squared_error(y, t), y
# Neural net architecture
def forward_err(x_data, y_data, train=True):
#train= False #TEST: Turn off dropout
dratio = 0.2 #0.5 #TEST: Dropout ratio
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.relu(model_err.l1(x)), ratio=dratio, train=train)
h2 = F.dropout(F.relu(model_err.l2(h1)), ratio=dratio, train=train)
y = model_err.l3(h2)
#return F.mean_squared_error(y, t), y
#return loss_for_error1(y, t, 0.1), y #TEST
return loss_for_error2(y, t, 0.1), y #TEST
# Setup optimizer
optimizer = optimizers.AdaDelta(rho=0.9)
#optimizer = optimizers.AdaGrad(lr=0.5)
#optimizer = optimizers.RMSprop()
#optimizer = optimizers.MomentumSGD()
#optimizer = optimizers.SGD(lr=0.8)
optimizer.setup(model.collect_parameters())
optimizer_err = optimizers.AdaDelta(rho=0.9)
optimizer_err.setup(model_err.collect_parameters())
# Learning loop
for epoch in xrange(1, n_epoch + 1):
print 'epoch', epoch
# training
perm = np.random.permutation(N)
sum_loss = 0
# Train model
for i in xrange(0, N, batchsize):
x_batch = x_train[perm[i:i + batchsize]]
y_batch = y_train[perm[i:i + batchsize]]
if args.gpu >= 0:
x_batch = cuda.to_gpu(x_batch)
y_batch = cuda.to_gpu(y_batch)
optimizer.zero_grads()
loss, pred = forward(x_batch, y_batch)
loss.backward() #Computing gradients
optimizer.update()
#D= y_train.shape[1]
#y_err_train[perm[i:i+batchsize]] = np.array([[(y1[d]-y2[d])**2 for d in range(D)] for y1,y2 in zip(cuda.to_cpu(pred.data), y_train[perm[i:i+batchsize]]) ]).astype(np.float32)
sum_loss += float(cuda.to_cpu(loss.data)) * batchsize
print 'train mean loss={}'.format(sum_loss / N)
# Generate training data for error model
preds = []
x_batch = x_train[:]
y_batch = y_train[:]
if args.gpu >= 0:
x_batch = cuda.to_gpu(x_batch)
y_batch = cuda.to_gpu(y_batch)
loss, pred = forward(x_batch, y_batch, train=False)
D = y_train.shape[1]
#y_err_train = np.array([[abs(y2[d]-y1[d]) for d in range(D)] for y1,y2 in zip(cuda.to_cpu(pred.data), y_train) ]).astype(np.float32)
y_err_train = np.abs(cuda.to_cpu(pred.data) - y_train)
# Learning loop
if epoch in (
5,
99,
NEpoch,
):
for epoch2 in xrange(1, 200 + 1):
print '--epoch2', epoch2
# training
perm = np.random.permutation(N)
sum_loss = 0
# Train error model
for i in xrange(0, N, batchsize):
x_batch = x_train[perm[i:i + batchsize]]
y_batch = y_err_train[perm[i:i + batchsize]]
if args.gpu >= 0:
x_batch = cuda.to_gpu(x_batch)
y_batch = cuda.to_gpu(y_batch)
optimizer_err.zero_grads()
loss, pred = forward_err(x_batch, y_batch)
loss.backward() #Computing gradients
optimizer_err.update()
sum_loss += float(cuda.to_cpu(loss.data)) * batchsize
print 'train(error) mean loss={}'.format(sum_loss / N)
#'''
# testing all data
preds = []
x_batch = x_test[:]
y_batch = y_test[:]
y_err_batch = y_err_test[:]
if args.gpu >= 0:
x_batch = cuda.to_gpu(x_batch)
y_batch = cuda.to_gpu(y_batch)
y_err_batch = cuda.to_gpu(y_err_batch)
loss, pred = forward(x_batch, y_batch, train=False)
loss_err, pred_err = forward_err(x_batch, y_err_batch, train=False)
preds = cuda.to_cpu(pred.data)
preds_err = cuda.to_cpu(pred_err.data)
sum_loss = float(cuda.to_cpu(loss.data)) * len(y_test)
sum_loss_err = float(cuda.to_cpu(loss_err.data)) * len(y_test)
pearson = np.corrcoef(
np.asarray(preds).reshape(len(preds), ),
np.asarray(y_test).reshape(len(preds), ))
#'''
print 'test mean loss={}, corrcoef={}, error loss={}'.format(
sum_loss / N_test, pearson[0][1], sum_loss_err / N_test)
# Dump data for plot:
fp1 = file('/tmp/nn_test%04i.dat' % epoch, 'w')
for x, y, yerr in zip(x_test, preds, preds_err):
fp1.write('%s #%i# %s %s\n' %
(' '.join(map(str, x)), len(x) + 1, ' '.join(map(
str, y)), ' '.join(map(str, yerr))))
fp1.close()
fp1 = file('/tmp/smpl_train2.dat', 'w')
for x, y, yerr in zip(x_train, y_train, y_err_train):
fp1.write('%s #%i# %s %s\n' %
(' '.join(map(str, x)), len(x) + 1, ' '.join(map(
str, y)), ' '.join(map(str, yerr))))
fp1.close()
#Save parameters
pickle.dump(model.parameters, open('datak/reg2c_mean.dat', 'wb'), -1)
pickle.dump(model_err.parameters, open('datak/reg2c_err.dat', 'wb'), -1)
class QNet:
# Hyper-Parameters
gamma = 0.99 # Discount factor
initial_exploration = 10**3 # Initial exploratoin. original: 5x10^4
replay_size = 32 # Replay (batch) size
target_model_update_freq = 10**4 # Target update frequancy. original: 10^4
data_size = 10**5 # Data size of history. original: 10^6
hist_size = 1 #original: 4
def __init__(self, use_gpu, enable_controller, dim):
self.use_gpu = use_gpu
self.num_of_actions = len(enable_controller)
self.enable_controller = enable_controller
self.dim = dim
print("Initializing Q-Network...")
hidden_dim = 256
self.model = FunctionSet(
l4=F.Linear(self.dim*self.hist_size, hidden_dim, wscale=np.sqrt(2)),
q_value=F.Linear(hidden_dim, self.num_of_actions,
initialW=np.zeros((self.num_of_actions, hidden_dim),
dtype=np.float32))
)
if self.use_gpu >= 0:
self.model.to_gpu()
self.model_target = copy.deepcopy(self.model)
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, self.hist_size, self.dim), 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, self.hist_size, self.dim), dtype=np.uint8),
np.zeros((self.data_size, 1), dtype=np.bool)]
def forward(self, state, action, reward, state_dash, episode_end):
num_of_batch = state.shape[0]
s = Variable(state)
s_dash = Variable(state_dash)
q = self.q_func(s) # Get Q-value
# Generate Target Signals
tmp = self.q_func_target(s_dash) # Q(s',*)
if self.use_gpu >= 0:
tmp = list(map(np.max, tmp.data.get())) # max_a Q(s',a)
else:
tmp = list(map(np.max, tmp.data)) # max_a Q(s',a)
max_q_dash = np.asanyarray(tmp, dtype=np.float32)
if self.use_gpu >= 0:
target = np.asanyarray(q.data.get(), dtype=np.float32)
else:
# make new array
target = np.array(q.data, dtype=np.float32)
for i in xrange(num_of_batch):
if not episode_end[i][0]:
tmp_ = reward[i] + self.gamma * max_q_dash[i]
else:
tmp_ = reward[i]
action_index = self.action_to_index(action[i])
target[i, action_index] = tmp_
# TD-error clipping
if self.use_gpu >= 0:
target = cuda.to_gpu(target)
td = Variable(target) - q # TD error
td_tmp = td.data + 1000.0 * (abs(td.data) <= 1) # Avoid zero division
td_clip = td * (abs(td.data) <= 1) + td/abs(td_tmp) * (abs(td.data) > 1)
zero_val = np.zeros((self.replay_size, self.num_of_actions), dtype=np.float32)
if self.use_gpu >= 0:
zero_val = cuda.to_gpu(zero_val)
zero_val = Variable(zero_val)
loss = F.mean_squared_error(td_clip, zero_val)
return loss, q
def stock_experience(self, time,
state, action, reward, state_dash,
episode_end_flag):
data_index = time % self.data_size
if episode_end_flag is True:
self.d[0][data_index] = state
self.d[1][data_index] = action
self.d[2][data_index] = reward
else:
self.d[0][data_index] = state
self.d[1][data_index] = action
self.d[2][data_index] = reward
self.d[3][data_index] = state_dash
self.d[4][data_index] = episode_end_flag
def experience_replay(self, time):
if self.initial_exploration < time:
# Pick up replay_size number of samples from the Data
if time < self.data_size: # during the first sweep of the History Data
replay_index = np.random.randint(0, time, (self.replay_size, 1))
else:
replay_index = np.random.randint(0, self.data_size, (self.replay_size, 1))
s_replay = np.ndarray(shape=(self.replay_size, self.hist_size, self.dim), dtype=np.float32)
a_replay = np.ndarray(shape=(self.replay_size, 1), dtype=np.uint8)
r_replay = np.ndarray(shape=(self.replay_size, 1), dtype=np.float32)
s_dash_replay = np.ndarray(shape=(self.replay_size, self.hist_size, self.dim), dtype=np.float32)
episode_end_replay = np.ndarray(shape=(self.replay_size, 1), dtype=np.bool)
for i in xrange(self.replay_size):
s_replay[i] = np.asarray(self.d[0][replay_index[i]], dtype=np.float32)
a_replay[i] = self.d[1][replay_index[i]]
r_replay[i] = self.d[2][replay_index[i]]
s_dash_replay[i] = np.array(self.d[3][replay_index[i]], dtype=np.float32)
episode_end_replay[i] = self.d[4][replay_index[i]]
if self.use_gpu >= 0:
s_replay = cuda.to_gpu(s_replay)
s_dash_replay = cuda.to_gpu(s_dash_replay)
# Gradient-based update
self.optimizer.zero_grads()
loss, _ = self.forward(s_replay, a_replay, r_replay, s_dash_replay, episode_end_replay)
loss.backward()
self.optimizer.update()
def q_func(self, state):
h4 = F.relu(self.model.l4(state / 255.0))
q = self.model.q_value(h4)
return q
def q_func_target(self, state):
h4 = F.relu(self.model_target.l4(state / 255.0))
q = self.model_target.q_value(h4)
return q
def e_greedy(self, state, epsilon):
s = Variable(state)
q = self.q_func(s)
q = q.data
if np.random.rand() < epsilon:
index_action = np.random.randint(0, self.num_of_actions)
print(" Random"),
else:
if self.use_gpu >= 0:
index_action = np.argmax(q.get())
else:
index_action = np.argmax(q)
print("#Greedy"),
return self.index_to_action(index_action), q
def target_model_update(self):
self.model_target = copy.deepcopy(self.model)
def index_to_action(self, index_of_action):
return self.enable_controller[index_of_action]
def action_to_index(self, action):
return self.enable_controller.index(action)
class MLP(Base):
def __init__(self,
data=None,
target=None,
n_inputs=784,
n_hidden=784,
n_outputs=10,
gpu=-1):
self.excludes.append('xp')
self.model = FunctionSet(l1=F.Linear(n_inputs, n_hidden),
l2=F.Linear(n_hidden, n_hidden),
l3=F.Linear(n_hidden, n_outputs))
if gpu >= 0:
self.model.to_gpu()
self.xp = cuda.cupy
else:
self.xp = np
if not data is None:
self.x_train, self.x_test = data
else:
self.x_train, self.y_test = None, None
if not target is None:
self.y_train, self.y_test = target
self.n_train = len(self.y_train)
self.n_test = len(self.y_test)
else:
self.y_train, self.y_test = None, None
self.n_train = 0
self.n_test = 0
self.gpu = gpu
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
def forward(self, x_data, y_data, train=True):
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.relu(self.model.l1(x)), train=train)
h2 = F.dropout(F.relu(self.model.l2(h1)), train=train)
y = self.model.l3(h2)
return F.softmax_cross_entropy(y, t), F.accuracy(y, t)
def train_and_test(self, n_epoch=20, batchsize=100):
for epoch in xrange(1, n_epoch + 1):
print 'epoch', epoch
perm = np.random.permutation(self.n_train)
sum_accuracy = 0
sum_loss = 0
for i in xrange(0, self.n_train, batchsize):
x_batch = self.xp.asarray(self.x_train[perm[i:i + batchsize]])
y_batch = self.xp.asarray(self.y_train[perm[i:i + batchsize]])
real_batchsize = len(x_batch)
self.optimizer.zero_grads()
loss, acc = self.forward(x_batch, y_batch)
loss.backward()
self.optimizer.update()
sum_loss += float(cuda.to_cpu(loss.data)) * real_batchsize
sum_accuracy += float(cuda.to_cpu(acc.data)) * real_batchsize
print 'train mean loss={}, accuracy={}'.format(
sum_loss / self.n_train, sum_accuracy / self.n_train)
# evalation
sum_accuracy = 0
sum_loss = 0
for i in xrange(0, self.n_test, batchsize):
x_batch = self.xp.asarray(self.x_test[i:i + batchsize])
y_batch = self.xp.asarray(self.y_test[i:i + batchsize])
real_batchsize = len(x_batch)
loss, acc = self.forward(x_batch, y_batch, train=False)
sum_loss += float(cuda.to_cpu(loss.data)) * real_batchsize
sum_accuracy += float(cuda.to_cpu(acc.data)) * real_batchsize
print 'test mean loss={}, accuracy={}'.format(
sum_loss / self.n_test, sum_accuracy / self.n_test)
class QNet:
# Hyper-Parameters
gamma = 0.99 # Discount factor
initial_exploration = 10**4 # Initial exploratoin. original: 5x10^4
replay_size = 32 # Replay (batch) size
target_model_update_freq = 10**4 # Target update frequancy. original: 10^4
data_size = 10**5 # Data size of history. original: 10^6
hist_size = 1 #original: 4
def __init__(self, use_gpu, enable_controller, dim):
self.use_gpu = use_gpu
self.num_of_actions = len(enable_controller)
self.enable_controller = enable_controller
self.dim = dim
print("Initializing Q-Network...")
hidden_dim = 256
self.model = FunctionSet(l4=F.Linear(self.dim * self.hist_size,
hidden_dim,
wscale=np.sqrt(2)),
q_value=F.Linear(
hidden_dim,
self.num_of_actions,
initialW=np.zeros(
(self.num_of_actions, hidden_dim),
dtype=np.float32)))
if self.use_gpu >= 0:
self.model.to_gpu()
self.model_target = copy.deepcopy(self.model)
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, self.hist_size, self.dim),
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, self.hist_size, self.dim),
dtype=np.uint8),
np.zeros((self.data_size, 1), dtype=np.bool)
]
def forward(self, state, action, reward, state_dash, episode_end):
num_of_batch = state.shape[0]
s = Variable(state)
s_dash = Variable(state_dash)
q = self.q_func(s) # Get Q-value
# Generate Target Signals
tmp = self.q_func_target(s_dash) # Q(s',*)
if self.use_gpu >= 0:
tmp = list(map(np.max, tmp.data.get())) # max_a Q(s',a)
else:
tmp = list(map(np.max, tmp.data)) # max_a Q(s',a)
max_q_dash = np.asanyarray(tmp, dtype=np.float32)
if self.use_gpu >= 0:
target = np.asanyarray(q.data.get(), dtype=np.float32)
else:
# make new array
target = np.array(q.data, dtype=np.float32)
for i in xrange(num_of_batch):
if not episode_end[i][0]:
tmp_ = np.sign(reward[i]) + self.gamma * max_q_dash[i]
else:
tmp_ = np.sign(reward[i])
action_index = self.action_to_index(action[i])
target[i, action_index] = tmp_
# TD-error clipping
if self.use_gpu >= 0:
target = cuda.to_gpu(target)
td = Variable(target) - q # TD error
td_tmp = td.data + 1000.0 * (abs(td.data) <= 1) # Avoid zero division
td_clip = td * (abs(td.data) <= 1) + td / abs(td_tmp) * (abs(td.data) >
1)
zero_val = np.zeros((self.replay_size, self.num_of_actions),
dtype=np.float32)
if self.use_gpu >= 0:
zero_val = cuda.to_gpu(zero_val)
zero_val = Variable(zero_val)
loss = F.mean_squared_error(td_clip, zero_val)
return loss, q
def stock_experience(self, time, state, action, reward, state_dash,
episode_end_flag):
data_index = time % self.data_size
if episode_end_flag is True:
self.d[0][data_index] = state
self.d[1][data_index] = action
self.d[2][data_index] = reward
else:
self.d[0][data_index] = state
self.d[1][data_index] = action
self.d[2][data_index] = reward
self.d[3][data_index] = state_dash
self.d[4][data_index] = episode_end_flag
def experience_replay(self, time):
if self.initial_exploration < time:
# Pick up replay_size number of samples from the Data
if time < self.data_size: # during the first sweep of the History Data
replay_index = np.random.randint(0, time,
(self.replay_size, 1))
else:
replay_index = np.random.randint(0, self.data_size,
(self.replay_size, 1))
s_replay = np.ndarray(shape=(self.replay_size, self.hist_size,
self.dim),
dtype=np.float32)
a_replay = np.ndarray(shape=(self.replay_size, 1), dtype=np.uint8)
r_replay = np.ndarray(shape=(self.replay_size, 1),
dtype=np.float32)
s_dash_replay = np.ndarray(shape=(self.replay_size, self.hist_size,
self.dim),
dtype=np.float32)
episode_end_replay = np.ndarray(shape=(self.replay_size, 1),
dtype=np.bool)
for i in xrange(self.replay_size):
s_replay[i] = np.asarray(self.d[0][replay_index[i]],
dtype=np.float32)
a_replay[i] = self.d[1][replay_index[i]]
r_replay[i] = self.d[2][replay_index[i]]
s_dash_replay[i] = np.array(self.d[3][replay_index[i]],
dtype=np.float32)
episode_end_replay[i] = self.d[4][replay_index[i]]
if self.use_gpu >= 0:
s_replay = cuda.to_gpu(s_replay)
s_dash_replay = cuda.to_gpu(s_dash_replay)
# Gradient-based update
self.optimizer.zero_grads()
loss, _ = self.forward(s_replay, a_replay, r_replay, s_dash_replay,
episode_end_replay)
loss.backward()
self.optimizer.update()
def q_func(self, state):
h4 = F.relu(self.model.l4(state))
q = self.model.q_value(h4 / 255.0)
return q
def q_func_target(self, state):
h4 = F.relu(self.model_target.l4(state / 255.0))
q = self.model_target.q_value(h4)
return q
def e_greedy(self, state, epsilon):
s = Variable(state)
q = self.q_func(s)
q = q.data
if np.random.rand() < epsilon:
index_action = np.random.randint(0, self.num_of_actions)
print(" Random"),
else:
if self.use_gpu >= 0:
index_action = np.argmax(q.get())
else:
index_action = np.argmax(q)
print("#Greedy"),
return self.index_to_action(index_action), q
def target_model_update(self):
self.model_target = copy.deepcopy(self.model)
def index_to_action(self, index_of_action):
return self.enable_controller[index_of_action]
def action_to_index(self, action):
return self.enable_controller.index(action)
class SDA(object):
def __init__(
self,
rng,
data,
target,
n_inputs=784,
n_hidden=[784,784,784],
n_outputs=10,
corruption_levels=[0.1,0.2,0.3],
gpu=-1):
self.model = FunctionSet(
l1=F.Linear(n_inputs, n_hidden[0]),
l2=F.Linear(n_hidden[0], n_hidden[1]),
l3=F.Linear(n_hidden[1], n_hidden[2]),
l4=F.Linear(n_hidden[2], n_outputs)
)
if gpu >= 0:
self.model.to_gpu()
self.rng = rng
self.gpu = gpu
self.data = data
self.target = target
self.x_train, self.x_test = data
self.y_train, self.y_test = target
self.n_train = len(self.y_train)
self.n_test = len(self.y_test)
self.corruption_levels = corruption_levels
self.n_inputs = n_inputs
self.n_hidden = n_hidden
self.n_outputs = n_outputs
self.dae1 = None
self.dae2 = None
self.dae3 = None
self.optimizer = None
self.setup_optimizer()
self.train_accuracies = []
self.train_losses = []
self.test_accuracies = []
self.test_losses = []
def setup_optimizer(self):
self.optimizer = optimizers.AdaDelta()
self.optimizer.setup(self.model)
@property
def xp(self):
return cuda.cupy if self.gpu >= 0 else numpy
def pre_train(self, n_epoch=20, batchsize=100):
first_inputs = self.data
# initialize first dAE
self.dae1 = DA(self.rng,
data=first_inputs,
n_inputs=self.n_inputs,
n_hidden=self.n_hidden[0],
corruption_level=self.corruption_levels[0],
gpu=self.gpu)
# train first dAE
logging.info("--------First DA training has started!--------")
self.dae1.train_and_test(n_epoch=n_epoch, batchsize=batchsize)
self.dae1.to_cpu()
# compute second iputs for second dAE
tmp1 = self.dae1.compute_hidden(first_inputs[0])
tmp2 = self.dae1.compute_hidden(first_inputs[1])
if self.gpu >= 0:
self.dae1.to_gpu()
second_inputs = [tmp1, tmp2]
# initialize second dAE
self.dae2 = DA(
self.rng,
data=second_inputs,
n_inputs=self.n_hidden[0],
n_hidden=self.n_hidden[1],
corruption_level=self.corruption_levels[1],
gpu=self.gpu
)
# train second dAE
logging.info("--------Second DA training has started!--------")
self.dae2.train_and_test(n_epoch=n_epoch, batchsize=batchsize)
self.dae2.to_cpu()
# compute third inputs for third dAE
tmp1 = self.dae2.compute_hidden(second_inputs[0])
tmp2 = self.dae2.compute_hidden(second_inputs[1])
if self.gpu >= 0:
self.dae2.to_gpu()
third_inputs = [tmp1, tmp2]
# initialize third dAE
self.dae3 = DA(
self.rng,
data=third_inputs,
n_inputs=self.n_hidden[1],
n_hidden=self.n_hidden[2],
corruption_level=self.corruption_levels[2],
gpu=self.gpu
)
# train third dAE
logging.info("--------Third DA training has started!--------")
self.dae3.train_and_test(n_epoch=n_epoch, batchsize=batchsize)
# update model parameters
self.model.l1 = self.dae1.encoder()
self.model.l2 = self.dae2.encoder()
self.model.l3 = self.dae3.encoder()
self.setup_optimizer()
def forward(self, x_data, y_data, train=True):
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.relu(self.model.l1(x)), train=train)
h2 = F.dropout(F.relu(self.model.l2(h1)), train=train)
h3 = F.dropout(F.relu(self.model.l3(h2)), train=train)
y = self.model.l4(h3)
return F.softmax_cross_entropy(y, t), F.accuracy(y, t)
def fine_tune(self, n_epoch=20, batchsize=100):
for epoch in xrange(1, n_epoch+1):
logging.info('fine tuning epoch {}'.format(epoch))
perm = self.rng.permutation(self.n_train)
sum_accuracy = 0
sum_loss = 0
for i in xrange(0, self.n_train, batchsize):
x_batch = self.xp.asarray(self.x_train[perm[i:i+batchsize]])
y_batch = self.xp.asarray(self.y_train[perm[i:i+batchsize]])
real_batchsize = len(x_batch)
self.optimizer.zero_grads()
loss, acc = self.forward(x_batch, y_batch)
loss.backward()
self.optimizer.update()
sum_loss += float(cuda.to_cpu(loss.data)) * real_batchsize
sum_accuracy += float(cuda.to_cpu(acc.data)) * real_batchsize
logging.info(
'fine tuning train mean loss={}, accuracy={}'.format(
sum_loss / self.n_train,
sum_accuracy / self.n_train
)
)
self.train_accuracies.append(sum_accuracy / self.n_train)
self.train_losses.append(sum_loss / self.n_train)
# evaluation
sum_accuracy = 0
sum_loss = 0
for i in xrange(0, self.n_test, batchsize):
x_batch = self.xp.asarray(self.x_test[i:i+batchsize])
y_batch = self.xp.asarray(self.y_test[i:i+batchsize])
real_batchsize = len(x_batch)
loss, acc = self.forward(x_batch, y_batch, train=False)
sum_loss += float(cuda.to_cpu(loss.data)) * real_batchsize
sum_accuracy += float(cuda.to_cpu(acc.data)) * real_batchsize
logging.info(
'fine tuning test mean loss={}, accuracy={}'.format(
sum_loss / self.n_test,
sum_accuracy / self.n_test
)
)
self.test_accuracies.append(sum_accuracy / self.n_test)
self.test_losses.append(sum_loss / self.n_test)
return self.train_accuracies, self.test_accuracies
def main(dim):
# Prepare multi-layer perceptron model
print "using GPU number: {}".format(args.gpu)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
#initialize parameter matrix
l1_W = []
l2_W = []
l3_W = []
l1b_W = []
l2b_W = []
n_units = 4 * (dim * 2 + 1)
initializer = chainer.initializers.Normal()
modelL1 = FunctionSet(l1=F.Linear(2 * (dim * 2 + 1),
n_units,
initialW=initializer),
l2=F.Linear(n_units,
2 * (dim * 2 + 1),
initialW=initializer))
# Setup optimizer
optL1 = optimizers.Adam()
optL1.setup(modelL1)
modelL1.to_gpu()
# Neural net architecture
def pretrain_L1(x_data, ratio=0.5, train=True):
x = Variable(x_data)
h1 = F.dropout(F.sigmoid(modelL1.l1(x)), ratio=ratio, train=train)
y = F.dropout(F.sigmoid(modelL1.l2(h1)), ratio=ratio, train=train)
return F.mean_squared_error(y, x), h1.data
modelL2 = FunctionSet(l1=F.Linear(n_units, n_units, initialW=initializer),
l2=F.Linear(n_units, n_units, initialW=initializer))
# Setup optimizer
optL2 = optimizers.Adam()
optL2.setup(modelL2)
modelL2.to_gpu()
# Neural net architecture
def pretrain_L2(x_data, ratio=0.5, train=True):
x = Variable(x_data)
h1 = F.dropout(F.sigmoid(modelL2.l1(x)), ratio=ratio, train=train)
y = F.dropout(F.sigmoid(modelL2.l2(h1)), ratio=ratio, train=train)
return F.mean_squared_error(y, x), h1.data
# h5dataset = h5py.File("dataset.h5","w")
dir = '/mnt/aoni02/uchida/work/selectfrq_estimated_data/'
# h5dataset.create_group(dir)
learned_data = 0
pretrainsize = 2700
learnsize = 2700
testsize = 100
HFFTL = 513
m20dB_signal = sorted(glob.glob('-20dB_estimated_data/safia1_*.wav'))
m20dB_noise = sorted(glob.glob('-20dB_estimated_data/safia2_*.wav'))
m10dB_signal = sorted(glob.glob('-10dB_estimated_data/safia1_*.wav'))
m10dB_noise = sorted(glob.glob('-10dB_estimated_data/safia2_*.wav'))
m5dB_signal = sorted(glob.glob('-5dB_estimated_data/safia1_*.wav'))
m5dB_noise = sorted(glob.glob('-5dB_estimated_data/safia2_*.wav'))
zerosignal = sorted(glob.glob('estimated_data/safia1_*.wav'))
zeronoise = sorted(glob.glob('estimated_data/safia2_*.wav'))
p5dB_signal = sorted(glob.glob('5dB_estimated_data/safia1_*.wav'))
p5dB_noise = sorted(glob.glob('5dB_estimated_data/safia2_*.wav'))
p10dB_signal = sorted(glob.glob('10dB_estimated_data/safia1_*.wav'))
p10dB_noise = sorted(glob.glob('10dB_estimated_data/safia2_*.wav'))
estimated_signal = [[]]
estimated_noise = [[]]
#learning_dataset
estimated_signal[0:learnsize / 5] = m10dB_signal[0:learnsize / 5]
estimated_signal[learnsize / 5:2 * learnsize /
5] = m5dB_signal[learnsize / 5:2 * learnsize / 5]
estimated_signal[2 * learnsize / 5:3 * learnsize /
5] = zerosignal[2 * learnsize / 5:3 * learnsize / 5]
estimated_signal[3 * learnsize / 5:4 * learnsize /
5] = p5dB_signal[3 * learnsize / 5:4 * learnsize / 5]
estimated_signal[4 * learnsize / 5:5 * learnsize /
5] = p10dB_signal[4 * learnsize / 5:5 * learnsize / 5]
#test_dataset
# estimated_signal[learnsize:learnsize+testsize] = m10dB_signal[0:testsize]
# estimated_signal[learnsize+testsize:learnsize+2*testsize] = m5dB_signal[testsize:testsize*2]
# estimated_signal[learnsize+2*testsize:learnsize+3*testsize] = zerosignal[testsize*2:testsize*3]
# estimated_signal[learnsize+3*testsize:learnsize+4*testsize] = p5dB_signal[testsize*3:testsize*4]
# estimated_signal[learnsize+4*testsize:learnsize+5*testsize] = p10dB_signal[testsize*4:testsize*5]
estimated_signal[learnsize:learnsize +
testsize] = m10dB_signal[learnsize:learnsize + testsize]
estimated_signal[learnsize + testsize:learnsize +
2 * testsize] = m5dB_signal[learnsize:learnsize +
testsize]
estimated_signal[learnsize + 2 * testsize:learnsize +
3 * testsize] = zerosignal[learnsize:learnsize + testsize]
estimated_signal[learnsize + 3 * testsize:learnsize +
4 * testsize] = p5dB_signal[learnsize:learnsize +
testsize]
estimated_signal[learnsize + 4 * testsize:learnsize +
5 * testsize] = p10dB_signal[learnsize:learnsize +
testsize]
estimated_signal[learnsize + 5 * testsize:learnsize +
6 * testsize] = m20dB_signal[learnsize:learnsize +
testsize]
estimated_noise[0:learnsize / 5] = m10dB_noise[0:learnsize / 5]
estimated_noise[learnsize / 5:2 * learnsize /
5] = m5dB_noise[learnsize / 5:2 * learnsize / 5]
estimated_noise[2 * learnsize / 5:3 * learnsize /
5] = zeronoise[2 * learnsize / 5:3 * learnsize / 5]
estimated_noise[3 * learnsize / 5:4 * learnsize /
5] = p5dB_noise[3 * learnsize / 5:4 * learnsize / 5]
estimated_noise[4 * learnsize / 5:5 * learnsize /
5] = p10dB_noise[4 * learnsize / 5:5 * learnsize / 5]
# estimated_noise[learnsize:learnsize+testsize] = m10dB_noise[0:testsize]
# estimated_noise[learnsize+testsize:learnsize+2*testsize] = m5dB_noise[testsize:testsize*2]
# estimated_noise[learnsize+2*testsize:learnsize+3*testsize] = zeronoise[testsize*2:testsize*3]
# estimated_noise[learnsize+3*testsize:learnsize+4*testsize] = p5dB_noise[testsize*3:testsize*4]
# estimated_noise[learnsize+4*testsize:learnsize+5*testsize] = p10dB_noise[testsize*4:testsize*5]
estimated_noise[learnsize:learnsize +
testsize] = m10dB_noise[learnsize:learnsize + testsize]
estimated_noise[learnsize + testsize:learnsize +
2 * testsize] = m5dB_noise[learnsize:learnsize + testsize]
estimated_noise[learnsize + 2 * testsize:learnsize +
3 * testsize] = zeronoise[learnsize:learnsize + testsize]
estimated_noise[learnsize + 3 * testsize:learnsize +
4 * testsize] = p5dB_noise[learnsize:learnsize + testsize]
estimated_noise[learnsize + 4 * testsize:learnsize +
5 * testsize] = p10dB_noise[learnsize:learnsize + testsize]
estimated_noise[learnsize + 5 * testsize:learnsize +
6 * testsize] = m20dB_noise[learnsize:learnsize + testsize]
teacher_signal = sorted(
glob.glob("/mnt/aoni02/uchida/work/origin_data/teacher/*.wav"))
def DNNbasedWienerfilter():
#pretrain loop
startexec = time.time()
for epoch in xrange(pretrain_epoch):
print "now proc: pretraining epoch{}".format(epoch)
startepoch = time.time()
perm = np.random.permutation(learnsize)
for idx in np.arange(0, pretrainsize,
3): #utterance Number training dataset
# start = time.time()
x_batch = np.empty((0, HFFTL * 2), float)
for iter in xrange(3):
fs, signal_data = read(estimated_signal[perm[idx + iter]],
"r")
fs, noise_data = read(estimated_noise[perm[idx + iter]],
"r")
signal_data = signal_data / np.sqrt(np.mean(signal_data**
2))
noise_data = noise_data / np.sqrt(np.mean(noise_data**2))
#FFT
Sspectrum_, synparam = FFTanalysis.FFTanalysis(signal_data)
Nspectrum_, synparam = FFTanalysis.FFTanalysis(noise_data)
N_FRAMES = np.shape(Sspectrum_)[0]
HFFTL = np.shape(Sspectrum_)[1]
x_data = np.zeros((N_FRAMES, HFFTL * 2))
for nframe in xrange(N_FRAMES):
spectrum = np.append(Sspectrum_[nframe],
Nspectrum_[nframe])
x_data[nframe] = [
np.sqrt(c.real**2 + c.imag**2) for c in spectrum
] #DNN indata
if iter == 0:
x_batch = np.append(x_batch, x_data, axis=0)
else:
x_batch = np.vstack((x_batch, x_data))
for frq in xrange(HFFTL):
x_frqbatch = np.zeros(
(np.shape(x_batch)[0], 2 * (dim * 2 + 1)), float)
x_frqbatch[:, dim] = x_batch[:, frq]
x_frqbatch[:, dim * 3 + 1] = x_batch[:, frq + HFFTL]
for j in np.arange(1, dim + 1):
if (frq - j) >= 0:
x_frqbatch[:, dim - j] = x_batch[:, frq - j]
x_frqbatch[:, dim * 3 + 1 - j] = x_batch[:, frq +
HFFTL - j]
if ((HFFTL - 1) - (j + frq)) >= 0:
x_frqbatch[:, dim + j] = x_batch[:, frq + j]
x_frqbatch[:, dim * 3 + 1 + j] = x_batch[:, frq +
HFFTL + j]
x_frqbatch = x_frqbatch.astype(np.float32)
if epoch != 0 or idx != 0: #except first batch
modelL1.l1.W.data = cuda.to_gpu(l1_W.pop(0))
modelL2.l1.W.data = cuda.to_gpu(l2_W.pop(0))
modelL1.l2.W.data = cuda.to_gpu(l1b_W.pop(0))
modelL2.l2.W.data = cuda.to_gpu(l2b_W.pop(0))
# training
if args.gpu >= 0:
x_frqbatch = cuda.to_gpu(x_frqbatch)
optL1.zero_grads()
loss, hidden = pretrain_L1(x_frqbatch, ratio=0.5)
loss.backward()
optL1.update()
optL2.zero_grads()
loss, hidden = pretrain_L2(hidden, ratio=0.5)
loss.backward()
optL2.update()
#model parameter saving
l1_W.append(cuda.to_cpu(modelL1.l1.W.data))
l2_W.append(cuda.to_cpu(modelL2.l1.W.data))
l1b_W.append(cuda.to_cpu(modelL1.l2.W.data))
l2b_W.append(cuda.to_cpu(modelL2.l2.W.data))
print 'pretrain epoch time:{0}sec'.format(
np.round(time.time() - startepoch, decimals=2))
# learning loop
model = FunctionSet(l1=F.Linear(2 * (dim * 2 + 1),
n_units,
initialW=initializer),
l2=F.Linear(n_units, n_units,
initialW=initializer),
l3=F.Linear(n_units, 1, initialW=initializer))
# Setup optimizer
optimizer = optimizers.Adam()
optimizer.setup(model)
model.to_gpu()
# Neural net architecture
def forward(x_data, y_data, ratio=0.5, train=True):
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.sigmoid(model.l1(x)), ratio=ratio, train=train)
h2 = F.dropout(F.sigmoid(model.l2(h1)), ratio=ratio, train=train)
y = model.l3(h2)
return F.mean_squared_error(y, t), y
startexec = time.time()
for epoch in xrange(n_epoch):
print "now proc: learning epoch{}".format(epoch)
startepoch = time.time()
perm = np.random.permutation(learnsize)
for idx in np.arange(0, learnsize,
3): #utterance Number training dataset
# start = time.time()
x_batch = np.empty((0, HFFTL * 2), float)
y_batch = np.empty((0, HFFTL), float)
for iter in xrange(3):
fs, signal_data = read(estimated_signal[perm[idx + iter]],
"r")
fs, noise_data = read(estimated_noise[perm[idx + iter]],
"r")
fs, teacher_data = read(teacher_signal[perm[idx + iter]],
"r")
signal_data = signal_data / np.sqrt(np.mean(signal_data**
2))
noise_data = noise_data / np.sqrt(np.mean(noise_data**2))
teacher_data = teacher_data / np.sqrt(
np.mean(teacher_data**2))
#FFT
Sspectrum_, synparam = FFTanalysis.FFTanalysis(signal_data)
Nspectrum_, synparam = FFTanalysis.FFTanalysis(noise_data)
Tspectrum_, synparam = FFTanalysis.FFTanalysis(
teacher_data)
N_FRAMES = np.shape(Sspectrum_)[0]
HFFTL = np.shape(Sspectrum_)[1]
x_data = np.zeros((N_FRAMES, HFFTL * 2))
y_data = np.zeros((N_FRAMES, HFFTL))
if epoch == 0:
learned_data += N_FRAMES
for nframe in xrange(N_FRAMES):
spectrum = np.append(Sspectrum_[nframe],
Nspectrum_[nframe])
x_data[nframe] = [
np.sqrt(c.real**2 + c.imag**2) for c in spectrum
] #DNN indata
#phaseSpectrum = [np.arctan2(c.imag, c.real) for c in spectrum]
Spower = np.array([
np.sqrt(c.real**2 + c.imag**2)
for c in Sspectrum_[nframe]
])
Tpower = np.array([
np.sqrt(c.real**2 + c.imag**2)
for c in Tspectrum_[nframe]
])
for i, x in enumerate(Spower):
if x == 0:
Spower[i] = 1e-10
y_data[nframe] = Tpower / Spower
if iter == 0:
x_batch = np.append(x_batch, x_data, axis=0)
y_batch = np.append(y_batch, y_data, axis=0)
else:
x_batch = np.vstack((x_batch, x_data))
y_batch = np.vstack((y_batch, y_data))
for frq in xrange(HFFTL):
x_frqbatch = np.zeros(
(np.shape(x_batch)[0], 2 * (dim * 2 + 1)), float)
x_frqbatch[:, dim] = x_batch[:, frq]
x_frqbatch[:, dim * 3 + 1] = x_batch[:, frq + HFFTL]
for j in np.arange(1, dim + 1):
if (frq - j) >= 0:
x_frqbatch[:, dim - j] = x_batch[:, frq - j]
x_frqbatch[:, dim * 3 + 1 - j] = x_batch[:, frq +
HFFTL - j]
if ((HFFTL - 1) - (j + frq)) >= 0:
x_frqbatch[:, dim + j] = x_batch[:, frq + j]
x_frqbatch[:, dim * 3 + 1 + j] = x_batch[:, frq +
HFFTL + j]
y_frqbatch = np.zeros((np.shape(y_batch)[0], 1), float)
y_frqbatch = y_batch[:,
frq].reshape(np.shape(y_batch)[0], 1)
x_frqbatch = x_frqbatch.astype(np.float32)
y_frqbatch = y_frqbatch.astype(np.float32)
model.l1.W.data = cuda.to_gpu(l1_W.pop(0))
model.l2.W.data = cuda.to_gpu(l2_W.pop(0))
if epoch != 0 or idx != 0: #except first batch
model.l3.W.data = cuda.to_gpu(l3_W.pop(0))
# training
if args.gpu >= 0:
x_frqbatch = cuda.to_gpu(x_frqbatch)
y_frqbatch = cuda.to_gpu(y_frqbatch)
optimizer.zero_grads()
loss, pred = forward(x_frqbatch, y_frqbatch, ratio=0.5)
loss.backward()
optimizer.update()
#model parameter saving
l1_W.append(cuda.to_cpu(model.l1.W.data))
l2_W.append(cuda.to_cpu(model.l2.W.data))
l3_W.append(cuda.to_cpu(model.l3.W.data))
print 'epoch time:{0}sec'.format(
np.round(time.time() - startepoch, decimals=2))
f = open('selectfrq_estimated_data/pretrain_write1.csv', 'w')
writer = csv.writer(f)
writer.writerows(l1_W)
f.close()
f = open('selectfrq_estimated_data/pretrain_write2.csv', 'w')
writer = csv.writer(f)
writer.writerows(l2_W)
f.close()
f = open('selectfrq_estimated_data/pretrain_write3.csv', 'w')
writer = csv.writer(f)
writer.writerows(l3_W)
f.close()
#test loop
SNRList = ["-10dB", "-5dB", "0dB", "5dB", "10dB", "-20dB"]
for SNRnum, SNR in enumerate(SNRList): #-10,-5,0,5,10,-20dB
loss_sum = np.zeros(testsize)
for idx in np.arange(learnsize + SNRnum * testsize,
learnsize + (SNRnum + 1) * testsize):
fs, signal_data = read(estimated_signal[idx], "r")
fs, noise_data = read(estimated_noise[idx], "r")
fs, teacher_data = read(
teacher_signal[idx - testsize * SNRnum], "r")
signal_data = signal_data / np.sqrt(np.mean(signal_data**2))
noise_data = noise_data / np.sqrt(np.mean(noise_data**2))
teacher_data = teacher_data / np.sqrt(np.mean(teacher_data**2))
Sspectrum_, synparam = FFTanalysis.FFTanalysis(signal_data)
Nspectrum_, synparam = FFTanalysis.FFTanalysis(noise_data)
Tspectrum_, synparam = FFTanalysis.FFTanalysis(teacher_data)
N_FRAMES = np.shape(Sspectrum_)[0]
HFFTL = np.shape(Sspectrum_)[1]
x_data = np.zeros((N_FRAMES, HFFTL * 2))
y_data = np.zeros((N_FRAMES, HFFTL))
for nframe in xrange(N_FRAMES):
spectrum = np.append(Sspectrum_[nframe],
Nspectrum_[nframe])
x_data[nframe] = [
np.sqrt(c.real**2 + c.imag**2) for c in spectrum
] #DNN indata
#phaseSpectrum = [np.arctan2(c.imag, c.real) for c in spectrum]
Spower = np.array([
np.sqrt(c.real**2 + c.imag**2)
for c in Sspectrum_[nframe]
])
Tpower = np.array([
np.sqrt(c.real**2 + c.imag**2)
for c in Tspectrum_[nframe]
])
for i, x in enumerate(Spower):
if x == 0:
Spower[i] = 1e-10
y_data[nframe] = Tpower / Spower
calcSNR = np.empty((N_FRAMES, 0), float)
totalloss = np.zeros(HFFTL, float)
# testing
for frq in xrange(HFFTL):
model.l1.W.data = cuda.to_gpu(l1_W[frq])
model.l2.W.data = cuda.to_gpu(l2_W[frq])
model.l3.W.data = cuda.to_gpu(l3_W[frq])
# testing
x_frqdata = np.zeros(
(np.shape(x_data)[0], 2 * (dim * 2 + 1)), float)
x_frqdata[:, dim] = x_data[:, frq]
x_frqdata[:, dim * 3 + 1] = x_data[:, frq + HFFTL]
for j in np.arange(1, dim + 1):
if (frq - j) >= 0:
x_frqdata[:, dim - j] = x_data[:, frq - j]
x_frqdata[:, dim * 3 + 1 - j] = x_data[:, frq +
HFFTL - j]
if ((HFFTL - 1) - (j + frq)) >= 0:
x_frqdata[:, dim + j] = x_data[:, frq + j]
x_frqdata[:, dim * 3 + 1 + j] = x_data[:, frq +
HFFTL + j]
y_frqdata = np.zeros((np.shape(y_data)[0], 1), float)
y_frqdata = y_data[:, frq].reshape(np.shape(y_data)[0], 1)
x_frqdata = x_frqdata.astype(np.float32)
y_frqdata = y_frqdata.astype(np.float32)
if args.gpu >= 0:
x_frqdata = cuda.to_gpu(x_frqdata)
y_frqdata = cuda.to_gpu(y_frqdata)
loss, pred = forward(x_frqdata, y_frqdata, train=False)
totalloss[frq] = cuda.to_cpu(loss.data)
pred = np.reshape(cuda.to_cpu(pred.data), (N_FRAMES, 1))
calcSNR = np.append(calcSNR, pred, axis=1)
fs, teacher_data = read(
teacher_signal[idx - testsize * SNRnum], "r")
if teacher_data.dtype == "int16":
teacher_data = teacher_data / norm
y_out = Sspectrum_ * calcSNR
wf_signal = FFTanalysis.Synth(y_out, synparam, BPFon=0)
wf_signal = wf_signal * np.sqrt(
np.mean(teacher_data**2) / np.mean(wf_signal**2))
write(
dir + SNR + "/dim{}_DNNbased_No{}.wav".format(
dim, idx - testsize * SNRnum), Fs, wf_signal)
print 'exec time:{0}sec'.format(
np.round(time.time() - startexec, decimals=2))
print "data: ", learned_data
def load_model():
# learning loop
model = FunctionSet(l1=F.Linear(2 * (dim * 2 + 1),
n_units,
initialW=initializer),
l2=F.Linear(n_units, n_units,
initialW=initializer),
l3=F.Linear(n_units, 1, initialW=initializer))
# Setup optimizer
optimizer = optimizers.Adam()
optimizer.setup(model)
model.to_gpu()
# Neural net architecture
def forward(x_data, y_data, ratio=0.5, train=True):
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.sigmoid(model.l1(x)), ratio=ratio, train=train)
h2 = F.dropout(F.sigmoid(model.l2(h1)), ratio=ratio, train=train)
y = model.l3(h2)
return F.mean_squared_error(y, t), y
with open('selectfrq_estimated_data/pretrain_write1.csv',
'r') as csvfile:
readfile = csv.reader(csvfile)
for row in readfile:
print len(row)
# print row
l1_W.append(row)
with open('selectfrq_estimated_data/pretrain_write2.csv',
"r") as csvfile:
reader = csv.reader(csvfile)
for row in reader:
# print row
l2_W.append(row)
with open('selectfrq_estimated_data/pretrain_write3.csv',
"r") as csvfile:
reader = csv.reader(csvfile)
for row in reader:
# print row
l3_W.append(row)
#test loop
SNRList = ["-10dB", "-5dB", "0dB", "5dB", "10dB", "-20dB"]
for SNRnum, SNR in enumerate(SNRList): #-10,-5,0,5,10,-20dB
loss_sum = np.zeros(testsize)
for idx in np.arange(learnsize + SNRnum * testsize,
learnsize + (SNRnum + 1) * testsize):
fs, signal_data = read(estimated_signal[idx], "r")
fs, noise_data = read(estimated_noise[idx], "r")
fs, teacher_data = read(
teacher_signal[idx - testsize * SNRnum], "r")
signal_data = signal_data / np.sqrt(np.mean(signal_data**2))
noise_data = noise_data / np.sqrt(np.mean(noise_data**2))
teacher_data = teacher_data / np.sqrt(np.mean(teacher_data**2))
Sspectrum_, synparam = FFTanalysis.FFTanalysis(signal_data)
Nspectrum_, synparam = FFTanalysis.FFTanalysis(noise_data)
Tspectrum_, synparam = FFTanalysis.FFTanalysis(teacher_data)
N_FRAMES = np.shape(Sspectrum_)[0]
HFFTL = np.shape(Sspectrum_)[1]
x_data = np.zeros((N_FRAMES, HFFTL * 2))
y_data = np.zeros((N_FRAMES, HFFTL))
for nframe in xrange(N_FRAMES):
spectrum = np.append(Sspectrum_[nframe],
Nspectrum_[nframe])
x_data[nframe] = [
np.sqrt(c.real**2 + c.imag**2) for c in spectrum
] #DNN indata
#phaseSpectrum = [np.arctan2(c.imag, c.real) for c in spectrum]
Spower = np.array([
np.sqrt(c.real**2 + c.imag**2)
for c in Sspectrum_[nframe]
])
Tpower = np.array([
np.sqrt(c.real**2 + c.imag**2)
for c in Tspectrum_[nframe]
])
for i, x in enumerate(Spower):
if x == 0:
Spower[i] = 1e-10
y_data[nframe] = Tpower / Spower
calcSNR = np.empty((N_FRAMES, 0), float)
totalloss = np.zeros(HFFTL, float)
# testing
for frq in xrange(HFFTL):
model.l1.W.data = cuda.to_gpu(l1_W[frq])
model.l2.W.data = cuda.to_gpu(l2_W[frq])
model.l3.W.data = cuda.to_gpu(l3_W[frq])
# testing
x_frqdata = np.zeros(
(np.shape(x_data)[0], 2 * (dim * 2 + 1)), float)
x_frqdata[:, dim] = x_data[:, frq]
x_frqdata[:, dim * 3 + 1] = x_data[:, frq + HFFTL]
for j in np.arange(1, dim + 1):
if (frq - j) >= 0:
x_frqdata[:, dim - j] = x_data[:, frq - j]
x_frqdata[:, dim * 3 + 1 - j] = x_data[:, frq +
HFFTL - j]
if ((HFFTL - 1) - (j + frq)) >= 0:
x_frqdata[:, dim + j] = x_data[:, frq + j]
x_frqdata[:, dim * 3 + 1 + j] = x_data[:, frq +
HFFTL + j]
y_frqdata = np.zeros((np.shape(y_data)[0], 1), float)
y_frqdata = y_data[:, frq].reshape(np.shape(y_data)[0], 1)
x_frqdata = x_frqdata.astype(np.float32)
y_frqdata = y_frqdata.astype(np.float32)
if args.gpu >= 0:
x_frqdata = cuda.to_gpu(x_frqdata)
y_frqdata = cuda.to_gpu(y_frqdata)
loss, pred = forward(x_frqdata, y_frqdata, train=False)
totalloss[frq] = cuda.to_cpu(loss.data)
pred = np.reshape(cuda.to_cpu(pred.data), (N_FRAMES, 1))
calcSNR = np.append(calcSNR, pred, axis=1)
fs, teacher_data = read(
teacher_signal[idx - testsize * SNRnum], "r")
if teacher_data.dtype == "int16":
teacher_data = teacher_data / norm
y_out = Sspectrum_ * calcSNR
wf_signal = FFTanalysis.Synth(y_out, synparam, BPFon=0)
wf_signal = wf_signal * np.sqrt(
np.mean(teacher_data**2) / np.mean(wf_signal**2))
write(
dir + SNR + "/dim{}_DNNbased_No{}.wav".format(
dim, idx - testsize * SNRnum), Fs, wf_signal)
def run():
start = time.time()
# DNNbasedWienerfilter()
load_model()
elasped_time = int(time.time() - start)
sec = elasped_time % 60
minute = elasped_time / 60
print 'elasped time:{0}min {1}sec'.format(minute, sec)
if __name__ == '__main__':
run()
def Main():
import argparse
import numpy as np
from sklearn.datasets import load_diabetes
from chainer import cuda, Variable, FunctionSet, optimizers
import chainer.functions as F
parser = argparse.ArgumentParser(description='Chainer example: regression')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
batchsize = 13
n_epoch = 100
n_units = 30
# Prepare dataset
print 'fetch diabetes dataset'
diabetes = load_diabetes()
data = diabetes['data'].astype(np.float32)
target = diabetes['target'].astype(np.float32).reshape(
len(diabetes['target']), 1)
N = batchsize * 30 #Number of training data
x_train, x_test = np.split(data, [N])
y_train, y_test = np.split(target, [N])
N_test = y_test.size
print 'Num of samples for train:', len(y_train)
print 'Num of samples for test:', len(y_test)
# Dump data for plot:
fp1 = file('/tmp/smpl_train.dat', 'w')
for x, y in zip(x_train, y_train):
fp1.write('%s #%i# %s\n' %
(' '.join(map(str, x)), len(x) + 1, ' '.join(map(str, y))))
fp1.close()
# Dump data for plot:
fp1 = file('/tmp/smpl_test.dat', 'w')
for x, y in zip(x_test, y_test):
fp1.write('%s #%i# %s\n' %
(' '.join(map(str, x)), len(x) + 1, ' '.join(map(str, y))))
fp1.close()
# Prepare multi-layer perceptron model
model = FunctionSet(l1=F.Linear(10, n_units),
l2=F.Linear(n_units, n_units),
l3=F.Linear(n_units, 1))
if args.gpu >= 0:
cuda.init(args.gpu)
model.to_gpu()
# Neural net architecture
def forward(x_data, y_data, train=True):
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.relu(model.l1(x)), train=train)
h2 = F.dropout(F.relu(model.l2(h1)), train=train)
y = model.l3(h2)
return F.mean_squared_error(y, t), y
# Setup optimizer
optimizer = optimizers.AdaDelta(rho=0.9)
optimizer.setup(model.collect_parameters())
# Learning loop
for epoch in xrange(1, n_epoch + 1):
print 'epoch', epoch
# training
perm = np.random.permutation(N)
sum_loss = 0
for i in xrange(0, N, batchsize):
x_batch = x_train[perm[i:i + batchsize]]
y_batch = y_train[perm[i:i + batchsize]]
if args.gpu >= 0:
x_batch = cuda.to_gpu(x_batch)
y_batch = cuda.to_gpu(y_batch)
optimizer.zero_grads()
loss, pred = forward(x_batch, y_batch)
loss.backward()
optimizer.update()
sum_loss += float(cuda.to_cpu(loss.data)) * batchsize
print 'train mean loss={}'.format(sum_loss / N)
'''
# testing per batch
sum_loss = 0
preds = []
for i in xrange(0, N_test, batchsize):
x_batch = x_test[i:i+batchsize]
y_batch = y_test[i:i+batchsize]
if args.gpu >= 0:
x_batch = cuda.to_gpu(x_batch)
y_batch = cuda.to_gpu(y_batch)
loss, pred = forward(x_batch, y_batch, train=False)
preds.extend(cuda.to_cpu(pred.data))
sum_loss += float(cuda.to_cpu(loss.data)) * batchsize
pearson = np.corrcoef(np.asarray(preds).reshape(len(preds),), np.asarray(y_test).reshape(len(preds),))
#'''
#'''
# testing all data
preds = []
x_batch = x_test[:]
y_batch = y_test[:]
if args.gpu >= 0:
x_batch = cuda.to_gpu(x_batch)
y_batch = cuda.to_gpu(y_batch)
loss, pred = forward(x_batch, y_batch, train=False)
preds = cuda.to_cpu(pred.data)
sum_loss = float(cuda.to_cpu(loss.data)) * len(y_test)
pearson = np.corrcoef(
np.asarray(preds).reshape(len(preds), ),
np.asarray(y_test).reshape(len(preds), ))
#'''
print 'test mean loss={}, corrcoef={}'.format(sum_loss / N_test,
pearson[0][1])
# Dump data for plot:
fp1 = file('/tmp/nn_test%04i.dat' % epoch, 'w')
for x, y in zip(x_test, preds):
fp1.write(
'%s #%i# %s\n' %
(' '.join(map(str, x)), len(x) + 1, ' '.join(map(str, y))))
fp1.close()
conv10=F.Convolution2D(256, 256, (1, 2)),
fc11=F.Linear(256 * 10 * 1, 1024),
norm1=F.BatchNormalization(1024),
fc12=F.Linear(1024, 1024),
norm2=F.BatchNormalization(1024),
fc13=F.Linear(1024, 3))
#optimizer = optimizers.MomentumSGD(lr=LR, momentum=0.9)
#optimizer = optimizers.SMORMS3(lr=LR, eps=1e-16)
#optimizer = optimizers.AdaGrad(lr=LR)
optimizer = optimizers.NesterovAG(lr=LR, momentum=0.9)
optimizer.setup(model)
if GPU_ID >= 0:
cuda.get_device(GPU_ID).use()
model.to_gpu(GPU_ID)
print 'show train_index,test_index'
print train_index
print test_index
print 'Fold %d ' % (c_f)
N_test = test_index.shape[0]
max_accuracy = 0
#訓練のために所見数を仮想的にupsample
#まずは各状態の数をカウント
state_num = []
parts = []
#NV,EP,PD,SCの順
fixed_layer = F.Linear(n_unitslist[layer_id], n_unitslist[layer_id + 1])
fixed_layer.W = encoded_Ws[layer_id]
fixed_layer.b = encoded_bs[layer_id]
setattr(ae_fix_model, "l" + str(layer_id + 1), fixed_layer)
setattr(
ae_model,
"l" + str(training_layer_id + 1),
F.Linear(n_unitslist[training_layer_id], n_unitslist[training_layer_id + 1]),
)
setattr(
ae_model,
"r" + str(training_layer_id + 1),
F.Linear(n_unitslist[training_layer_id + 1], n_unitslist[training_layer_id]),
)
ae_fix_model = ae_fix_model.to_gpu()
ae_model = ae_model.to_gpu()
ae_optimizer = optimizers.Adam()
ae_optimizer.setup(ae_model)
# training
perm = np.random.permutation(n_train_batchset)
sum_loss = 0
for i in range(0, n_train_batchset, batchsize):
x_batch = cuda.to_gpu(x_train[perm[i : i + batchsize]])
ae_optimizer.zero_grads()
x = Variable(x_batch)
acc = x
for layer_id in range(0, training_layer_id):
class CommentNetwork:
def __init__(self, n, saveFile, opt, lossFunc, mod=None, use_gpu=False, numDirectIterations=1, defaultOutputTruncation=10):
self.n=n
self.saveFile=saveFile
self.use_gpu=use_gpu
self.lossFunc=lossFunc
self.numDirectIterations=numDirectIterations
self.defaultOutputTruncation=defaultOutputTruncation
if mod==None:
#construct network model
self.model= FunctionSet(
x_to_h = F.Linear(7, n),
h_to_h = F.Linear(n, n),
h_to_y = F.Linear(n, 7)
)
else:
self.model=mod
if self.use_gpu:
self.model.to_gpu()
else:
self.model.to_cpu()
self.optimizer = opt
self.optimizer.setup(self.model)
#constants
self.null_byte=np.array([[0]*7], dtype=np.float32)
if self.use_gpu:
self.null_byte=cuda.to_gpu(self.null_byte)
self.null_byte=Variable(self.null_byte)
def forward_one_step(self, h, x, computeOutput=True):
h=F.sigmoid(self.model.x_to_h(x) + self.model.h_to_h(h))
if computeOutput:
y=F.sigmoid(self.model.h_to_y(h))
return h, y
else:
return h
def forward(self, input_string, output_string, truncateSize=None, volatile=False):
if truncateSize==None:
truncateSize=self.defaultOutputTruncation
#feed variable in, ignoring output until model has whole input string
h=np.zeros((1,self.n),dtype=np.float32)
if self.use_gpu:
h=cuda.to_gpu(h)
h=Variable(h, volatile=volatile)
for c in input_string:
bits=np.array([[bool(ord(c)&(2**i)) for i in range(7)]], dtype=np.float32)
if self.use_gpu:
bits=cuda.to_gpu(bits)
bits=Variable(bits, volatile=volatile) #8 bits, never all 0 for ascii
h=self.forward_one_step(h, bits, computeOutput=False)
#prep for training
self.optimizer.zero_grads()
y='' #output string
nullEnd=False
loss=0
def yc_translation(yc, y, nullEnd, truncateSize):
yc=sum([bool(round(bit))*(2**i_bit) for i_bit, bit in enumerate(cuda.to_cpu(yc.data[0]))]) #translate to int
if not yc: #null byte signifies end of sequence
nullEnd=True
if not nullEnd:
y+=chr(yc) #translate to character
truncateSize-=1
return y, nullEnd, truncateSize
#Read output by prompting with null bytes.; train with training output
for c in output_string:
bits=np.array([[bool(ord(c)&(2**i)) for i in range(7)]], dtype=np.float32)
if self.use_gpu:
bits=cuda.to_gpu(bits)
bits=Variable(bits, volatile=volatile)
h, yc = self.forward_one_step(h, self.null_byte)
loss+=self.lossFunc(yc, bits)
y, nullEnd, truncateSize = yc_translation(yc, y, nullEnd, truncateSize)
#reinforce null byte as end of sequence
h, yc = self.forward_one_step(h, self.null_byte)
loss+=self.lossFunc(yc, self.null_byte)
y, nullEnd, truncateSize = yc_translation(yc, y, nullEnd, truncateSize)
#continue reading out as long as network does not terminate and we have not hit TruncateSize
while not nullEnd and truncateSize>0:
h, yc = self.forward_one_step(h, self.null_byte)
y, nullEnd, truncateSize = yc_translation(yc, y, nullEnd, truncateSize)
#Train
loss.backward()
self.optimizer.update()
return y, nullEnd #nullEnd true if netowrk terminated output sequence. False if output sequence truncated.
def trainTree(self, tree, maxCommentLength=float('inf')): #DFS training
if 'children' in tree:
allPass=True
for child in tree['children']:
self.trainTree(child, maxCommentLength)
prompt=tree['body']
trainResponse=child['body']
if prompt!='[deleted]' and trainResponse!='[deleted]' and prompt and trainResponse and len(prompt)<=maxCommentLength and len(trainResponse)<=maxCommentLength:
for i in range(self.numDirectIterations):
givenResponse, nullEnd=self.forward(prompt, trainResponse)
print '<#'+str(i)+'--prompt--'+str(len(prompt))+'chars-->\n', repr(prompt), '\n<--trainResponse--'+str(len(trainResponse))+'chars-->\n', repr(trainResponse), '\n<--givenResponse--'+str(len(givenResponse))+'chars'+('' if nullEnd else ', truncated')+'-->\n', repr(givenResponse)+'\n'
if givenResponse==trainResponse:
break
else:
allPass=False
return allPass
# loop over lines in a file identifying if they contain a tree after parsing the json
def trainFile(self, openFile, maxCommentLength=float('inf')):
allPass=True
for i, treeText in enumerate(openFile):
#throw away whitespace
if treeText.strip():
#print fileName, treeText
tree=json.loads(treeText.strip())
#it's a tree, let's train
if 'children' in tree:
print 'training #'+str(i)+' '+openFile.name
allPass&=self.trainTree(tree, maxCommentLength)
return allPass
def saveModel(self):
print 'Stopped computation, saving model. Please wait...'
f=open(self.saveFile,'w')
pickle.dump(self.model, f)
f.close()
print 'Saved model'
def sig_exit(self, _1, _2):
self.saveModel()
exit()
class MLP(object):
def __init__(
self,
data,
target,
n_inputs=784,
n_hidden=784,
n_outputs=10,
gpu=-1
):
self.model = FunctionSet(
l1=F.Linear(n_inputs, n_hidden),
l2=F.Linear(n_hidden, n_hidden),
l3=F.Linear(n_hidden, n_outputs)
)
if gpu >= 0:
self.model.to_gpu()
self.x_train, self.x_test = data
self.y_train, self.y_test = target
self.n_train = len(self.y_train)
self.n_test = len(self.y_test)
self.gpu = gpu
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
self.train_accuracies = []
self.train_losses = []
self.test_accuracies = []
self.test_losses = []
@property
def xp(self):
return cuda.cupy if self.gpu >= 0 else numpy
def forward(self, x_data, y_data, train=True):
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.relu(self.model.l1(x)), train=train)
h2 = F.dropout(F.relu(self.model.l2(h1)), train=train)
y = self.model.l3(h2)
return F.softmax_cross_entropy(y, t), F.accuracy(y, t)
def train_and_test(self, n_epoch=20, batchsize=100):
for epoch in xrange(1, n_epoch + 1):
logging.info('epoch {}'.format(epoch))
perm = numpy.random.permutation(self.n_train)
sum_accuracy = 0
sum_loss = 0
for i in xrange(0, self.n_train, batchsize):
x_batch = self.xp.asarray(self.x_train[perm[i:i+batchsize]])
y_batch = self.xp.asarray(self.y_train[perm[i:i+batchsize]])
real_batchsize = len(x_batch)
self.optimizer.zero_grads()
loss, acc = self.forward(x_batch, y_batch)
loss.backward()
self.optimizer.update()
sum_loss += float(cuda.to_cpu(loss.data)) * real_batchsize
sum_accuracy += float(cuda.to_cpu(acc.data)) * real_batchsize
self.train_accuracies.append(sum_accuracy / self.n_train)
self.train_losses.append(sum_loss / self.n_train)
logging.info(
'train mean loss={}, accuracy={}'.format(
sum_loss / self.n_train,
sum_accuracy / self.n_train
)
)
# evalation
sum_accuracy = 0
sum_loss = 0
for i in xrange(0, self.n_test, batchsize):
x_batch = self.xp.asarray(self.x_test[i:i+batchsize])
y_batch = self.xp.asarray(self.y_test[i:i+batchsize])
real_batchsize = len(x_batch)
loss, acc = self.forward(x_batch, y_batch, train=False)
sum_loss += float(cuda.to_cpu(loss.data)) * real_batchsize
sum_accuracy += float(cuda.to_cpu(acc.data)) * real_batchsize
self.test_accuracies.append(sum_accuracy / self.n_test)
self.test_accuracies.append(sum_loss / self.n_test)
logging.info(
'test mean loss={}, accuracy={}'.format(
sum_loss / self.n_test,
sum_accuracy / self.n_test
)
)
class Caption_generator(object):
def __init__(self,caption_model_place,cnn_model_place,index2word_place,gpu_id=-1,beamsize=3):
#basic paramaters you need to modify
self.gpu_id=gpu_id# GPU ID. if you want to use cpu, -1
self.beamsize=beamsize
#Gpu Setting
global xp
if self.gpu_id >= 0:
xp = cuda.cupy
cuda.get_device(gpu_id).use()
else:
xp=np
# Prepare dataset
with open(index2word_place, 'r') as f:
self.index2word = pickle.load(f)
vocab=self.index2word
#Load Caffe Model
with open(cnn_model_place, 'r') as f:
self.func = pickle.load(f)
#Model Preparation
image_feature_dim=1024#dimension of image feature
self.n_units = 512 #number of units per layer
n_units = 512
self.model = FunctionSet()
self.model.img_feature2vec=F.Linear(image_feature_dim, n_units)#CNN(I)の最後のレイヤーに相当。#parameter W,b
self.model.embed=F.EmbedID(len(vocab), n_units)#W_e*S_tに相当 #parameter W
self.model.l1_x=F.Linear(n_units, 4 * n_units)#parameter W,b
self.model.l1_h=F.Linear(n_units, 4 * n_units)#parameter W,b
self.model.out=F.Linear(n_units, len(vocab))#parameter W,b
serializers.load_hdf5(caption_model_place, self.model)#read pre-trained model
#To GPU
if gpu_id >= 0:
self.model.to_gpu()
self.func.to_gpu()
#to avoid overflow.
#I don't know why, but this model overflows at the first time only with CPU.
#So I intentionally make overflow so that it never happns after that.
if gpu_id < 0:
numpy_image = np.ones((3, 224,224), dtype=np.float32)
self.generate(numpy_image)
def feature_exractor(self,x_chainer_variable): #to extract image feature by CNN.
y, = self.func(inputs={'data': x_chainer_variable}, outputs=['pool5/7x7_s1'],
disable=['loss1/ave_pool', 'loss2/ave_pool','loss3/classifier'],
train=False)
return y
def forward_one_step_for_image(self,img_feature, state, volatile='on'):
x = img_feature#img_feature is chainer.variable.
h0 = self.model.img_feature2vec(x)
h1_in = self.model.l1_x(F.dropout(h0,train=False)) + self.model.l1_h(state['h1'])
c1, h1 = F.lstm(state['c1'], h1_in)
y = self.model.out(F.dropout(h1,train=False))#don't forget to change drop out into non train mode.
state = {'c1': c1, 'h1': h1}
return state, F.softmax(y)
#forward_one_step is after the CNN layer,
#h0 is n_units dimensional vector (embedding)
def forward_one_step(self,cur_word, state, volatile='on'):
x = chainer.Variable(cur_word, volatile)
h0 = self.model.embed(x)
h1_in = self.model.l1_x(F.dropout(h0,train=False)) + self.model.l1_h(state['h1'])
c1, h1 = F.lstm(state['c1'], h1_in)
y = self.model.out(F.dropout(h1,train=False))
state = {'c1': c1, 'h1': h1}
return state, F.softmax(y)
def beam_search(self,sentence_candidates,final_sentences,depth=1,beamsize=3):
volatile=True
next_sentence_candidates_temp=list()
for sentence_tuple in sentence_candidates:
cur_sentence=sentence_tuple[0]
cur_index=sentence_tuple[0][-1]
cur_index_xp=xp.array([cur_index],dtype=np.int32)
cur_state=sentence_tuple[1]
cur_log_likely=sentence_tuple[2]
state, predicted_word = self.forward_one_step(cur_index_xp,cur_state, volatile=volatile)
predicted_word_np=cuda.to_cpu(predicted_word.data)
top_indexes=(-predicted_word_np).argsort()[0][:beamsize]
for index in np.nditer(top_indexes):
index=int(index)
probability=predicted_word_np[0][index]
next_sentence=copy.deepcopy(cur_sentence)
next_sentence.append(index)
log_likely=math.log(probability)
next_log_likely=cur_log_likely+log_likely
next_sentence_candidates_temp.append((next_sentence,state,next_log_likely))# make each sentence tuple
prob_np_array=np.array([sentence_tuple[2] for sentence_tuple in next_sentence_candidates_temp])
top_candidates_indexes=(-prob_np_array).argsort()[:beamsize]
next_sentence_candidates=list()
for i in top_candidates_indexes:
sentence_tuple=next_sentence_candidates_temp[i]
index=sentence_tuple[0][-1]
if self.index2word[index]=='<EOS>':
final_sentence=sentence_tuple[0]
final_likely=sentence_tuple[2]
final_probability=math.exp(final_likely)
final_sentences.append((final_sentence,final_probability,final_likely))
else:
next_sentence_candidates.append(sentence_tuple)
if len(final_sentences)>=beamsize:
return final_sentences
elif depth==50:
return final_sentences
else:
depth+=1
return self.beam_search(next_sentence_candidates,final_sentences,depth,beamsize)
def generate(self,numpy_image):
'''Generate Caption for an Numpy Image array
Args:
numpy_image: numpy image
Returns:
list of generated captions. The structure is [caption,caption,caption,...]
Where caption = {"sentence":This is a generated sentence, "probability": The probability of the generated sentence}
'''
#initial step
x_batch = np.ndarray((1, 3, 224,224), dtype=np.float32)
x_batch[0]=numpy_image
volatile=True
if self.gpu_id >=0:
x_batch_chainer = Variable(cuda.to_gpu(x_batch),volatile=volatile)
else:
x_batch_chainer = Variable(x_batch,volatile=volatile)
batchsize=1
#image is chainer.variable.
state = {name: chainer.Variable(xp.zeros((batchsize, self.n_units),dtype=np.float32),volatile) for name in ('c1', 'h1')}
img_feature=self.feature_exractor(x_batch_chainer)
state, predicted_word = self.forward_one_step_for_image(img_feature,state, volatile=volatile)
if self.gpu_id >=0:
index=cuda.to_cpu(predicted_word.data.argmax(1))[0]
else:
index=predicted_word.data.argmax(1)[0]
probability=predicted_word.data[0][index]
initial_sentence_candidates=[([index],state,probability)]
final_sentences=list()
generated_sentence_candidates=self.beam_search(initial_sentence_candidates,final_sentences,beamsize=self.beamsize)
#convert to index to strings
generated_string_sentence_candidates=[]
for sentence_tuple in generated_sentence_candidates:
sentence=[self.index2word[index] for index in sentence_tuple[0]][1:-1]
probability=sentence_tuple[1]
final_likely=sentence_tuple[2]
a_candidate={'sentence':sentence,'probability':probability,'log_probability':final_likely}
generated_string_sentence_candidates.append(a_candidate)
return generated_string_sentence_candidates
def generate_temp(self,numpy_image):
'''Simple Generate Caption for an Numpy Image array
Args:
numpy_image: numpy image
Returns:
string of generated capiton
'''
genrated_sentence_string=''
x_batch = np.ndarray((1, 3, 224,224), dtype=np.float32)
x_batch[0]=numpy_image
volatile=True
if self.gpu_id >=0:
x_batch_chainer = Variable(cuda.to_gpu(x_batch),volatile=volatile)
else:
x_batch_chainer = Variable(x_batch,volatile=volatile)
batchsize=1
#image is chainer.variable.
state = {name: chainer.Variable(xp.zeros((batchsize, self.n_units),dtype=np.float32),volatile) for name in ('c1', 'h1')}
img_feature=self.feature_exractor(x_batch_chainer)
#img_feature_chainer is chainer.variable of extarcted feature.
state = {name: chainer.Variable(xp.zeros((batchsize, self.n_units),dtype=np.float32),volatile) for name in ('c1', 'h1')}
state, predicted_word = self.forward_one_step_for_image(img_feature,state, volatile=volatile)
index=predicted_word.data.argmax(1)
index=cuda.to_cpu(index)[0]
#genrated_sentence_string+=index2word[index] #dont's add it because this is <SOS>
for i in xrange(50):
state, predicted_word = self.forward_one_step(predicted_word.data.argmax(1).astype(np.int32),state, volatile=volatile)
index=predicted_word.data.argmax(1)
index=cuda.to_cpu(index)[0]
if self.index2word[index]=='<EOS>':
genrated_sentence_string=genrated_sentence_string.strip()
break;
genrated_sentence_string+=self.index2word[index]+" "
return genrated_sentence_string
def get_top_sentence(self,numpy_image):
'''
just get a top sentence as string
Args:
numpy_image: numpy image
Returns:
string of generated capiton
'''
candidates=self.generate(numpy_image)
scores=[caption['log_probability'] for caption in candidates]
argmax=np.argmax(scores)
top_caption=candidates[argmax]['sentence']
sentence = ''
for word in top_caption:
sentence+=word+' '
return sentence.strip()
class SdAMixin(with_metaclass(ABCMeta, BaseEstimator)):
"""
Stacked Denoising Autoencoder
References:
http://deeplearning.net/tutorial/SdA.html
https://github.com/pfnet/chainer/blob/master/examples/mnist/train_mnist.py
"""
def __init__(self, n_input, n_hiddens, n_output, noise_levels=None, dropout_ratios=None, do_pretrain=True,
batch_size=100, n_epoch_pretrain=20, n_epoch_finetune=20, optimizer=optimizers.Adam(),
activation_func=F.relu, verbose=False, gpu=-1):
self.n_input = n_input
self.n_hiddens = n_hiddens
self.n_output = n_output
self.do_pretrain = do_pretrain
self.batch_size = batch_size
self.n_epoch_pretrain = n_epoch_pretrain
self.n_epoch_finetune = n_epoch_finetune
self.optimizer = optimizer
self.dAs = \
[dA(self.n_input, self.n_hiddens[0],
self._check_var(noise_levels, 0), self._check_var(dropout_ratios, 0), self.batch_size,
self.n_epoch_pretrain, copy.deepcopy(optimizer),
activation_func, verbose, gpu)] + \
[dA(self.n_hiddens[i], self.n_hiddens[i + 1],
self._check_var(noise_levels, i + 1), self._check_var(dropout_ratios, i + 1), self.batch_size,
self.n_epoch_pretrain, copy.deepcopy(optimizer),
activation_func, verbose, gpu) for i in range(len(n_hiddens) - 1)]
self.verbose = verbose
self.gpu = gpu
def _check_var(self, var, index, default_val=0.0):
return var[index] if var is not None else default_val
def fit(self, X, y):
if self.do_pretrain:
self._pretrain(X)
self._finetune(X, y)
def _pretrain(self, X):
for layer, dA in enumerate(self.dAs):
utils.disp('*** pretrain layer: {} ***'.format(layer + 1), self.verbose)
if layer == 0:
layer_input = X
else:
layer_input = self.dAs[layer - 1].encode(Variable(layer_input), train=False).data
dA.fit(layer_input)
def _finetune(self, X, y):
utils.disp('*** finetune ***', self.verbose)
# construct model and setup optimizer
params = {'l{}'.format(layer + 1): dA.encoder for layer, dA in enumerate(self.dAs)}
params.update({'l{}'.format(len(self.dAs) + 1): F.Linear(self.dAs[-1].n_hidden, self.n_output)})
self.model = FunctionSet(**params)
self.optimizer.setup(self.model)
if self.gpu >= 0:
cuda.get_device(self.gpu).use()
self.model.to_gpu()
xp = cuda.cupy if self.gpu >= 0 else np
n = len(X)
for epoch in range(self.n_epoch_finetune):
utils.disp('epoch: {}'.format(epoch + 1), self.verbose)
perm = np.random.permutation(n)
sum_loss = 0
for i in range(0, n, self.batch_size):
X_batch = xp.asarray(X[perm[i: i + self.batch_size]])
y_batch = xp.asarray(y[perm[i: i + self.batch_size]])
self.optimizer.zero_grads()
y_var = self._forward(X_batch)
loss = self._loss_func(y_var, Variable(y_batch))
loss.backward()
self.optimizer.update()
sum_loss += float(loss.data) * len(X_batch)
utils.disp('fine tune mean loss={}'.format(sum_loss / n), self.verbose)
def _forward(self, X, train=True):
X_var = Variable(X)
output = X_var
for dA in self.dAs:
output = dA.encode(output, train)
y_var = self.model['l{}'.format(len(self.dAs) + 1)](output)
return y_var
@abstractmethod
def _loss_func(self, y_var, t_var):
pass
class QNet:
# Hyper-Parameters
gamma = 0.99 # Discount factor
initial_exploration = 10**3 # Initial exploratoin. original: 5x10^4
replay_size = 32 # Replay (batch) size
target_model_update_freq = 10**4 # Target update frequancy. original: 10^4
data_size = 10**5 # Data size of history. original: 10^6
hist_size = 1 # original: 4
def __init__(self, use_gpu, enable_controller, dim, epsilon, epsilon_delta, min_eps):
self.use_gpu = use_gpu
self.num_of_actions = len(enable_controller)
self.enable_controller = enable_controller
self.dim = dim
self.epsilon = epsilon
self.epsilon_delta = epsilon_delta
self.min_eps = min_eps
self.time = 0
app_logger.info("Initializing Q-Network...")
hidden_dim = 256
self.model = FunctionSet(
l4=F.Linear(self.dim*self.hist_size, hidden_dim, wscale=np.sqrt(2)),
q_value=F.Linear(hidden_dim, self.num_of_actions,
initialW=np.zeros((self.num_of_actions, hidden_dim),
dtype=np.float32))
)
if self.use_gpu >= 0:
self.model.to_gpu()
self.model_target = copy.deepcopy(self.model)
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, self.hist_size, self.dim), 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, self.hist_size, self.dim), dtype=np.uint8),
np.zeros((self.data_size, 1), dtype=np.bool)]
def forward(self, state, action, reward, state_dash, episode_end):
num_of_batch = state.shape[0]
s = Variable(state)
s_dash = Variable(state_dash)
q = self.q_func(s) # Get Q-value
# Generate Target Signals
tmp = self.q_func_target(s_dash) # Q(s',*)
if self.use_gpu >= 0:
tmp = list(map(np.max, tmp.data.get())) # max_a Q(s',a)
else:
tmp = list(map(np.max, tmp.data)) # max_a Q(s',a)
max_q_dash = np.asanyarray(tmp, dtype=np.float32)
if self.use_gpu >= 0:
target = np.asanyarray(q.data.get(), dtype=np.float32)
else:
# make new array
target = np.array(q.data, dtype=np.float32)
for i in xrange(num_of_batch):
if not episode_end[i][0]:
tmp_ = reward[i] + self.gamma * max_q_dash[i]
else:
tmp_ = reward[i]
action_index = self.action_to_index(action[i])
target[i, action_index] = tmp_
# TD-error clipping
if self.use_gpu >= 0:
target = cuda.to_gpu(target)
td = Variable(target) - q # TD error
td_tmp = td.data + 1000.0 * (abs(td.data) <= 1) # Avoid zero division
td_clip = td * (abs(td.data) <= 1) + td/abs(td_tmp) * (abs(td.data) > 1)
zero_val = np.zeros((self.replay_size, self.num_of_actions), dtype=np.float32)
if self.use_gpu >= 0:
zero_val = cuda.to_gpu(zero_val)
zero_val = Variable(zero_val)
loss = F.mean_squared_error(td_clip, zero_val)
return loss, q
def q_func(self, state):
h4 = F.relu(self.model.l4(state / 255.0))
q = self.model.q_value(h4)
return q
def q_func_target(self, state):
h4 = F.relu(self.model_target.l4(state / 255.0))
q = self.model_target.q_value(h4)
return q
def e_greedy(self, state, epsilon):
s = Variable(state)
q = self.q_func(s)
q = q.data
if np.random.rand() < epsilon:
index_action = np.random.randint(0, self.num_of_actions)
app_logger.info(" Random")
else:
if self.use_gpu >= 0:
index_action = np.argmax(q.get())
else:
index_action = np.argmax(q)
app_logger.info("#Greedy")
return self.index_to_action(index_action), q
def target_model_update(self):
self.model_target = copy.deepcopy(self.model)
def index_to_action(self, index_of_action):
return self.enable_controller[index_of_action]
def action_to_index(self, action):
return self.enable_controller.index(action)
def start(self, feature):
self.state = np.zeros((self.hist_size, self.dim), dtype=np.uint8)
self.state[0] = feature
state_ = np.asanyarray(self.state.reshape(1, self.hist_size, self.dim), dtype=np.float32)
if self.use_gpu >= 0:
state_ = cuda.to_gpu(state_)
# Generate an Action e-greedy
action, q_now = self.e_greedy(state_, self.epsilon)
return_action = action
return return_action
def update_model(self, replayed_experience):
if replayed_experience[0]:
self.optimizer.zero_grads()
loss, _ = self.forward(replayed_experience[1], replayed_experience[2],
replayed_experience[3], replayed_experience[4], replayed_experience[5])
loss.backward()
self.optimizer.update()
# Target model update
if replayed_experience[0] and np.mod(self.time, self.target_model_update_freq) == 0:
app_logger.info("Model Updated")
self.target_model_update()
self.time += 1
app_logger.info("step: {}".format(self.time))
def step(self, features):
if self.hist_size == 4:
self.state = np.asanyarray([self.state[1], self.state[2], self.state[3], features], dtype=np.uint8)
elif self.hist_size == 2:
self.state = np.asanyarray([self.state[1], features], dtype=np.uint8)
elif self.hist_size == 1:
self.state = np.asanyarray([features], dtype=np.uint8)
else:
app_logger.error("self.DQN.hist_size err")
state_ = np.asanyarray(self.state.reshape(1, self.hist_size, self.dim), dtype=np.float32)
if self.use_gpu >= 0:
state_ = cuda.to_gpu(state_)
# Exploration decays along the time sequence
if self.initial_exploration < self.time:
self.epsilon -= self.epsilon_delta
if self.epsilon < self.min_eps:
self.epsilon = self.min_eps
eps = self.epsilon
else: # Initial Exploation Phase
app_logger.info("Initial Exploration : {}/{} steps".format(self.time, self.initial_exploration))
eps = 1.0
# Generate an Action by e-greedy action selection
action, q_now = self.e_greedy(state_, eps)
if self.use_gpu >= 0:
q_max = np.max(q_now.get())
else:
q_max = np.max(q_now)
return action, eps, q_max
class InceptionBN(Function):
"""Inception module in new GoogLeNet with BN."""
def __init__(self, in_channels, out1, proj3, out3, proj33, out33,
pooltype, proj_pool=None, stride=1):
if out1 > 0:
assert stride == 1
assert proj_pool is not None
self.f = FunctionSet(
proj3 = F.Convolution2D(in_channels, proj3, 1, nobias=True),
conv3 = F.Convolution2D( proj3, out3, 3, pad=1, stride=stride, nobias=True),
proj33 = F.Convolution2D(in_channels, proj33, 1, nobias=True),
conv33a = F.Convolution2D( proj33, out33, 3, pad=1, nobias=True),
conv33b = F.Convolution2D( out33, out33, 3, pad=1, stride=stride, nobias=True),
proj3n = F.BatchNormalization(proj3),
conv3n = F.BatchNormalization(out3),
proj33n = F.BatchNormalization(proj33),
conv33an = F.BatchNormalization(out33),
conv33bn = F.BatchNormalization(out33),
)
if out1 > 0:
self.f.conv1 = F.Convolution2D(in_channels, out1, 1, stride=stride, nobias=True)
self.f.conv1n = F.BatchNormalization(out1)
if proj_pool is not None:
self.f.poolp = F.Convolution2D(in_channels, proj_pool, 1, nobias=True)
self.f.poolpn = F.BatchNormalization(proj_pool)
if pooltype == 'max':
self.f.pool = MaxPooling2D(3, stride=stride, pad=1)
elif pooltype == 'avg':
self.f.pool = AveragePooling2D(3, stride=stride, pad=1)
else:
raise NotImplementedError()
def forward(self, x):
f = self.f
self.x = Variable(x[0])
outs = []
if hasattr(f, 'conv1'):
h1 = f.conv1(self.x)
h1 = f.conv1n(h1)
h1 = F.relu(h1)
outs.append(h1)
h3 = F.relu(f.proj3n(f.proj3(self.x)))
h3 = F.relu(f.conv3n(f.conv3(h3)))
outs.append(h3)
h33 = F.relu(f.proj33n(f.proj33(self.x)))
h33 = F.relu(f.conv33an(f.conv33a(h33)))
h33 = F.relu(f.conv33bn(f.conv33b(h33)))
outs.append(h33)
p = f.pool(self.x)
if hasattr(f, 'poolp'):
p = F.relu(f.poolpn(f.poolp(p)))
outs.append(p)
self.y = F.concat(outs, axis=1)
return self.y.data,
def backward(self, x, gy):
self.y.grad = gy[0]
self.y.backward()
return self.x.grad,
def to_gpu(self, device=None):
super(InceptionBN, self).to_gpu(device)
self.f.to_gpu(device)
@property
def parameters(self):
return self.f.parameters
@parameters.setter
def parameters(self, params):
self.f.parameters = params
@property
def gradients(self):
return self.f.gradients
@gradients.setter
def gradients(self, grads):
self.f.gradients = grads
class ConvolutionalDenoisingAutoencoder():
def __init__(self,
imgsize,
n_in_channels,
n_out_channels,
ksize,
stride=1,
pad=0,
use_cuda=False):
self.model = FunctionSet(
encode=F.Convolution2D(n_in_channels, n_out_channels, ksize,
stride, pad),
decode=F.Linear(
n_out_channels * (math.floor(
(imgsize + 2 * pad - ksize) / stride) + 1)**2,
n_in_channels * imgsize**2))
self.use_cuda = use_cuda
if self.use_cuda:
self.model.to_gpu()
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model.collect_parameters())
def encode(self, x_var):
return F.sigmoid(self.model.encode(x_var))
def decode(self, x_var):
return self.model.decode(x_var)
def predict(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
x = Variable(x_data)
p = self.encode(x)
if self.use_cuda:
return cuda.to_cpu(p.data)
else:
return p.data
def cost(self, x_data):
x = Variable(x_data)
t = Variable(
x_data.reshape(x_data.shape[0], x_data.shape[1] * x_data.shape[2] *
x_data.shape[3]))
h = F.dropout(x)
h = self.encode(h)
y = self.decode(h)
return F.mean_squared_error(y, t)
def train(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
self.optimizer.zero_grads()
loss = self.cost(x_data)
loss.backward()
self.optimizer.update()
if self.use_cuda:
return float(cuda.to_cpu(loss.data))
else:
return loss.data
def test(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
loss = self.cost(x_data)
return float(cuda.to_cpu(loss.data))
def Main():
import argparse
import numpy as np
from chainer import cuda, Variable, FunctionSet, optimizers
import chainer.functions as F
parser = argparse.ArgumentParser(description='Chainer example: regression')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
batchsize = 10
n_epoch = NEpoch
n_units = 200 #TEST
# Prepare dataset
data_x, data_y = GenData(20, noise=0.0) #TEST: n samples, noise
batchsize = max(1, min(batchsize,
len(data_y) / 20)) #TEST: adjust batchsize
#dx2,dy2=GenData(300, noise=0.0); data_x.extend(dx2); data_y.extend(dy2)
data = np.array(data_x).astype(np.float32)
target = np.array(data_y).astype(np.float32)
N = len(data) #batchsize * 30
x_train = data
y_train = target
nt = 25
N_test = nt * nt
x_test = np.array(
sum([[[x1, x2] for x2 in FRange1(-3.0, 3.0, nt)]
for x1 in FRange1(-3.0, 3.0, nt)], [])).astype(np.float32)
y_test = np.array([[TrueFunc(x)] for x in x_test]).astype(np.float32)
print 'Num of samples for train:', len(y_train)
# Dump data for plot:
fp1 = file('/tmp/smpl_train.dat', 'w')
for x, y in zip(x_train, y_train):
fp1.write('%s #%i# %s\n' %
(' '.join(map(str, x)), len(x) + 1, ' '.join(map(str, y))))
fp1.close()
# Dump data for plot:
fp1 = file('/tmp/smpl_test.dat', 'w')
for x, y, i in zip(x_test, y_test, range(len(y_test))):
if i % (nt + 1) == 0: fp1.write('\n')
fp1.write('%s #%i# %s\n' %
(' '.join(map(str, x)), len(x) + 1, ' '.join(map(str, y))))
fp1.close()
# Prepare multi-layer perceptron model
model = FunctionSet(l1=F.Linear(2, n_units),
l2=F.Linear(n_units, n_units),
l3=F.Linear(n_units, 1))
#TEST: Random bias initialization
#, bias=Rand()
#model.l1.b[:]= [Rand() for k in range(n_units)]
#model.l2.b[:]= [Rand() for k in range(n_units)]
#model.l3.b[:]= [Rand() for k in range(1)]
#print model.l2.__dict__
if args.gpu >= 0:
cuda.init(args.gpu)
model.to_gpu()
# Neural net architecture
def forward(x_data, y_data, train=True):
#train= False #TEST: Turn off dropout
dratio = 0.2 #0.5 #TEST: Dropout ratio
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.relu(model.l1(x)), ratio=dratio, train=train)
h2 = F.dropout(F.relu(model.l2(h1)), ratio=dratio, train=train)
#h1 = F.dropout(F.leaky_relu(model.l1(x),slope=0.2), ratio=dratio, train=train)
#h2 = F.dropout(F.leaky_relu(model.l2(h1),slope=0.2), ratio=dratio, train=train)
#h1 = F.dropout(F.sigmoid(model.l1(x)), ratio=dratio, train=train)
#h2 = F.dropout(F.sigmoid(model.l2(h1)), ratio=dratio, train=train)
#h1 = F.dropout(F.tanh(model.l1(x)), ratio=dratio, train=train)
#h2 = F.dropout(F.tanh(model.l2(h1)), ratio=dratio, train=train)
#h1 = F.dropout(model.l1(x), ratio=dratio, train=train)
#h2 = F.dropout(model.l2(h1), ratio=dratio, train=train)
#h1 = F.relu(model.l1(x))
#h2 = F.relu(model.l2(h1))
#h1 = model.l1(x)
#h2 = model.l2(h1)
y = model.l3(h2)
return F.mean_squared_error(y, t), y
# Setup optimizer
optimizer = optimizers.AdaDelta(rho=0.9)
#optimizer = optimizers.AdaGrad(lr=0.5)
#optimizer = optimizers.RMSprop()
#optimizer = optimizers.MomentumSGD()
#optimizer = optimizers.SGD(lr=0.8)
optimizer.setup(model.collect_parameters())
# Learning loop
for epoch in xrange(1, n_epoch + 1):
print 'epoch', epoch
# training
perm = np.random.permutation(N)
sum_loss = 0
for i in xrange(0, N, batchsize):
x_batch = x_train[perm[i:i + batchsize]]
y_batch = y_train[perm[i:i + batchsize]]
if args.gpu >= 0:
x_batch = cuda.to_gpu(x_batch)
y_batch = cuda.to_gpu(y_batch)
optimizer.zero_grads()
loss, pred = forward(x_batch, y_batch)
loss.backward() #Computing gradients
optimizer.update()
sum_loss += float(cuda.to_cpu(loss.data)) * batchsize
print 'train mean loss={}'.format(sum_loss / N)
#'''
# testing all data
preds = []
x_batch = x_test[:]
y_batch = y_test[:]
if args.gpu >= 0:
x_batch = cuda.to_gpu(x_batch)
y_batch = cuda.to_gpu(y_batch)
loss, pred = forward(x_batch, y_batch, train=False)
preds = cuda.to_cpu(pred.data)
sum_loss = float(cuda.to_cpu(loss.data)) * len(y_test)
pearson = np.corrcoef(
np.asarray(preds).reshape(len(preds), ),
np.asarray(y_test).reshape(len(preds), ))
#'''
print 'test mean loss={}, corrcoef={}'.format(sum_loss / N_test,
pearson[0][1])
# Dump data for plot:
fp1 = file('/tmp/nn_test%04i.dat' % epoch, 'w')
for x, y, i in zip(x_test, preds, range(len(preds))):
if i % (nt + 1) == 0: fp1.write('\n')
fp1.write(
'%s #%i# %s\n' %
(' '.join(map(str, x)), len(x) + 1, ' '.join(map(str, y))))
fp1.close()
class SdAMixin(with_metaclass(ABCMeta, BaseEstimator)):
"""
Stacked Denoising Autoencoder
References:
http://deeplearning.net/tutorial/SdA.html
https://github.com/pfnet/chainer/blob/master/examples/mnist/train_mnist.py
"""
def __init__(self,
n_input,
n_hiddens,
n_output,
noise_levels=None,
dropout_ratios=None,
do_pretrain=True,
batch_size=100,
n_epoch_pretrain=20,
n_epoch_finetune=20,
optimizer=optimizers.Adam(),
activation_func=F.relu,
verbose=False,
gpu=-1):
self.n_input = n_input
self.n_hiddens = n_hiddens
self.n_output = n_output
self.do_pretrain = do_pretrain
self.batch_size = batch_size
self.n_epoch_pretrain = n_epoch_pretrain
self.n_epoch_finetune = n_epoch_finetune
self.optimizer = optimizer
self.dAs = \
[dA(self.n_input, self.n_hiddens[0],
self._check_var(noise_levels, 0), self._check_var(dropout_ratios, 0), self.batch_size,
self.n_epoch_pretrain, copy.deepcopy(optimizer),
activation_func, verbose, gpu)] + \
[dA(self.n_hiddens[i], self.n_hiddens[i + 1],
self._check_var(noise_levels, i + 1), self._check_var(dropout_ratios, i + 1), self.batch_size,
self.n_epoch_pretrain, copy.deepcopy(optimizer),
activation_func, verbose, gpu) for i in range(len(n_hiddens) - 1)]
self.verbose = verbose
self.gpu = gpu
def _check_var(self, var, index, default_val=0.0):
return var[index] if var is not None else default_val
def fit(self, X, y):
if self.do_pretrain:
self._pretrain(X)
self._finetune(X, y)
def _pretrain(self, X):
for layer, dA in enumerate(self.dAs):
utils.disp('*** pretrain layer: {} ***'.format(layer + 1),
self.verbose)
if layer == 0:
layer_input = X
else:
layer_input = self.dAs[layer - 1].encode(Variable(layer_input),
train=False).data
dA.fit(layer_input)
def _finetune(self, X, y):
utils.disp('*** finetune ***', self.verbose)
# construct model and setup optimizer
params = {
'l{}'.format(layer + 1): dA.encoder
for layer, dA in enumerate(self.dAs)
}
params.update({
'l{}'.format(len(self.dAs) + 1):
F.Linear(self.dAs[-1].n_hidden, self.n_output)
})
self.model = FunctionSet(**params)
self.optimizer.setup(self.model)
if self.gpu >= 0:
cuda.get_device(self.gpu).use()
self.model.to_gpu()
xp = cuda.cupy if self.gpu >= 0 else np
n = len(X)
for epoch in range(self.n_epoch_finetune):
utils.disp('epoch: {}'.format(epoch + 1), self.verbose)
perm = np.random.permutation(n)
sum_loss = 0
for i in range(0, n, self.batch_size):
X_batch = xp.asarray(X[perm[i:i + self.batch_size]])
y_batch = xp.asarray(y[perm[i:i + self.batch_size]])
self.optimizer.zero_grads()
y_var = self._forward(X_batch)
loss = self._loss_func(y_var, Variable(y_batch))
loss.backward()
self.optimizer.update()
sum_loss += float(loss.data) * len(X_batch)
utils.disp('fine tune mean loss={}'.format(sum_loss / n),
self.verbose)
def _forward(self, X, train=True):
X_var = Variable(X)
output = X_var
for dA in self.dAs:
output = dA.encode(output, train)
y_var = self.model['l{}'.format(len(self.dAs) + 1)](output)
return y_var
@abstractmethod
def _loss_func(self, y_var, t_var):
pass
class DA(object):
def __init__(
self,
rng,
data,
n_inputs=784,
n_hidden=784,
corruption_level=0.3,
optimizer=optimizers.AdaDelta,
gpu=-1
):
"""
Denoising AutoEncoder
data: data for train
n_inputs: a number of units of input layer and output layer
n_hidden: a number of units of hidden layer
corruption_level: a ratio of masking noise
"""
self.model = FunctionSet(
encoder=F.Linear(n_inputs, n_hidden),
decoder=F.Linear(n_hidden, n_inputs)
)
if gpu >= 0:
self.model.to_gpu()
self.gpu = gpu
self.x_train, self.x_test = data
self.n_train = len(self.x_train)
self.n_test = len(self.x_test)
self.n_inputs = n_inputs
self.n_hidden = n_hidden
self.optimizer = optimizer()
self.optimizer.setup(self.model)
self.corruption_level = corruption_level
self.rng = rng
self.train_losses = []
self.test_losses = []
@property
def xp(self):
return cuda.cupy if self.gpu >= 0 else numpy
def forward(self, x_data, train=True):
y_data = x_data
# add noise (masking noise)
x_data = self.get_corrupted_inputs(x_data, train=train)
x, t = Variable(x_data), Variable(y_data)
# encode
h = self.encode(x)
# decode
y = self.decode(h)
# compute loss
loss = F.mean_squared_error(y, t)
return loss
def compute_hidden(self, x_data):
# x_data = self.xp.asarray(x_data)
x = Variable(x_data)
h = self.encode(x)
# return cuda.to_cpu(h.data)
return h.data
def predict(self, x_data):
x = Variable(x_data)
# encode
h = self.encode(x)
# decode
y = self.decode(h)
return cuda.to_cpu(y.data)
def encode(self, x):
return F.relu(self.model.encoder(x))
def decode(self, h):
return F.relu(self.model.decoder(h))
def encoder(self):
initialW = self.model.encoder.W
initial_bias = self.model.encoder.b
return F.Linear(self.n_inputs,
self.n_hidden,
initialW=initialW,
initial_bias=initial_bias)
def decoder(self):
return self.model.decoder
def to_cpu(self):
self.model.to_cpu()
self.xp = np
def to_gpu(self):
if self.gpu < 0:
logging.error("something wrong")
raise
self.model.to_gpu()
self.xp = cuda.cupy
# masking noise
def get_corrupted_inputs(self, x_data, train=True):
if train and self.corruption_level != 0.0:
mask = self.rng.binomial(size=x_data.shape, n=1, p=1.0 - self.corruption_level)
mask = mask.astype(numpy.float32)
mask = self.xp.asarray(mask)
ret = mask * x_data
# return self.xp.asarray(ret.astype(numpy.float32))
return ret
else:
return x_data
def train_and_test(self, n_epoch=5, batchsize=100):
for epoch in xrange(1, n_epoch+1):
logging.info('epoch: {}'.format(epoch))
perm = self.rng.permutation(self.n_train)
sum_loss = 0
for i in xrange(0, self.n_train, batchsize):
x_batch = self.xp.asarray(self.x_train[perm[i:i+batchsize]])
real_batchsize = len(x_batch)
self.optimizer.zero_grads()
loss = self.forward(x_batch)
loss.backward()
self.optimizer.update()
sum_loss += float(loss.data) * real_batchsize
logging.info(
'train mean loss={}'.format(sum_loss / self.n_train)
)
# evaluation
sum_loss = 0
for i in xrange(0, self.n_test, batchsize):
x_batch = self.xp.asarray(self.x_test[i:i+batchsize])
real_batchsize = len(x_batch)
loss = self.forward(x_batch, train=False)
sum_loss += float(loss.data) * real_batchsize
logging.info(
'test mean loss={}'.format(sum_loss / self.n_test)
)
def finetuning(self, data, training_params):
"""
入力データを使用して Fine tuning を実施
"""
self.logger.info("Start finetuning...")
threshold = training_params.loss_threshold
### Model 設定
model = FunctionSet()
for num, f_layer in enumerate(self.f_layers, 1):
name = "l_f{0}".format(num)
model.__setattr__(name, f_layer)
for num, b_layer in enumerate(self.b_layers, 1):
name = "l_b{0}".format(num)
model.__setattr__(name, b_layer)
if self.use_gpu:
model = model.to_gpu()
self.optimizer.setup(model)
### forward 処理設定
def forward(x_data):
x = Variable(x_data)
t = Variable(x_data)
h = x
for num in xrange(1, len(self.f_layers) + 1):
h = self.activation(model.__getitem__("l_f{0}".format(num))(h))
for num in reversed(xrange(1, len(self.b_layers) + 1)):
h = self.activation(model.__getitem__("l_b{0}".format(num))(h))
y = h
return F.mean_squared_error(y, t)
### Training
train_data = data
train_size = len(train_data)
batch_size = training_params.batch_size
batch_max = int(math.ceil(train_size / float(batch_size)))
epoch = 0
while True:
epoch += 1
indexes = np.random.permutation(train_size)
sum_loss = 0
for i in xrange(batch_max):
start = i * batch_size
end = (i + 1) * batch_size
x_batch = train_data[indexes[start:end]]
self.logger.debug("Index {0} => {1}, data count = {2}".format(start, end, len(x_batch)))
if self.use_gpu:
x_batch = cuda.to_gpu(x_batch)
self.optimizer.zero_grads()
loss = forward(x_batch)
sum_loss += loss.data * batch_size
loss.backward()
self.optimizer.update()
epoch_loss = sum_loss / train_size
self.logger.info("Epoch {0}, Training loss = {1}".format(epoch, epoch_loss))
if threshold is not None and epoch_loss < threshold:
self.logger.info("Training loss is less then loss_threshold ({0}), stop training.".format(threshold))
break
if epoch >= training_params.epochs:
break
self.logger.info("Complete finetuning.")
acc_root, result['correct_root'], result['total_root']))
vocab = {}
train_trees = read_corpus('trees/train.txt', vocab)
test_trees = read_corpus('trees/test.txt', vocab)
develop_trees = read_corpus('trees/dev.txt', vocab)
model = FunctionSet(
embed=F.EmbedID(len(vocab), n_units),
l=F.Linear(n_units * 2, n_units),
w=F.Linear(n_units, n_label),
)
if args.gpu >= 0:
cuda.init()
model.to_gpu()
# Setup optimizer
optimizer = optimizers.AdaGrad(lr=0.1)
optimizer.setup(model.collect_parameters())
accum_loss = 0
count = 0
start_at = time.time()
cur_at = start_at
for epoch in range(n_epoch):
print('Epoch: {0:d}'.format(epoch))
total_loss = 0
cur_at = time.time()
random.shuffle(train_trees)
for tree in train_trees:
def pretraining(self, data, training_params):
"""
入力データを使用して Pretraining を実施
"""
self.logger.info("Start pretraining...")
threshold = training_params.loss_threshold
for l_idx in xrange(len(self.f_layers)):
self.logger.info("Pretrining {0} and {1} layers.".format(l_idx + 1, l_idx + 2))
### データ設定
train_data = None
if l_idx == 0:
train_data = data
else:
train_data = pre_train_data
### Model 作成
model = FunctionSet(l_in=self.f_layers[l_idx], l_out=self.b_layers[l_idx])
if self.use_gpu:
model = model.to_gpu()
self.optimizer.setup(model)
### forward 処理設定
def forwardWithLoss(x_data):
x = Variable(x_data)
t = Variable(x_data)
h = self.activation(model.l_in(x))
y = self.activation(model.l_out(h))
return F.mean_squared_error(y, t)
def forwardWithActivation(x_data):
x = Variable(x_data)
y = self.activation(model.l_in(x))
return y.data
### Training
train_size = len(train_data)
batch_size = training_params.batch_size
batch_max = int(math.ceil(train_size / float(batch_size)))
epoch = 0
while True:
epoch += 1
indexes = np.random.permutation(train_size)
sum_loss = 0
for i in xrange(batch_max):
start = i * batch_size
end = (i + 1) * batch_size
x_batch = train_data[indexes[start:end]]
self.logger.debug("Index {0} => {1}, data count = {2}".format(start, end, len(x_batch)))
if self.use_gpu:
x_batch = cuda.to_gpu(x_batch)
self.optimizer.zero_grads()
loss = forwardWithLoss(x_batch)
sum_loss += loss.data * batch_size
loss.backward()
self.optimizer.update()
epoch_loss = sum_loss / train_size
self.logger.info("Epoch {0}, Training loss = {1}".format(epoch, epoch_loss))
if threshold is not None and epoch_loss < threshold:
self.logger.info(
"Training loss is less then loss_threshold ({0}), stop training.".format(threshold)
)
break
if epoch >= training_params.epochs:
break
### Set next layer data
pre_train_data = np.zeros((train_size, self.layer_sizes[l_idx + 1]), dtype=train_data.dtype)
for i in xrange(batch_max):
start = i * batch_size
end = (i + 1) * batch_size
x_batch = train_data[start:end]
if self.use_gpu:
x_batch = cuda.to_gpu(x_batch)
y_batch = forwardWithActivation(x_batch)
if self.use_gpu:
y_batch = cuda.to_cpu(y_batch)
pre_train_data[start:end] = y_batch
self.logger.info("Complete pretraining.")
h = F.relu(h)
h = F.average_pooling_2d(h, 3, stride=2)
h = model.conv4(h)
h = model.ip1(h)
y = h
""" softmax normalization + compute loss & validation """
return F.softmax_cross_entropy(y, t), F.accuracy(y, t)
""" training configuration """
iteration = 50
batchsize = 100
N = train_data.shape[0]
model.to_gpu()
optim = optimizers.Adam()
optim.setup(model)
logging.basicConfig(filename='train.log', filemode='w', level=logging.DEBUG)
""" training """
for epoch in range(iteration):
perm = np.random.permutation(N)
progress = ProgressBar(
widgets=['epoch: ' + str(epoch + 1) +
' ', Percentage()])
progress.min_value = 0
progress.max_value = N - 1
progress.start()
sum_loss = 0.0
sum_accuracy = 0.0
def DNNbasedWienerfilter():
#pretrain loop
startexec = time.time()
for epoch in xrange(pretrain_epoch):
print "now proc: pretraining epoch{}".format(epoch)
startepoch = time.time()
perm = np.random.permutation(learnsize)
for idx in np.arange(0, pretrainsize,
3): #utterance Number training dataset
# start = time.time()
x_batch = np.empty((0, HFFTL * 2), float)
for iter in xrange(3):
fs, signal_data = read(estimated_signal[perm[idx + iter]],
"r")
fs, noise_data = read(estimated_noise[perm[idx + iter]],
"r")
signal_data = signal_data / np.sqrt(np.mean(signal_data**
2))
noise_data = noise_data / np.sqrt(np.mean(noise_data**2))
#FFT
Sspectrum_, synparam = FFTanalysis.FFTanalysis(signal_data)
Nspectrum_, synparam = FFTanalysis.FFTanalysis(noise_data)
N_FRAMES = np.shape(Sspectrum_)[0]
HFFTL = np.shape(Sspectrum_)[1]
x_data = np.zeros((N_FRAMES, HFFTL * 2))
for nframe in xrange(N_FRAMES):
spectrum = np.append(Sspectrum_[nframe],
Nspectrum_[nframe])
x_data[nframe] = [
np.sqrt(c.real**2 + c.imag**2) for c in spectrum
] #DNN indata
if iter == 0:
x_batch = np.append(x_batch, x_data, axis=0)
else:
x_batch = np.vstack((x_batch, x_data))
for frq in xrange(HFFTL):
x_frqbatch = np.zeros(
(np.shape(x_batch)[0], 2 * (dim * 2 + 1)), float)
x_frqbatch[:, dim] = x_batch[:, frq]
x_frqbatch[:, dim * 3 + 1] = x_batch[:, frq + HFFTL]
for j in np.arange(1, dim + 1):
if (frq - j) >= 0:
x_frqbatch[:, dim - j] = x_batch[:, frq - j]
x_frqbatch[:, dim * 3 + 1 - j] = x_batch[:, frq +
HFFTL - j]
if ((HFFTL - 1) - (j + frq)) >= 0:
x_frqbatch[:, dim + j] = x_batch[:, frq + j]
x_frqbatch[:, dim * 3 + 1 + j] = x_batch[:, frq +
HFFTL + j]
x_frqbatch = x_frqbatch.astype(np.float32)
if epoch != 0 or idx != 0: #except first batch
modelL1.l1.W.data = cuda.to_gpu(l1_W.pop(0))
modelL2.l1.W.data = cuda.to_gpu(l2_W.pop(0))
modelL1.l2.W.data = cuda.to_gpu(l1b_W.pop(0))
modelL2.l2.W.data = cuda.to_gpu(l2b_W.pop(0))
# training
if args.gpu >= 0:
x_frqbatch = cuda.to_gpu(x_frqbatch)
optL1.zero_grads()
loss, hidden = pretrain_L1(x_frqbatch, ratio=0.5)
loss.backward()
optL1.update()
optL2.zero_grads()
loss, hidden = pretrain_L2(hidden, ratio=0.5)
loss.backward()
optL2.update()
#model parameter saving
l1_W.append(cuda.to_cpu(modelL1.l1.W.data))
l2_W.append(cuda.to_cpu(modelL2.l1.W.data))
l1b_W.append(cuda.to_cpu(modelL1.l2.W.data))
l2b_W.append(cuda.to_cpu(modelL2.l2.W.data))
print 'pretrain epoch time:{0}sec'.format(
np.round(time.time() - startepoch, decimals=2))
# learning loop
model = FunctionSet(l1=F.Linear(2 * (dim * 2 + 1),
n_units,
initialW=initializer),
l2=F.Linear(n_units, n_units,
initialW=initializer),
l3=F.Linear(n_units, 1, initialW=initializer))
# Setup optimizer
optimizer = optimizers.Adam()
optimizer.setup(model)
model.to_gpu()
# Neural net architecture
def forward(x_data, y_data, ratio=0.5, train=True):
x, t = Variable(x_data), Variable(y_data)
h1 = F.dropout(F.sigmoid(model.l1(x)), ratio=ratio, train=train)
h2 = F.dropout(F.sigmoid(model.l2(h1)), ratio=ratio, train=train)
y = model.l3(h2)
return F.mean_squared_error(y, t), y
startexec = time.time()
for epoch in xrange(n_epoch):
print "now proc: learning epoch{}".format(epoch)
startepoch = time.time()
perm = np.random.permutation(learnsize)
for idx in np.arange(0, learnsize,
3): #utterance Number training dataset
# start = time.time()
x_batch = np.empty((0, HFFTL * 2), float)
y_batch = np.empty((0, HFFTL), float)
for iter in xrange(3):
fs, signal_data = read(estimated_signal[perm[idx + iter]],
"r")
fs, noise_data = read(estimated_noise[perm[idx + iter]],
"r")
fs, teacher_data = read(teacher_signal[perm[idx + iter]],
"r")
signal_data = signal_data / np.sqrt(np.mean(signal_data**
2))
noise_data = noise_data / np.sqrt(np.mean(noise_data**2))
teacher_data = teacher_data / np.sqrt(
np.mean(teacher_data**2))
#FFT
Sspectrum_, synparam = FFTanalysis.FFTanalysis(signal_data)
Nspectrum_, synparam = FFTanalysis.FFTanalysis(noise_data)
Tspectrum_, synparam = FFTanalysis.FFTanalysis(
teacher_data)
N_FRAMES = np.shape(Sspectrum_)[0]
HFFTL = np.shape(Sspectrum_)[1]
x_data = np.zeros((N_FRAMES, HFFTL * 2))
y_data = np.zeros((N_FRAMES, HFFTL))
if epoch == 0:
learned_data += N_FRAMES
for nframe in xrange(N_FRAMES):
spectrum = np.append(Sspectrum_[nframe],
Nspectrum_[nframe])
x_data[nframe] = [
np.sqrt(c.real**2 + c.imag**2) for c in spectrum
] #DNN indata
#phaseSpectrum = [np.arctan2(c.imag, c.real) for c in spectrum]
Spower = np.array([
np.sqrt(c.real**2 + c.imag**2)
for c in Sspectrum_[nframe]
])
Tpower = np.array([
np.sqrt(c.real**2 + c.imag**2)
for c in Tspectrum_[nframe]
])
for i, x in enumerate(Spower):
if x == 0:
Spower[i] = 1e-10
y_data[nframe] = Tpower / Spower
if iter == 0:
x_batch = np.append(x_batch, x_data, axis=0)
y_batch = np.append(y_batch, y_data, axis=0)
else:
x_batch = np.vstack((x_batch, x_data))
y_batch = np.vstack((y_batch, y_data))
for frq in xrange(HFFTL):
x_frqbatch = np.zeros(
(np.shape(x_batch)[0], 2 * (dim * 2 + 1)), float)
x_frqbatch[:, dim] = x_batch[:, frq]
x_frqbatch[:, dim * 3 + 1] = x_batch[:, frq + HFFTL]
for j in np.arange(1, dim + 1):
if (frq - j) >= 0:
x_frqbatch[:, dim - j] = x_batch[:, frq - j]
x_frqbatch[:, dim * 3 + 1 - j] = x_batch[:, frq +
HFFTL - j]
if ((HFFTL - 1) - (j + frq)) >= 0:
x_frqbatch[:, dim + j] = x_batch[:, frq + j]
x_frqbatch[:, dim * 3 + 1 + j] = x_batch[:, frq +
HFFTL + j]
y_frqbatch = np.zeros((np.shape(y_batch)[0], 1), float)
y_frqbatch = y_batch[:,
frq].reshape(np.shape(y_batch)[0], 1)
x_frqbatch = x_frqbatch.astype(np.float32)
y_frqbatch = y_frqbatch.astype(np.float32)
model.l1.W.data = cuda.to_gpu(l1_W.pop(0))
model.l2.W.data = cuda.to_gpu(l2_W.pop(0))
if epoch != 0 or idx != 0: #except first batch
model.l3.W.data = cuda.to_gpu(l3_W.pop(0))
# training
if args.gpu >= 0:
x_frqbatch = cuda.to_gpu(x_frqbatch)
y_frqbatch = cuda.to_gpu(y_frqbatch)
optimizer.zero_grads()
loss, pred = forward(x_frqbatch, y_frqbatch, ratio=0.5)
loss.backward()
optimizer.update()
#model parameter saving
l1_W.append(cuda.to_cpu(model.l1.W.data))
l2_W.append(cuda.to_cpu(model.l2.W.data))
l3_W.append(cuda.to_cpu(model.l3.W.data))
print 'epoch time:{0}sec'.format(
np.round(time.time() - startepoch, decimals=2))
f = open('selectfrq_estimated_data/pretrain_write1.csv', 'w')
writer = csv.writer(f)
writer.writerows(l1_W)
f.close()
f = open('selectfrq_estimated_data/pretrain_write2.csv', 'w')
writer = csv.writer(f)
writer.writerows(l2_W)
f.close()
f = open('selectfrq_estimated_data/pretrain_write3.csv', 'w')
writer = csv.writer(f)
writer.writerows(l3_W)
f.close()
#test loop
SNRList = ["-10dB", "-5dB", "0dB", "5dB", "10dB", "-20dB"]
for SNRnum, SNR in enumerate(SNRList): #-10,-5,0,5,10,-20dB
loss_sum = np.zeros(testsize)
for idx in np.arange(learnsize + SNRnum * testsize,
learnsize + (SNRnum + 1) * testsize):
fs, signal_data = read(estimated_signal[idx], "r")
fs, noise_data = read(estimated_noise[idx], "r")
fs, teacher_data = read(
teacher_signal[idx - testsize * SNRnum], "r")
signal_data = signal_data / np.sqrt(np.mean(signal_data**2))
noise_data = noise_data / np.sqrt(np.mean(noise_data**2))
teacher_data = teacher_data / np.sqrt(np.mean(teacher_data**2))
Sspectrum_, synparam = FFTanalysis.FFTanalysis(signal_data)
Nspectrum_, synparam = FFTanalysis.FFTanalysis(noise_data)
Tspectrum_, synparam = FFTanalysis.FFTanalysis(teacher_data)
N_FRAMES = np.shape(Sspectrum_)[0]
HFFTL = np.shape(Sspectrum_)[1]
x_data = np.zeros((N_FRAMES, HFFTL * 2))
y_data = np.zeros((N_FRAMES, HFFTL))
for nframe in xrange(N_FRAMES):
spectrum = np.append(Sspectrum_[nframe],
Nspectrum_[nframe])
x_data[nframe] = [
np.sqrt(c.real**2 + c.imag**2) for c in spectrum
] #DNN indata
#phaseSpectrum = [np.arctan2(c.imag, c.real) for c in spectrum]
Spower = np.array([
np.sqrt(c.real**2 + c.imag**2)
for c in Sspectrum_[nframe]
])
Tpower = np.array([
np.sqrt(c.real**2 + c.imag**2)
for c in Tspectrum_[nframe]
])
for i, x in enumerate(Spower):
if x == 0:
Spower[i] = 1e-10
y_data[nframe] = Tpower / Spower
calcSNR = np.empty((N_FRAMES, 0), float)
totalloss = np.zeros(HFFTL, float)
# testing
for frq in xrange(HFFTL):
model.l1.W.data = cuda.to_gpu(l1_W[frq])
model.l2.W.data = cuda.to_gpu(l2_W[frq])
model.l3.W.data = cuda.to_gpu(l3_W[frq])
# testing
x_frqdata = np.zeros(
(np.shape(x_data)[0], 2 * (dim * 2 + 1)), float)
x_frqdata[:, dim] = x_data[:, frq]
x_frqdata[:, dim * 3 + 1] = x_data[:, frq + HFFTL]
for j in np.arange(1, dim + 1):
if (frq - j) >= 0:
x_frqdata[:, dim - j] = x_data[:, frq - j]
x_frqdata[:, dim * 3 + 1 - j] = x_data[:, frq +
HFFTL - j]
if ((HFFTL - 1) - (j + frq)) >= 0:
x_frqdata[:, dim + j] = x_data[:, frq + j]
x_frqdata[:, dim * 3 + 1 + j] = x_data[:, frq +
HFFTL + j]
y_frqdata = np.zeros((np.shape(y_data)[0], 1), float)
y_frqdata = y_data[:, frq].reshape(np.shape(y_data)[0], 1)
x_frqdata = x_frqdata.astype(np.float32)
y_frqdata = y_frqdata.astype(np.float32)
if args.gpu >= 0:
x_frqdata = cuda.to_gpu(x_frqdata)
y_frqdata = cuda.to_gpu(y_frqdata)
loss, pred = forward(x_frqdata, y_frqdata, train=False)
totalloss[frq] = cuda.to_cpu(loss.data)
pred = np.reshape(cuda.to_cpu(pred.data), (N_FRAMES, 1))
calcSNR = np.append(calcSNR, pred, axis=1)
fs, teacher_data = read(
teacher_signal[idx - testsize * SNRnum], "r")
if teacher_data.dtype == "int16":
teacher_data = teacher_data / norm
y_out = Sspectrum_ * calcSNR
wf_signal = FFTanalysis.Synth(y_out, synparam, BPFon=0)
wf_signal = wf_signal * np.sqrt(
np.mean(teacher_data**2) / np.mean(wf_signal**2))
write(
dir + SNR + "/dim{}_DNNbased_No{}.wav".format(
dim, idx - testsize * SNRnum), Fs, wf_signal)
print 'exec time:{0}sec'.format(
np.round(time.time() - startexec, decimals=2))
print "data: ", learned_data
