def __init__(self):
self.num_of_actions = 4
print "Initializing DQN..."
print "Model Building"
self.model = Chain(l1=links.Convolution2D(self.STATE_FRAMES,
32,
ksize=8,
stride=4,
nobias=False,
wscale=0.01),
l2=links.Convolution2D(32,
64,
ksize=4,
stride=2,
nobias=False,
wscale=0.01),
l3=links.Convolution2D(64,
64,
ksize=3,
stride=1,
nobias=False,
wscale=0.01),
l4=links.Linear(3136, 512, wscale=0.01),
q_value=links.Linear(512,
self.num_of_actions)).to_gpu()
self.model_target = copy.deepcopy(self.model)
def fit(self,
X,
batchsize=100,
n_iter=100,
init_smooth=0.8,
init_scale=0.1,
lr=0.01,
optimizer='Momentum'):
L = np.array([len(seq) for seq in X])
self.max_length = np.max(L)
init = X[np.where(L == self.centroid_length)[0]]
init = np.unique(init)
init = init[np.random.choice(len(init), self.n_centroid,
replace=False)]
print(init)
init_seq = one_hot_encoding(init, self.dict_alphabet, self.max_length,
init_smooth)
init_seq[np.where(init_seq != 0)] = np.log(
init_seq[np.where(init_seq != 0)])
noise = np.random.gumbel(0, 1, init_seq.shape)
init_seq[np.where(init_seq != 0)] += noise[np.where(init_seq != 0)]
init_seq *= init_scale
init_seq = np.transpose(
np.transpose(init_seq, (1, 0, 2)) - np.mean(init_seq, axis=1),
(1, 0, 2))
self.model = Chain(kmeans=SoftKMeansLayer(self.n_centroid,
self.centroid_length,
init_W=init_seq,
tau1=self.tau))
self.optimizer = {
'Adam': optimizers.Adam(lr),
'Momentum': optimizers.MomentumSGD(lr),
'SGD': optimizers.SGD(lr)
}[optimizer]
self.optimizer.setup(self.model)
self.optimizer.add_hook(chainer.optimizer.WeightDecay(1e-6))
if self.use_gpu:
self.model.to_gpu()
with chainer.using_config('train', True):
lcurve = []
for i in range(n_iter):
self.model.cleargrads()
indexes = np.random.choice(len(X), batchsize)
x = X[indexes]
x = one_hot_encoding(x, self.dict_alphabet, self.max_length)
if self.use_gpu:
x = cupy.array(x)
loss = self.model.kmeans(x[indexes])
loss.backward()
lcurve.append(float(loss.data))
self.optimizer.update()
print(i, np.mean(lcurve[-10:]))
return np.array(lcurve)
def __init__(self, nlp, shape, **settings):
Chain.__init__(self,
embed=_Embed(shape['nr_vector'], shape['nr_dim'], shape['nr_hidden'],
initialW=lambda arr: set_vectors(arr, nlp.vocab)),
encode=_Encode(shape['nr_hidden'], shape['nr_hidden']),
attend=_Attend(shape['nr_hidden'], shape['nr_hidden']),
predict=_Predict(shape['nr_hidden'], shape['nr_class']))
self.to_gpu(0)
class ChainerDQNclass:
STATE_FRAMES = 4 # number of frames to store in the state
def __init__(self):
self.num_of_actions = 4
print "Initializing DQN..."
print "Model Building"
self.model = Chain(l1=links.Convolution2D(self.STATE_FRAMES,
32,
ksize=8,
stride=4,
nobias=False,
wscale=0.01),
l2=links.Convolution2D(32,
64,
ksize=4,
stride=2,
nobias=False,
wscale=0.01),
l3=links.Convolution2D(64,
64,
ksize=3,
stride=1,
nobias=False,
wscale=0.01),
l4=links.Linear(3136, 512, wscale=0.01),
q_value=links.Linear(512,
self.num_of_actions)).to_gpu()
self.model_target = copy.deepcopy(self.model)
# self.optimizer = optimizers.Adam(alpha=1e-6)
# self.optimizer.use_cleargrads()
# self.optimizer.setup(self.model)
def Q_func(self, state):
h1 = funcitons.relu(self.model.l1(state)) # scale inputs in [0.0 1.0]
h2 = funcitons.relu(self.model.l2(h1))
h3 = funcitons.relu(self.model.l3(h2))
h4 = funcitons.relu(self.model.l4(h3))
Q = self.model.q_value(h4)
return Q
def Q_func_target(self, state):
h1 = funcitons.relu(
self.model_target.l1(state)) # scale inputs in [0.0 1.0]
h2 = funcitons.relu(self.model_target.l2(h1))
h3 = funcitons.relu(self.model_target.l3(h2))
h4 = funcitons.relu(self.model_target.l4(h3))
Q = self.model_target.q_value(h4)
return Q
def target_model_update(self):
self.model_target = copy.deepcopy(self.model)
def __init__(self):
self.model = Chain(conv1=L.Convolution2D(3, 20, 3, 1, 1),
conv2=L.Convolution2D(20, 20, 3, 1, 1),
conv3=L.Convolution2D(20, 40, 3, 1, 1),
conv4=L.Convolution2D(40, 40, 3, 1, 1),
linear1=L.Linear(None, 100),
linear2=L.Linear(100, 4))
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
def __init__(self, use_gpu, enable_controller, cnn_input_dim, feature_dim,
agent_count, other_input_dim, model):
self.use_gpu = use_gpu
self.num_of_actions = len(enable_controller)
self.enable_controller = enable_controller
self.cnn_input_dim = cnn_input_dim
self.feature_dim = feature_dim
self.agent_count = agent_count
self.other_input_dim = other_input_dim
self.data_size = self.timestep_per_episode
self.loss_log_file = self.loss_log + "loss.log"
self.loss_per_episode = 0
self.time_of_episode = 0
print("Initializing Q-Network...")
if model == 'None':
self.model = Chain(
conv1=L.Convolution2D(3 * self.hist_size, 32, 4, stride=2),
bn1=L.BatchNormalization(32),
conv2=L.Convolution2D(32, 32, 4, stride=2),
bn2=L.BatchNormalization(32),
conv3=L.Convolution2D(32, 32, 4, stride=2),
bn3=L.BatchNormalization(32),
# conv4=L.Convolution2D(64, 64, 4, stride=2),
# bn4=L.BatchNormalization(64),
l1=L.Linear(
self.feature_dim + self.other_input_dim * self.hist_size,
128),
l2=L.Linear(128, 128),
l3=L.Linear(128, 96),
l4=L.Linear(96, 64),
q_value=L.Linear(64, self.num_of_actions))
else:
with open(model, 'rb') as i:
self.model = pickle.load(i)
self.data_size = 0
if self.use_gpu >= 0:
self.model.to_gpu()
self.optimizer = optimizers.RMSpropGraves()
self.optimizer.setup(self.model)
# History Data : D=[s, a, r, s_dash, end_episode_flag]
self.d = [
np.zeros((self.agent_count, self.data_size, self.hist_size, 128,
128, 3),
dtype=np.uint8),
np.zeros((self.agent_count, self.data_size, self.hist_size,
self.other_input_dim),
dtype=np.uint8),
np.zeros((self.agent_count, self.data_size), dtype=np.uint8),
np.zeros((self.agent_count, self.data_size, 1), dtype=np.float32),
np.zeros((self.agent_count, self.data_size, 1), dtype=np.bool)
]
def __init__(self):
self.model = Chain(
QL=L.EmbedID(int(maxL-minL+1),1),
QVJ=L.EmbedID(len(VJ_dict), 1),
QA=L.EmbedID(len(AA)+1,1,ignore_label=0)
)
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
self.Z=1
def __init__(self,name="perceptron",layers=(1000,1000),optimizer=None,activation=F.sigmoid):
Network.__init__(self,name)
self.layers = {}
for i in range(len(layers)-1):
layer = L.Linear(layers[i],layers[i+1])
self.layers['l'+str(i)]=layer
self.model = Chain(**self.layers)
if Deel.gpu >=0:
self.model = self.model.to_gpu(Deel.gpu)
self.optimizer = optimizers.MomentumSGD(lr=0.01,momentum=0.9)
self.optimizer.setup(self.model)
self.activation = activation
def __init__(self, d, f, R):
self.d = d
self.f = f
self.R = R
g = ChainList(*[L.Linear(1, f) for i in six.moves.range(AtomIdMax)])
H = ChainList(*[
ChainList(*[L.Linear(f, f) for i in six.moves.range(R)])
for j in six.moves.range(5)
])
W = ChainList(*[L.Linear(f, d) for i in six.moves.range(R)])
self.model = Chain(H=H, W=W, g=g)
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
def show_test_performance(model: chainer.Chain,
test: Iterable[Any],
*,
device: int = 0,
batchsize: int = 256) -> None:
if device >= 0:
model.to_gpu()
test_iter = chainer.iterators.SerialIterator(test,
batchsize,
repeat=False,
shuffle=False)
test_evaluator = extensions.Evaluator(test_iter, model, device=device)
results = test_evaluator()
print("Test accuracy:", results["main/accuracy"])
def generate_mols(model: chainer.Chain,
temp=0.5,
z_mu=None,
batch_size=20,
true_adj=None,
device=-1):
"""
:param model: GraphNVP model
:param z_mu: latent vector of a molecule
:param batch_size:
:param true_adj:
:param gpu:
:return:
"""
device_obj = chainer.backend.get_device(device)
xp = device_obj.xp
z_dim = model.adj_size + model.x_size
mu = xp.zeros([z_dim], dtype=xp.float32)
sigma_diag = xp.ones([z_dim])
if model.hyperparams.learn_dist:
sigma_diag = xp.sqrt(xp.exp(model.ln_var.data)) * sigma_diag
# sigma_diag = xp.exp(xp.hstack((model.ln_var_x.data, model.ln_var_adj.data)))
sigma = temp * sigma_diag
with chainer.no_backprop_mode():
if z_mu is not None:
mu = z_mu
sigma = 0.01 * xp.eye(z_dim, dtype=xp.float32)
z = xp.random.normal(mu, sigma, (batch_size, z_dim)).astype(xp.float32)
x, adj = model.reverse(z, true_adj=true_adj)
return x, adj
def __init__(self, d, f, R, gpu):
self.d = d
self.f = f
self.R = R
self.gpu = gpu
g = ChainList(*[L.Linear(1, f) for i in six.moves.range(AtomIdMax)])
H = ChainList(*[L.Linear(f, f) for i in six.moves.range(R)])
W = ChainList(*[L.Linear(f, d) for i in six.moves.range(R + 1)])
self.optimizer = optimizers.Adam()
self.model = Chain(H=H, W=W, g=g)
if gpu:
self.model.to_gpu(0)
self.optimizer.setup(self.model)
self.to = [[] for i in six.moves.range(2)]
self.atom_sid = [[] for i in six.moves.range(2)]
self.anum = [[] for i in six.moves.range(2)]
def __init__(self,
rng,
data,
target,
n_inputs=784,
n_hidden=[784, 784, 784, 784, 784],
n_outputs=1,
corruption_levels=[0.1, 0.1, 0.1, 0.1, 0.1],
gpu=-1):
self.model = Chain(l1=L.Linear(n_inputs, n_hidden[0]),
l2=L.Linear(n_hidden[0], n_hidden[1]),
l3=L.Linear(n_hidden[1], n_hidden[2]),
l4=L.Linear(n_hidden[2], n_hidden[3]),
l5=L.Linear(n_hidden[3], n_hidden[4]),
l6=L.Linear(n_hidden[4], n_outputs))
if gpu >= 0:
self.model.to_gpu()
self.xp = cuda.cupy
else:
self.xp = np
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.hidden_size = len(n_hidden)
self.dae1 = None
self.dae2 = None
self.dae3 = None
self.dae4 = None
self.dae5 = None
self.optimizer = None
self.setup_optimizer()
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 = Chain(
l4=L.Linear(self.dim * self.hist_size,
hidden_dim,
initialW=initializers.Normal(
0.5 / math.sqrt(self.dim * self.hist_size))),
q_value=L.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)
# 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 __init__(self, owner, kind_name, link, input=None):
if input == owner:
input = None
if input is not None and not isinstance(input, Node):
raise TypeError("Invalid argument. 'input' must be Node.")
if not isinstance(link, Link):
raise TypeError('Cannot register a non-link object as a child')
Chain.__init__(self)
Node.__init__(self, owner, kind_name)
self.allow_multi_inputs = False
self.output_same_value = True
if input is not None:
input.add_ouput(self)
self.add_input(input)
with self.init_scope():
self.link = link
def __init__(self,
rng,
data,
n_inputs=784,
n_hidden=784,
corruption_level=0.05,
optimizer=optimizers.Adam,
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 = Chain(encoder=L.Linear(n_inputs, n_hidden),
decoder=L.Linear(n_hidden, n_inputs))
if gpu >= 0:
self.model.to_gpu()
self.xp = cuda.cupy
else:
self.xp = np
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
def __init__(self, d, f, R):
self.d = d
self.f = f
self.R = R
g = ChainList(*[L.Linear(1, f) for i in six.moves.range(AtomIdMax)])
H = ChainList(*[ChainList(*[L.Linear(f, f)
for i in six.moves.range(R)])
for j in six.moves.range(5)])
W = ChainList(*[L.Linear(f, d) for i in six.moves.range(R)])
self.model = Chain(H=H, W=W, g=g)
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
def __init__(self, model, owner=None, kind_name='root', input=None):
if input == owner:
input = None
if input is not None and not isinstance(input, Node):
raise TypeError("Invalid argument. 'input' must be Node.")
Chain.__init__(self)
Node.__init__(self, owner, kind_name)
self.allow_multi_inputs = False
self.output_same_value = True
if input is not None:
input.add_ouput(self)
self.add_input(input)
self.model = model # この Module が属する Model
self.nodes = [] # 子ノード列
self.kindwise_count = {} # 種類毎の子ノード数
self.firsts = None # 最初のノード列
self.lasts = None # 最後のノード列
self.assembly_depth = 0 # これが 0 以外ならノード生成時に子ノードとして登録される、0 なら self.owner の子ノードとして登録される
def get_predicted_scores(
model: chainer.Chain,
test_iterator: chainer.iterators.MultiprocessIterator,
converter: Callable,
device_id: int,
) -> np.ndarray:
device = chainer.get_device(device_id)
device.use()
model.to_gpu()
pred_scores = []
with chainer.using_config("train", False):
with chainer.using_config("enable_backprop", False):
for batch in test_iterator:
inputs = converter(batch, device)
y = model.predict(*inputs)
y.to_cpu()
pred_scores.append(y.data.ravel())
return np.hstack(pred_scores)
def darknetConv2D(in_channel, out_channel, bn=True):
if (bn):
return Chain(
c=L.Convolution2D(in_channel,
out_channel,
ksize=3,
pad=1,
nobias=True),
n=L.BatchNormalization(out_channel, use_beta=False, eps=0.000001),
b=L.Bias(shape=[
out_channel,
]),
)
else:
return Chain(
c=L.Convolution2D(in_channel,
out_channel,
ksize=3,
pad=1,
nobias=True),
b=L.Bias(shape=[
out_channel,
]),
)
def __init__(self, d, f, R, gpu):
self.d = d
self.f = f
self.R = R
self.gpu = gpu
g = ChainList(*[L.Linear(1, f) for i in six.moves.range(AtomIdMax)])
H = ChainList(*[L.Linear(f, f) for i in six.moves.range(R)])
W = ChainList(*[L.Linear(f, d) for i in six.moves.range(R + 1)])
self.optimizer = optimizers.Adam()
self.model = Chain(H=H, W=W, g=g)
if gpu:
self.model.to_gpu(0)
self.optimizer.setup(self.model)
self.to = [[] for i in six.moves.range(2)]
self.atom_sid = [[] for i in six.moves.range(2)]
self.anum = [[] for i in six.moves.range(2)]
class Perceptron(Chain, Network):
def __init__(self,
name="perceptron",
layers=(1000, 1000),
optimizer=None,
activation=F.sigmoid):
Network.__init__(self, name)
self.layers = {}
for i in range(len(layers) - 1):
layer = L.Linear(layers[i], layers[i + 1])
self.layers['l' + str(i)] = layer
self.model = Chain(**self.layers)
if Deel.gpu >= 0:
self.model = self.model.to_gpu(Deel.gpu)
self.optimizer = optimizers.MomentumSGD(lr=0.01, momentum=0.9)
self.optimizer.setup(self.model)
self.activation = activation
def forward(self, x=None, t=None):
if x is None:
x = Tensor.context
xp = Deel.xp
volatile = 'off' if Deel.train else 'on'
h = Variable(np.asarray(x.value, dtype=xp.float32), volatile=volatile)
self.optimizer.zero_grads()
for i in range(len(self.layers)):
h = F.dropout(self.activation(self.layers['l' + str(i)](h)),
train=Deel.train)
h = ChainerTensor(h)
h.use()
return h
def backprop(self, t, x=None):
if x is None:
x = Tensor.context
#loss = F.mean_squared_error(x.content,t.content)
loss = F.softmax_cross_entropy(x.content, t.content)
if Deel.train:
loss.backward()
accuracy = F.accuracy(x.content, t.content)
self.optimizer.update()
return loss.data, accuracy.data
def train_detector(data, label, model_path='model', model=None, optimizer=None, n_batch=20, n_epoch=20):
num_data = len(label)
if model is None:
model = Chain(
conv1=chainer.functions.Convolution2D(1, 32, 3),
conv2=chainer.functions.Convolution2D(32, 64, 3),
l1=chainer.functions.Linear(576, 200),
l2=chainer.functions.Linear(200, 100),
l3=chainer.functions.Linear(100, 10)
)
if optimizer is None:
optimizer = optimizers.Adam()
optimizer.setup(model)
for epoch in range(n_epoch):
print("epoch : %d" % (epoch + 1))
# ランダムに並び替える
perm = numpy.random.permutation(num_data)
sum_accuracy = 0
sum_loss = 0
# バッチサイズごとに学習
b_start = time.time()
for i in range(0, num_data, n_batch):
x_batch = data[perm[i:i + n_batch]]
t_batch = label[perm[i:i + n_batch]]
# 勾配を初期化
optimizer.zero_grads()
# 順伝搬
loss, accuracy = forward(x_batch, t_batch, model)
# 誤差逆伝搬
loss.backward()
optimizer.update() # パラメータ更新
sum_loss += float(loss.data) * n_batch
sum_accuracy += float(accuracy.data) * n_batch
# 誤差と精度を表示
print("[学習]loss: %f, accuracy: %f, time: %f秒"
% (sum_loss / num_data, sum_accuracy / num_data, time.time() - b_start))
# 学習したモデルを保存
pickle.dump(model, open(model_path, 'wb'), -1)
class Perceptron(Chain,Network):
def __init__(self,name="perceptron",layers=(1000,1000),optimizer=None,activation=F.sigmoid):
Network.__init__(self,name)
self.layers = {}
for i in range(len(layers)-1):
layer = L.Linear(layers[i],layers[i+1])
self.layers['l'+str(i)]=layer
self.model = Chain(**self.layers)
if Deel.gpu >=0:
self.model = self.model.to_gpu(Deel.gpu)
self.optimizer = optimizers.MomentumSGD(lr=0.01,momentum=0.9)
self.optimizer.setup(self.model)
self.activation = activation
def forward(self,x=None,t=None):
if x is None:
x=Tensor.context
xp = Deel.xp
volatile = 'off' if Deel.train else 'on'
h = Variable(xp.asarray(x.value,dtype=xp.float32),volatile=volatile)
self.optimizer.zero_grads()
for i in range(len(self.layers)):
h = F.dropout(self.activation(self.layers['l'+str(i)](h)),train=Deel.train)
h = ChainerTensor(h)
h.use()
return h
def backprop(self,t,x=None):
if x is None:
x=Tensor.context
#loss = F.mean_squared_error(x.content,t.content)
loss = F.softmax_cross_entropy(x.content,t.content)
if Deel.train:
loss.backward()
accuracy = F.accuracy(x.content,t.content)
self.optimizer.update()
return loss.data,accuracy.data
class OldModel():
def __init__(self):
self.model = Chain(
QL=L.EmbedID(int(maxL-minL+1),1),
QVJ=L.EmbedID(len(VJ_dict), 1),
QA=L.EmbedID(len(AA)+1,1,ignore_label=0)
)
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
self.Z=1
def forward(self,data):
out1=self.model.QL(data[:,[0]])
out2 = self.model.QVJ(data[:, [1]])
out3=self.model.QA(data[:,2:])
out=F.sum(F.concat((out1,out2,out3),axis=1)[:,:,0],axis=1)
return out
def get_AA_coeficient(self):
QA=self.model.QA.W.data
back_code={val:key for key,val in AA.items()}
out=np.zeros((20,maxL-minL+1,maxL))
for i in range(1,len(QA)):
if i in self.used_coef:
out[AminoAcide[back_code[i][2]],back_code[i][0]-minL,back_code[i][1]]=np.exp(QA[i])
return out
def predict(self,x):
print('prediction')
out=[]
step=50
for i in range(0,len(x),step):
px = Variable(x[i:i+step])
output = F.exp(self.forward(px))/self.Z
out+=list(output.data)
return np.array(out)
def fit(self,DATA,GEN,counts,epochs):
# Make a training function which takes in training data and targets
# as an input.
def train(data, gen, model,counts, batchsize=200000, n_epochs=1):
lcurve=[]
data_size = data.shape[0]
gen_size = gen.shape[0]
gen_var = Variable(gen)
#self.model.to_gpu()
for epoch in range(n_epochs):
# randomly shuffle the indices of the training data
shuffler = np.random.permutation(data_size)
# loop over batches
for i in range(0, data_size, batchsize):
print('epoch %d %d%%' % (epoch + 1,100*i/data_size))
data_var = Variable(data[shuffler[i: i + batchsize]])
counts_var = Variable(counts[shuffler[i: i + batchsize]])
S=np.sum(counts[shuffler[i: i + batchsize]])
output_d = self.forward(data_var)
output_g = F.exp(self.forward(gen_var))
model.zerograds()
loss = -(F.sum(output_d*counts_var)-S*F.log(F.sum(output_g)/gen_size))
lcurve.append(loss.data)
loss.backward()
self.optimizer.update()
return np.array(lcurve)
self.training=True
self.lcurve=train(DATA, GEN, self.model, counts, n_epochs=epochs)
gen_size = GEN.shape[0]
gen_var = Variable(GEN)
output_g = F.exp(self.forward(gen_var))
self.Z = F.sum(output_g) / gen_size
self.training=False
self.used_coef=np.unique(DATA[:,2:])
def __init__(self, nr_in, nr_out):
Chain.__init__(self)
class nfp(object):
"""NFP manager
This class has the generator function of NFP and
updator of NN for learning the generator of NFP.
Args:
d: Dimension of NFP.
f: Dimension of the feature for generating NFP.
R: Radius for generating NFP.
"""
def __init__(self, d, f, R):
self.d = d
self.f = f
self.R = R
g = ChainList(*[L.Linear(1, f) for i in six.moves.range(AtomIdMax)])
H = ChainList(*[ChainList(*[L.Linear(f, f)
for i in six.moves.range(R)])
for j in six.moves.range(5)])
W = ChainList(*[L.Linear(f, d) for i in six.moves.range(R)])
self.model = Chain(H=H, W=W, g=g)
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
def get_nfp(self, sid, train=True):
"""Generates NFP.
Args:
sid (int): Substance ID.
train (boolean): Training flag. If you want to train
the NFP NN, set it True, otherwise False.
Returns:
fp: NFP.
"""
d, f, R = self.d, self.f, self.R
mol = data.load_sdf(sid)
atoms = mol.GetAtoms()
n = len(atoms)
fp = Variable(np.zeros([1, d], dtype='float32'), volatile=not train)
r = [[Variable(np.zeros([1, f], dtype='float32'), volatile=not train)
for i in six.moves.range(n)] for j in six.moves.range(R + 1)]
for atom in atoms:
a = atom.GetIdx()
anum = atom.GetAtomicNum()
r[0][a] += self.model.g[anum](Variable(np.array([[1]],
dtype='float32'),
volatile=not train))
for l in six.moves.range(R):
v = [Variable(np.zeros([1, f], dtype='float32'),
volatile=not train)
for i in six.moves.range(n)]
for atom in atoms:
a = atom.GetIdx()
v[a] += r[l][a]
for n_atom in atom.GetNeighbors():
na = n_atom.GetIdx()
v[a] += r[l][na]
for atom in atoms:
a = atom.GetIdx()
deg = atom.GetDegree()
deg = min(5, max(1, deg))
r[l + 1][a] = F.tanh(self.model.H[deg - 1][l](v[a]))
i = F.softmax(self.model.W[l](r[l + 1][a]))
fp += i
return fp
def update(self, sids, y, net, train=True):
"""Updates NFP NN.
Args:
sids (int[]): Substance ID.
y (np.array(int32[])[2]): Activity data. y[0] is for
the training dataset and y[1] is for the test dataset.
net (nn.NN): Classifier of QSAR.
train (boolean): Training flag. If you want to train
the NFP NN, set it True, otherwise False.
Returns:
result (float): Overall accuracy on the test dataset.
"""
def get_nfps(sids, train=True):
print('generate fingerprints...')
fps = {}
for i, sid in enumerate(sids[0] + sids[1]):
fps[sid] = self.get_nfp(sid, train)
print('done.')
return fps
self.model.zerograds()
fps = get_nfps(sids, train)
x_train = [fps[sid] for sid in sids[0]]
x_test = [fps[sid] for sid in sids[1]]
for x in x_train:
x.volatile = 'off'
for x in x_test:
x.volatile = 'off'
result = net.train(x_train, y[0], x_test, y[1], train)
self.optimizer.update()
return result
class DA:
def __init__(self,
rng,
data,
n_inputs=784,
n_hidden=784,
corruption_level=0.05,
optimizer=optimizers.Adam,
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 = Chain(encoder=L.Linear(n_inputs, n_hidden),
decoder=L.Linear(n_hidden, n_inputs))
if gpu >= 0:
self.model.to_gpu()
self.xp = cuda.cupy
else:
self.xp = np
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
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.reshape(y_data.shape)), Variable(
y_data.reshape(x_data.shape))
# 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 L.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:
print "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(np.float32)
mask = self.xp.asarray(mask)
ret = mask * x_data
# return self.xp.asarray(ret.astype(np.float32))
return ret
else:
return x_data
def train_and_test(self, n_epoch=5, batchsize=100):
self.save_accuracy = self.xp.tile([1000.0], 2000)
self.best_loss = 1.0
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.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
print '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
print 'test mean loss={}'.format(sum_loss / self.n_test)
if (sum_loss / self.n_test) < self.best_loss:
self.best_loss = sum_loss / self.n_test
self.best_epoch = epoch
serializers.save_hdf5('dae.model', self.model)
print("update best loss")
#早期終了？
if self.xp.mean(self.save_accuracy) < sum_loss:
print("early stopping done")
break
#早期終了用配列にsum_accuracyを追加
self.save_accuracy = self.save_accuracy[1:]
append = self.xp.array([float(sum_loss)])
self.save_accuracy = self.xp.hstack((self.save_accuracy, append))
print("best_epoch: %d" % (self.best_epoch))
serializers.load_hdf5("dae.model", self.model)
# 学習データを画像に変換
def conv_feat_2_image(feats):
data = np.ndarray((len(feats), 1, 28, 28), dtype=np.float32)
for i, f in enumerate(feats):
data[i] = f.reshape(28, 28)
return data
data_train = conv_feat_2_image(data_train)
data_test = conv_feat_2_image(data_test)
# 層のパラメータ
model = Chain(conv1=F.Convolution2D(1, 32, 3),
conv2=F.Convolution2D(32, 64, 3),
l1=F.Linear(576, 200),
l2=F.Linear(200, 100),
l3=F.Linear(100, 10)).to_gpu()
# 伝播のさせかた
def forward(x, is_train=True):
h1 = F.max_pooling_2d(F.relu(model.conv1(x)), 3)
h2 = F.max_pooling_2d(F.relu(model.conv2(h1)), 3)
h3 = F.dropout(F.relu(model.l1(h2)), train=is_train)
h4 = F.dropout(F.relu(model.l2(h3)), train=is_train)
p = model.l3(h4)
return p
# 学習のさせかた
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 = Chain(l4=L.Linear(self.dim * self.hist_size,
hidden_dim,
initialW=I.HeNormal()),
q_value=L.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)
# 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 range(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.target.cleargrads()
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 nfp(object):
"""NFP manager
This class has the generator function of NFP and
updator of NN for learning the generator of NFP.
Args:
d: Dimension of NFP.
f: Dimension of the feature for generating NFP.
R: Radius for generating NFP.
gpu (boolean): GPU flag. If you want to use GPU, set it True.
"""
def __init__(self, d, f, R, gpu):
self.d = d
self.f = f
self.R = R
self.gpu = gpu
g = ChainList(*[L.Linear(1, f) for i in six.moves.range(AtomIdMax)])
H = ChainList(*[L.Linear(f, f) for i in six.moves.range(R)])
W = ChainList(*[L.Linear(f, d) for i in six.moves.range(R + 1)])
self.optimizer = optimizers.Adam()
self.model = Chain(H=H, W=W, g=g)
if gpu:
self.model.to_gpu(0)
self.optimizer.setup(self.model)
self.to = [[] for i in six.moves.range(2)]
self.atom_sid = [[] for i in six.moves.range(2)]
self.anum = [[] for i in six.moves.range(2)]
def get_nfp(self, sids, train=True):
"""Generates NFP.
Args:
sids (int[]): List of substance IDs.
train (boolean): Training flag. If you want to train
the NFP NN, set it True, otherwise False.
Returns:
fp: Dictionary of NFPs. Key is a substance ID.
"""
d, f, R = self.d, self.f, self.R
def add_var(x):
if self.gpu:
return Variable(cuda.to_gpu(x, 0), volatile=not train)
else:
return Variable(x, volatile=not train)
if train:
ti = 0
else:
ti = 1
to = self.to[ti]
atom_sid = self.atom_sid[ti]
anum = self.anum[ti]
if len(to) == 0:
for sid in sids:
mol = data.load_sdf(sid)
atoms = mol.GetAtoms()
n = len(atoms)
base = len(to)
to += [[] for i in six.moves.range(n)]
atom_sid += [sid for i in six.moves.range(n)]
anum += [1 for i in six.moves.range(n)]
for atom in atoms:
anum[base + atom.GetIdx()] = atom.GetAtomicNum()
to[base + atom.GetIdx()] = [base + n_atom.GetIdx()
for n_atom in atom.GetNeighbors()]
for i in six.moves.range(len(to)):
if len(to[i]) == 0:
to[i].append(i)
V = len(atom_sid)
vec = [[] for i in six.moves.range(R + 1)]
fp = {}
for l in six.moves.range(R + 1):
vec[l] = [add_var(np.zeros([1, f], dtype='float32'))
for i in six.moves.range(V)]
for sid in sids:
fp[sid] = add_var(np.zeros([1, d], dtype='float32'))
for i in six.moves.range(V):
vec[0][i] += self.model.g[anum[i]](add_var(np.array([[1]],
dtype='float32')))
p = [[] for i in six.moves.range(R)]
for l in six.moves.range(R):
p[l] = [to[i][np.random.randint(len(to[i]))]
for i in six.moves.range(V)]
for i in six.moves.range(V):
vec[l + 1][i] = F.tanh(self.model.H[l]
(vec[l][i] + vec[l][p[l][i]]))
tmp = [[] for i in six.moves.range(R + 1)]
for l in six.moves.range(R + 1):
for i in six.moves.range(V):
tmp[l].append(F.softmax(self.model.W[l](vec[l][i])))
for l in six.moves.range(R + 1):
for i in six.moves.range(V):
fp[atom_sid[i]] += tmp[l][i]
return fp
def update(self, sids, y, net, train=True):
"""Updates NFP NN.
Args:
sids (int[]): Substance ID.
y (np.array(int32[])[2]): Activity data. y[0] is for
the training dataset and y[1] is for the test dataset.
net (nn.NN): Classifier of QSAR.
train (boolean): Training flag. If you want to train
the NFP NN, set it True, otherwise False.
Returns:
result (float): Overall accuracy on the test dataset.
"""
self.model.zerograds()
fps = self.get_nfp(sids[0] + sids[1], train)
x_train = [fps[sid] for sid in sids[0]]
x_test = [fps[sid] for sid in sids[1]]
for x in x_train:
x.volatile = 'off'
for x in x_test:
x.volatile = 'off'
result = net.train(x_train, y[0], x_test, y[1], train, self.gpu)
self.optimizer.update()
return result
class FaceNet():
def __init__(self):
self.model = Chain(conv1=L.Convolution2D(3, 20, 3, 1, 1),
conv2=L.Convolution2D(20, 20, 3, 1, 1),
conv3=L.Convolution2D(20, 40, 3, 1, 1),
conv4=L.Convolution2D(40, 40, 3, 1, 1),
linear1=L.Linear(None, 100),
linear2=L.Linear(100, 4))
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model)
def foward(self, x):
out = self.model.conv1(x)
out = F.elu(out)
out = self.model.conv2(out)
out = F.max_pooling_2d(out, 2)
out = F.elu(out)
out = self.model.conv3(out)
out = F.elu(out)
out = self.model.conv4(out)
out = F.elu(out)
out = F.average_pooling_2d(out, 6)
out = F.dropout(out)
out = self.model.linear1(out)
out = F.elu(out)
out = F.dropout(out)
out = self.model.linear2(out)
return out
def predict(self, X, step=100):
with chainer.using_config('train', False):
with chainer.no_backprop_mode():
output = []
for i in range(0, len(X), step):
x = Variable(X[i:i + step])
output.append(self.foward(x).data)
return np.vstack(output)
def score(self, X, Y, step=100):
predicted = self.predict(X, step)
score = F.r2_score(predicted, Y).data
return score
def fit(self, X, Y, batchsize=100, n_epoch=10):
with chainer.using_config('train', True):
learning_curve = []
for epoch in range(n_epoch):
print('epoch ', epoch)
index = np.random.permutation(len(X))
for i in range(0, len(index), batchsize):
self.model.cleargrads()
print(i)
x = X[index[i:i + batchsize]]
y = Y[index[i:i + batchsize]]
#augment(x, y)
x = Variable(x)
y = Variable(y)
output = self.foward(x)
loss = F.mean_squared_error(y, output)
loss.backward()
learning_curve.append(float(loss.data))
self.optimizer.update()
return learning_curve
class nfp(object):
"""NFP manager
This class has the generator function of NFP and
updator of NN for learning the generator of NFP.
Args:
d: Dimension of NFP.
f: Dimension of the feature for generating NFP.
R: Radius for generating NFP.
gpu (boolean): GPU flag. If you want to use GPU, set it True.
"""
def __init__(self, d, f, R, gpu):
self.d = d
self.f = f
self.R = R
self.gpu = gpu
g = ChainList(*[L.Linear(1, f) for i in six.moves.range(AtomIdMax)])
H = ChainList(*[L.Linear(f, f) for i in six.moves.range(R)])
W = ChainList(*[L.Linear(f, d) for i in six.moves.range(R + 1)])
self.optimizer = optimizers.Adam()
self.model = Chain(H=H, W=W, g=g)
if gpu:
self.model.to_gpu(0)
self.optimizer.setup(self.model)
self.to = [[] for i in six.moves.range(2)]
self.atom_sid = [[] for i in six.moves.range(2)]
self.anum = [[] for i in six.moves.range(2)]
def get_nfp(self, sids, train=True):
"""Generates NFP.
Args:
sids (int[]): List of substance IDs.
train (boolean): Training flag. If you want to train
the NFP NN, set it True, otherwise False.
Returns:
fp: Dictionary of NFPs. Key is a substance ID.
"""
d, f, R = self.d, self.f, self.R
def add_var(x):
if self.gpu:
return Variable(cuda.to_gpu(x, 0), volatile=not train)
else:
return Variable(x, volatile=not train)
if train:
ti = 0
else:
ti = 1
to = self.to[ti]
atom_sid = self.atom_sid[ti]
anum = self.anum[ti]
if len(to) == 0:
for sid in sids:
mol = data.load_sdf(sid)
atoms = mol.GetAtoms()
n = len(atoms)
base = len(to)
to += [[] for i in six.moves.range(n)]
atom_sid += [sid for i in six.moves.range(n)]
anum += [1 for i in six.moves.range(n)]
for atom in atoms:
anum[base + atom.GetIdx()] = atom.GetAtomicNum()
to[base + atom.GetIdx()] = [
base + n_atom.GetIdx()
for n_atom in atom.GetNeighbors()
]
for i in six.moves.range(len(to)):
if len(to[i]) == 0:
to[i].append(i)
V = len(atom_sid)
vec = [[] for i in six.moves.range(R + 1)]
fp = {}
for l in six.moves.range(R + 1):
vec[l] = [
add_var(np.zeros([1, f], dtype='float32'))
for i in six.moves.range(V)
]
for sid in sids:
fp[sid] = add_var(np.zeros([1, d], dtype='float32'))
for i in six.moves.range(V):
vec[0][i] += self.model.g[anum[i]](add_var(
np.array([[1]], dtype='float32')))
p = [[] for i in six.moves.range(R)]
for l in six.moves.range(R):
p[l] = [
to[i][np.random.randint(len(to[i]))]
for i in six.moves.range(V)
]
for i in six.moves.range(V):
vec[l + 1][i] = F.tanh(self.model.H[l](vec[l][i] +
vec[l][p[l][i]]))
tmp = [[] for i in six.moves.range(R + 1)]
for l in six.moves.range(R + 1):
for i in six.moves.range(V):
tmp[l].append(F.softmax(self.model.W[l](vec[l][i])))
for l in six.moves.range(R + 1):
for i in six.moves.range(V):
fp[atom_sid[i]] += tmp[l][i]
return fp
def update(self, sids, y, net, train=True):
"""Updates NFP NN.
Args:
sids (int[]): Substance ID.
y (np.array(int32[])[2]): Activity data. y[0] is for
the training dataset and y[1] is for the test dataset.
net (nn.NN): Classifier of QSAR.
train (boolean): Training flag. If you want to train
the NFP NN, set it True, otherwise False.
Returns:
result (float): Overall accuracy on the test dataset.
"""
self.model.zerograds()
fps = self.get_nfp(sids[0] + sids[1], train)
x_train = [fps[sid] for sid in sids[0]]
x_test = [fps[sid] for sid in sids[1]]
for x in x_train:
x.volatile = 'off'
for x in x_test:
x.volatile = 'off'
result = net.train(x_train, y[0], x_test, y[1], train, self.gpu)
self.optimizer.update()
return result
def __init__(self, nr_vector, nr_dim, nr_out, set_vectors=None):
Chain.__init__(self,
embed=L.EmbedID(nr_vector, nr_dim, initialW=set_vectors),
project=L.Linear(None, nr_out, nobias=True))
self.embed.W.volatile = False
def __init__(self, nr_vector, nr_dim, nr_out):
Chain.__init__(self,
embed=L.EmbedID(nr_vector, nr_dim),
project=L.Linear(None, nr_out, nobias=True))
# -*- coding:utf-8 -*-
import numpy as np
import chainer
from chainer import Function, Variable, optimizers
from chainer import Link, Chain
import chainer.functions as F
import chainer.links as L
# main
if __name__ == '__main__':
x_data = np.array([[1.0, 0.5]], dtype=np.float32)
t_data = np.array([0])
model = Chain(layer1=L.Linear(2, 2, initialW=np.array([[0.1, 0.2], [0.3, 0.4]], dtype=np.float32)),
layer2=L.Linear(2, 2, initialW=np.array([[0.1, 0.2], [0.3, 0.4]], dtype=np.float32)))
optimizer = optimizers.SGD()
optimizer.setup(model)
x = Variable(x_data)
t = Variable(t_data)
u1 = model.layer1(x)
z1 = F.sigmoid(u1)
u2 = model.layer2(z1)
y = F.softmax(u2)
print "x=\n" + str(x.data)
print "w1=\n" + str(model.layer1.W.data)
print "b1=\n" + str(model.layer1.b.data)
print "u1=\n" + str(u1.data)
def __init__(self):
# super(MyChain, self).__init__() # 多继承的时候，这种比较方便，一次性调用所有父类的构造器
Chain.__init__(self) # 在子类中调用父类的方法，需要加上基类名作为前缀，且还需传入self
with self.init_scope():
self.l1 = L.Linear(4, 3)
self.l2 = L.Linear(3, 2)
def __init__(self, nr_in, nr_out):
Chain.__init__(self,
fwd=L.LSTM(nr_in, nr_out),
bwd=L.LSTM(nr_in, nr_out),
mix=L.Bilinear(nr_out, nr_out, nr_out))
def __call__(self, x):
return MyBiasFunction()(x, self.b)
# DCNN定数
minibatch_size = 16
feature_num = 4
k = 192
model = Chain(
layer1=L.Convolution2D(in_channels = feature_num, out_channels = k, ksize = 5, pad = 2),
layer2=L.Convolution2D(in_channels = k, out_channels = k, ksize = 3, pad = 1),
layer3=L.Convolution2D(in_channels = k, out_channels = k, ksize = 3, pad = 1),
layer4=L.Convolution2D(in_channels = k, out_channels = k, ksize = 3, pad = 1),
layer5=L.Convolution2D(in_channels = k, out_channels = k, ksize = 3, pad = 1),
layer6=L.Convolution2D(in_channels = k, out_channels = k, ksize = 3, pad = 1),
layer7=L.Convolution2D(in_channels = k, out_channels = k, ksize = 3, pad = 1),
layer8=L.Convolution2D(in_channels = k, out_channels = k, ksize = 3, pad = 1),
layer9=L.Convolution2D(in_channels = k, out_channels = k, ksize = 3, pad = 1),
layer10=L.Convolution2D(in_channels = k, out_channels = k, ksize = 3, pad = 1),
layer11=L.Convolution2D(in_channels = k, out_channels = k, ksize = 3, pad = 1),
layer12=L.Convolution2D(in_channels = k, out_channels = k, ksize = 3, pad = 1),
layer13=L.Convolution2D(in_channels = k, out_channels = 1, ksize = 1, nobias = True),
layer13_2=MyBias(19*19))
model.to_gpu()
if args.learning_rate != '':
optimizer = optimizers.SGD(float(args.learning_rate))
else:
optimizer = optimizers.SGD()
def __init__(self, nr_in, nr_out):
Chain.__init__(self,
l1=L.Linear(nr_in, nr_in),
l2=L.Linear(nr_in, nr_out))