def fit(self,
data,
n_epochs,
all_losses=[],
print_every=100,
plot_every=10,
augment=False):
start = time.time()
loss_avg = 0
if augment:
smiles_augmentation = SmilesEnumerator()
else:
smiles_augmentation = None
for epoch in range(1, n_epochs + 1):
inp, target = data.random_training_set(smiles_augmentation)
loss = self.train_step(inp, target)
loss_avg += loss
if epoch % print_every == 0:
print('[%s (%d %d%%) %.4f]' %
(time_since(start), epoch, epoch / n_epochs * 100, loss))
print(self.evaluate(data=data, prime_str='<', predict_len=100),
'\n')
if epoch % plot_every == 0:
all_losses.append(loss_avg / plot_every)
loss_avg = 0
return all_losses
def __init__(self):
self.data = None
self.X_orig = None
self.X = None
self.Y = None
self.X_train = None
self.y_train = None
self.X_test = None
self.y_test = None
self.model = None
self.sme = SmilesEnumerator()
self.unique_adv = []
self.unique_chars = None
self.char_to_int = None
self.int_to_char = None
self.pad = 0
self.numAdv = 0
self.numSamples = 0
self.perturbations = [0]
def smile_augment(self, input_smiles, times):
print('Begin SMILES augmentation ...')
sme = SmilesEnumerator(pad=0, isomericSmiles=False)
smiles_aug = []
times = int(times)
for i in tqdm(range(len(input_smiles))):
smi = input_smiles[i]
boom = []
for j in range(times):
temp = sme.randomize_smiles(smi)
mol = Chem.MolFromSmiles(temp)
if mol: # check if the randomized smile is a valid molecule
boom.append(temp)
else:
continue
smiles_aug.extend(boom)
print("Smiles augmentation completed")
print("Length of augmented smiles set:", len(smiles_aug))
print("Sample augmented SMILES:\n", smiles_aug[2:10])
return smiles_aug
def lipo_lstm_test(r,threshold_SC,threshold_BC,symbols_TC,seq,TestCaseNum,Mutation,CoverageStop):
r.resetTime()
seeds = 3
random.seed(seeds)
# set oracle radius
oracleRadius = 0.2
# load model
lipo = lipoClass()
lipo.load_data()
lipo.load_model()
sme = SmilesEnumerator()
# test layer
layer = 1
# choose time steps to cover
t1 = int(seq[0])
t2 = int(seq[1])
indices = slice(t1, t2 + 1)
# calculate mean and std for z-norm
h_train = lipo.cal_hidden_keras(lipo.X_train, layer)
mean_TC, std_TC, max_SC, min_SC, max_BC, min_BC = aggregate_inf(h_train, indices)
n_seeds = 200
# get the seeds pool
smiles_seeds = []
for item in lipo.X_orig_train:
if sme.randomize_smiles(item,0) != None:
smiles_seeds.append(item)
if len(smiles_seeds) == n_seeds:
break
smiles_seeds = np.array(smiles_seeds)
X_seeds = lipo.smile_vect(smiles_seeds)
# predict logD value from smiles representation
smiles = np.array(['SCC(=O)O[C@@]1(SC[NH+](C[C@H]1SC=C)C)c2SCSCc2'])
test = np.squeeze(lipo.smile_vect(smiles))
[h_t, c_t, f_t] = lipo.cal_hidden_state(test,layer)
# test objective NC
nctoe = NCTestObjectiveEvaluation(r)
threshold_nc = 0
nctoe.testObjective.setParamters(lipo.model, layer, threshold_nc, test)
# test objective KMNC
kmnctoe = KMNCTestObjectiveEvaluation(r)
k_sec = 10
kmnctoe.testObjective.setParamters(lipo.model, layer, k_sec, test)
# test objective NBC
nbctoe = NBCTestObjectiveEvaluation(r)
ub = 0.7
lb = -0.7
nbctoe.testObjective.setParamters(lipo.model, layer, ub, lb, test)
# test objective SNAC
snactoe = NCTestObjectiveEvaluation(r)
threshold_snac = 0.7
snactoe.testObjective.setParamters(lipo.model, layer, threshold_snac, test)
# test objective SC
SCtoe = SCTestObjectiveEvaluation(r)
SC_test_obj = 'h'
act_SC = SCtoe.get_activations(np.array([h_t]))
SCtoe.testObjective.setParamters(lipo.model, SC_test_obj, layer, float(threshold_SC), indices, max_SC, min_SC, np.squeeze(act_SC))
# test objective BC
BCtoe = BCTestObjectiveEvaluation(r)
BC_test_obj = 'h'
act_BC = BCtoe.get_activations(np.array([h_t]))
BCtoe.testObjective.setParamters(lipo.model, BC_test_obj, layer, float(threshold_BC), indices, max_BC, min_BC, np.squeeze(act_BC))
# test objective TC
TCtoe = TCTestObjectiveEvaluation(r)
seq_len = 5
TC_test_obj = 'h'
TCtoe.testObjective.setParamters(lipo.model, TC_test_obj, layer, int(symbols_TC), seq_len, indices, mean_TC, std_TC)
y_seeds = np.squeeze(lipo.model.predict(X_seeds))
X_test = []
r_t = 400 // len(X_seeds)
while lipo.numSamples < int(TestCaseNum):
# generate test cases
unique_test = np.repeat(np.arange(len(X_seeds)), r_t, axis=0)
smiles_test1 = np.repeat(smiles_seeds, r_t, axis=0)
y_test1 = np.repeat(y_seeds, r_t, axis=0)
new_smiles = np.array([sme.randomize_smiles(smiles_test1[i], i+lipo.numSamples) for i in range(len(smiles_test1))])
test2 = lipo.smile_vect(new_smiles)
if lipo.numSamples > 0 and Mutation == 'genetic':
y_test1 = np.concatenate((y_test1, np.array([sc_test_1]), np.array([bc_test_1]), np.array([tc_test_1])))
test2 = np.concatenate((test2, np.array([sc_test_2]), np.array([bc_test_2]), np.array([tc_test_2])))
unique_test = np.concatenate((unique_test, np.array([seed_id_sc]), np.array([seed_id_bc]), np.array([seed_id_tc])))
y_test2 = np.squeeze(lipo.model.predict(test2))
# # display statistics of adv.
lipo.displayInfo(y_test1, y_test2, unique_test)
# calculate the hidden state
h_test = lipo.cal_hidden_keras(test2, layer)
# update the coverage
# update NC coverage
nctoe.update_features(test2)
# update KMNC coverage
kmnctoe.update_features(test2)
# update NBC coverage
nbctoe.update_features(test2)
# update SNAC coverage
snactoe.update_features(test2)
# update SC coverage
SCtoe.update_features(h_test, len(X_test))
# update BC coverage
BCtoe.update_features(h_test, len(X_test))
# update TC coverage
TCtoe.update_features(h_test, len(X_test))
X_test = X_test + test2.tolist()
if Mutation == 'genetic':
num_generation = 10
sc_test_record = SCtoe.testObjective.test_record
bc_test_record = BCtoe.testObjective.test_record
tc_test_record = TCtoe.testObjective.test_record
if len(sc_test_record) != 0:
print('boost coverage for SC')
sc_feature, sc_cov_fit = random.choice(list(sc_test_record.items()))
seed_id_sc = sc_cov_fit[0] % len(X_seeds)
sc_test_1 = y_seeds[seed_id_sc]
# boost coverage with GA
sc_test_2 = getNextInputByGA(lipo, SCtoe, sc_feature, np.array(X_test[sc_cov_fit[0]]), num_generation,
lipo.numSamples)
print('\n')
else:
sc_test_1 = y_seeds[0]
sc_test_2 = X_seeds[0]
seed_id_sc = 0
if len(bc_test_record) != 0:
print('boost coverage for BC')
bc_feature, bc_cov_fit = random.choice(list(bc_test_record.items()))
seed_id_bc = bc_cov_fit[0] % len(X_seeds)
bc_test_1 = y_seeds[seed_id_bc]
# boost coverage with GA
bc_test_2 = getNextInputByGA(lipo, BCtoe, bc_feature, np.array(X_test[bc_cov_fit[0]]), num_generation,
lipo.numSamples)
print('\n')
else:
bc_test_1 = y_seeds[0]
bc_test_2 = X_seeds[0]
seed_id_bc = 0
if len(tc_test_record) != 0:
print('boost coverage for TC')
tc_feature, tc_cov_fit = random.choice(list(tc_test_record.items()))
seed_id_tc = tc_cov_fit[1] % len(X_seeds)
tc_test_1 = y_seeds[seed_id_tc]
# boost coverage with GA
tc_test_2 = getNextInputByGA(lipo, TCtoe, tc_feature, np.array(X_test[tc_cov_fit[1]]), num_generation,
lipo.numSamples)
else:
tc_test_1 = y_seeds[0]
tc_test_2 = X_seeds[0]
seed_id_tc = 0
# write information to file
writeInfo(r, lipo.numSamples, lipo.numAdv, lipo.perturbations, nctoe.coverage, kmnctoe.coverage, nbctoe.coverage,
snactoe.coverage, SCtoe.coverage, BCtoe.coverage, TCtoe.coverage, len(lipo.unique_adv))
print("statistics: \n")
nctoe.displayCoverage()
kmnctoe.displayCoverage()
nbctoe.displayCoverage()
snactoe.displayCoverage()
SCtoe.displayCoverage()
BCtoe.displayCoverage()
TCtoe.displayCoverage()
print('unique adv.', len(lipo.unique_adv))
lipo.displaySuccessRate()
import pandas as pd
import rdkit
from rdkit import Chem
import os
import sys
import torch
import re
from tqdm import tqdm
import SmilesEnumerator.SmilesEnumerator as se
sme = se.SmilesEnumerator()
def clear_info(smiles):
mol = Chem.MolFromSmiles(smiles)
for atom in mol.GetAtoms():
if atom.HasProp('molAtomMapNumber'):
atom.ClearProp('molAtomMapNumber')
return Chem.MolToSmiles(mol, canonical=False)
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-use_data_path', default='../../databox/select_50k/database_all.csv')
parser.add_argument('-output_dir', default='../../databox/select_50k/')
parser.add_argument('-canonical_pd_info_list', default='../../databox/select_50k/canonical_pd_info_list')
opt = parser.parse_args()
return X_ret
def createLSTM(input_shape):
output_shape = 1
model = Sequential()
model.add(LSTM(64,input_shape=input_shape,dropout = 0.2))
model.add(Dense(output_shape,activation="sigmoid"))
model.compile(loss='binary_crossentropy',optimizer=Adam(lr=0.001))
print model.summary()
NN = false # set to true to run LSTM
targets = ['target1', 'target2', 'target3','target4','target5','target6','target7','target8', 'target9','target10','target11','target12']
sme = SmilesEnumerator()
auc = []
f1 = []
d = pd.read_csv("data.csv")
for i in range(1,13): #to cover the 12 targets
target = 'target' + str(i)
d[target] = d.apply( # fill missing values with median of row
lambda row: np.median(row) if np.isnan(row[target]) else row[target],
axis=1
)
da = d.copy()
#da.dropna(inplace=True) # alternatively, drop rows with missing values
#downSample:
df_majority = da[da[target]==0]
df_minority = da[da[target]==1]
def lipo_lstm_test(r, threshold_CC, threshold_MC, symbols_SQ, seq, TestCaseNum,
minimalTest, TargMetri, CoverageStop):
r.resetTime()
random.seed(1)
# set oracle radius
oracleRadius = 0.2
# load model
lipo = lipoClass()
lipo.load_data()
lipo.load_model()
# minimal test dataset generation
if minimalTest != '0':
ncdata = []
ccdata = []
mcdata = []
sqpdata = []
sqndata = []
# test layer
layer = 1
termin = 0
# predict logD value from smiles representation
smiles = np.array(['CCC(=O)O[C@@]1(CC[NH+](C[C@H]1CC=C)C)c2ccccc2'])
test = np.squeeze(lipo.smile_vect(smiles))
h_t, c_t, f_t = lipo.cal_hidden_state(test)
# input seeds
X_train = lipo.X_train[random.sample(range(3100), 3000)]
# test objective NC
nctoe = NCTestObjectiveEvaluation(r)
nctoe.model = lipo.model
nctoe.testObjective.layer = layer
nctoe.testCase = test
activations_nc = nctoe.get_activations()
nctoe.testObjective.feature = (np.argwhere(
activations_nc >= np.min(activations_nc))).tolist()
nctoe.testObjective.setOriginalNumOfFeature()
# test objective CC
cctoe = CCTestObjectiveEvaluation(r)
cctoe.model = lipo.model
cctoe.testObjective.layer = layer
cctoe.hidden = h_t
cctoe.threshold = float(threshold_CC)
activations_cc = cctoe.get_activations()
total_features_cc = (np.argwhere(
activations_cc >= np.min(activations_cc))).tolist()
cctoe.testObjective.feature = total_features_cc
cctoe.testObjective.setOriginalNumOfFeature()
cctoe.testObjective.setfeaturecount()
# test objective MC
mctoe = MCTestObjectiveEvaluation(r)
mctoe.model = lipo.model
mctoe.testObjective.layer = layer
mctoe.hidden = f_t
mctoe.threshold = float(threshold_MC)
activations_mc = mctoe.get_activations()
total_features_mc = (np.argwhere(
activations_mc >= np.min(activations_mc))).tolist()
mctoe.testObjective.feature = total_features_mc
mctoe.testObjective.setOriginalNumOfFeature()
mctoe.testObjective.setfeaturecount()
# test objective SQ
sqtoe = SQTestObjectiveEvaluation(r)
sqtoe.model = lipo.model
sqtoe.testObjective.layer = layer
sqtoe.symbols = int(symbols_SQ)
# generate all the features
# choose time steps to cover
t1 = int(seq[0])
t2 = int(seq[1])
indices = slice(t1, t2 + 1)
#slice(70, 75)
# characters to represent time series
alpha_list = [chr(i) for i in range(97, 97 + int(symbols_SQ))]
symb = ''.join(alpha_list)
sqtoe.testObjective.feature_p = list(iter.product(symb,
repeat=t2 - t1 + 1))
sqtoe.testObjective.feature_n = list(iter.product(symb,
repeat=t2 - t1 + 1))
sqtoe.testObjective.setOriginalNumOfFeature()
# define smile enumerator of a molecule
sme = SmilesEnumerator()
for test in X_train:
for i in range(4):
pred1 = lipo.displayInfo(test)
# get next input test2 from the current input test
smiles = lipo.vect_smile(np.array([test]))
new_smiles = np.array([sme.randomize_smiles(smiles[0], i)])
test2 = np.squeeze(lipo.smile_vect(new_smiles))
if not (test2 is None):
pred2 = lipo.displayInfo(test2)
h_t, c_t, f_t = lipo.cal_hidden_state(test2)
cctoe.hidden = h_t
lipo.updateSample(pred1, pred2, 0, True)
# update NC coverage
nctoe.testCase = test2
nctoe.update_features()
# update CC coverage
cctoe.hidden = h_t
cctoe.update_features()
# update MC coverage
mctoe.hidden = f_t
mctoe.update_features()
# update SQ coverage
sqtoe.hidden = h_t
sqtoe.update_features(indices)
# write information to file
writeInfo(r, lipo.numSamples, lipo.numAdv, lipo.perturbations,
nctoe.coverage, cctoe.coverage, mctoe.coverage,
sqtoe.coverage_p, sqtoe.coverage_n)
# terminate condition
if TargMetri == 'CC':
termin = cctoe.coverage
elif TargMetri == 'GC':
termin = mctoe.coverage
elif TargMetri == 'SQN':
termin = sqtoe.coverage_n
elif TargMetri == 'SQP':
termin = sqtoe.coverage_p
# output test cases and adversarial example
if minimalTest == '0':
f = open('output/smiles_test_set.txt', 'a')
f.write(new_smiles[0])
f.write('\n')
f.close()
if abs(pred1 - pred2) >= 1:
f = open('adv_output/adv_smiles_test_set.txt', 'a')
f.write(new_smiles[0])
f.write('\n')
f.close()
else:
if nctoe.minimal == 1:
ncdata.append(test2)
f = open('minimal_nc/test_set.txt', 'a')
f.write(new_smiles[0])
f.write('\n')
f.close()
if cctoe.minimal == 1:
ccdata.append(test2)
f = open('minimal_cc/test_set.txt', 'a')
f.write(new_smiles[0])
f.write('\n')
f.close()
if mctoe.minimal == 1:
mcdata.append(test2)
f = open('minimal_mc/test_set.txt', 'a')
f.write(new_smiles[0])
f.write('\n')
f.close()
if sqtoe.minimalp == 1:
sqpdata.append(test2)
f = open('minimal_sqp/test_set.txt', 'a')
f.write(new_smiles[0])
f.write('\n')
f.close()
if sqtoe.minimaln == 1:
sqndata.append(test2)
f = open('minimal_sqn/test_set.txt', 'a')
f.write(new_smiles[0])
f.write('\n')
f.close()
# check termination condition
if lipo.numSamples < int(TestCaseNum) and termin < float(
CoverageStop):
continue
else:
io.savemat(
'log_folder/feature_count_CC.mat',
{'feature_count_CC': cctoe.testObjective.feature_count})
io.savemat(
'log_folder/feature_count_GC.mat',
{'feature_count_GC': mctoe.testObjective.feature_count})
# if minimalTest != '0':
# np.save('minimal_nc/ncdata', ncdata)
# np.save('minimal_cc/ccdata', ccdata)
# np.save('minimal_mc/mcdata', mcdata)
# np.save('minimal_sqp/sqpdata', sqpdata)
# np.save('minimal_sqn/sqndata', sqndata)
break
if lipo.numSamples < int(TestCaseNum) and termin < float(CoverageStop):
continue
else:
break
print("statistics: \n")
nctoe.displayCoverage()
cctoe.displayCoverage()
mctoe.displayCoverage()
sqtoe.displayCoverage1()
sqtoe.displayCoverage2()
lipo.displaySamples()
lipo.displaySuccessRate()
class lipoClass:
def __init__(self):
self.data = None
self.X_orig = None
self.X = None
self.Y = None
self.X_train = None
self.y_train = None
self.X_test = None
self.y_test = None
self.model = None
self.sme = SmilesEnumerator()
self.unique_adv = []
self.unique_chars = None
self.char_to_int = None
self.int_to_char = None
self.pad = 0
self.numAdv = 0
self.numSamples = 0
self.perturbations = [0]
def load_data(self):
self.data = pd.read_csv("dataset/Lipophilicity.csv")
self.pre_processing()
self.smile_dict()
self.pad = len(max(self.X_orig, key=len))
self.X = self.smile_vect(self.X_orig)
self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(
self.X, self.Y, test_size=0.2, random_state=2)
self.X_orig_train = self.vect_smile(self.X_train)
def pre_processing(self):
self.X_orig = np.array(self.data.smiles)
self.Y = np.array(self.data.exp)
index = [
i for i in range(len(self.X_orig)) if len(self.X_orig[i]) <= 80
]
self.X_orig = self.X_orig[index]
self.Y = self.Y[index]
def smile_dict(self):
raw_data = ''.join(self.X_orig)
self.unique_chars = sorted(list(set(raw_data)))
# maps each unique character as int
self.char_to_int = dict(
(c, i + 1) for i, c in enumerate(self.unique_chars))
# int to char dictionary
self.int_to_char = dict(
(i + 1, c) for i, c in enumerate(self.unique_chars))
def smile_vect(self, X):
new_X = np.zeros((X.shape[0], self.pad), dtype=np.int8)
for i, ss in enumerate(X):
l = len(ss)
diff = self.pad - l
for j, c in enumerate(ss):
new_X[i, j + diff] = self.char_to_int[c]
return new_X
def load_model(self):
self.model = load_model('models/Lipo.h5',
custom_objects={'rmse': rmse})
self.model.compile(loss='mean_squared_error',
optimizer='adam',
metrics=[rmse])
self.model.summary()
def layerName(self, layer):
layerNames = [layer.name for layer in self.model.layers]
return layerNames[layer]
def train_model(self):
self.load_data()
char_num = len(self.unique_chars) + 1
embedding_vector_length = 8
self.model = Sequential()
self.model.add(
Embedding(char_num, embedding_vector_length,
input_length=self.pad))
self.model.add(LSTM(64))
self.model.add(Dropout(0.2))
self.model.add(Dense(1, activation="linear"))
self.model.compile(loss='mean_squared_error',
optimizer='adam',
metrics=[rmse])
print(self.model.summary())
self.model.fit(self.X_train,
self.y_train,
validation_data=(self.X_test, self.y_test),
nb_epoch=300,
batch_size=32)
self.model.save('Lipo.h5')
def vect_smile(self, vect):
smiles = []
for v in vect:
# mask v
v = filter(None, v)
smile = "".join(self.int_to_char[i] for i in v)
smiles.append(smile)
return np.array(smiles)
def displayInfo(self, y_test1, y_test2, unique_test):
diff = y_test1 - y_test2
adv_index = np.where(abs(diff) > 1)
adv_n = len(adv_index[0])
unique_test = unique_test[adv_index]
if adv_n != 0:
for item in unique_test:
if item not in self.unique_adv:
self.unique_adv.append(item)
self.numAdv += adv_n
self.numSamples += len(y_test2)
self.displaySuccessRate()
def mutation(self, test, test_num, seed):
out = []
smiles = self.vect_smile(np.array([test]))
new_smiles = [
self.sme.randomize_smiles(smiles[0], seed + i)
for i in range(test_num)
]
new_test = self.smile_vect(np.array(new_smiles))
return new_test.tolist()
def displaySamples(self):
print("%s samples are considered" % (self.numSamples))
def displaySuccessRate(self):
print("%s samples, within which there are %s adversarial examples" %
(self.numSamples, self.numAdv))
print("the rate of adversarial examples is %.2f\n" %
(self.numAdv / self.numSamples))
def displayPerturbations(self):
if self.numAdv > 0:
print(
"the average perturbation of the adversarial examples is %s" %
(sum(self.perturbations) / self.numAdv))
print(
"the smallest perturbation of the adversarial examples is %s" %
(min(self.perturbations)))
# calculate the lstm hidden state and cell state manually
def cal_hidden_state(self, test, layer):
acx = get_activations_single_layer(self.model, np.array([test]),
self.layerName(0))
units = int(
int(self.model.layers[1].trainable_weights[0].shape[1]) / 4)
# print("No units: ", units)
# lstm_layer = model.layers[1]
W = self.model.layers[1].get_weights()[0]
U = self.model.layers[1].get_weights()[1]
b = self.model.layers[1].get_weights()[2]
W_i = W[:, :units]
W_f = W[:, units:units * 2]
W_c = W[:, units * 2:units * 3]
W_o = W[:, units * 3:]
U_i = U[:, :units]
U_f = U[:, units:units * 2]
U_c = U[:, units * 2:units * 3]
U_o = U[:, units * 3:]
b_i = b[:units]
b_f = b[units:units * 2]
b_c = b[units * 2:units * 3]
b_o = b[units * 3:]
# calculate the hidden state value
h_t = np.zeros((self.pad, units))
c_t = np.zeros((self.pad, units))
f_t = np.zeros((self.pad, units))
h_t0 = np.zeros((1, units))
c_t0 = np.zeros((1, units))
for i in range(0, self.pad):
f_gate = hard_sigmoid(
np.dot(acx[i, :], W_f) + np.dot(h_t0, U_f) + b_f)
i_gate = hard_sigmoid(
np.dot(acx[i, :], W_i) + np.dot(h_t0, U_i) + b_i)
o_gate = hard_sigmoid(
np.dot(acx[i, :], W_o) + np.dot(h_t0, U_o) + b_o)
new_C = np.tanh(np.dot(acx[i, :], W_c) + np.dot(h_t0, U_c) + b_c)
c_t0 = f_gate * c_t0 + i_gate * new_C
h_t0 = o_gate * np.tanh(c_t0)
c_t[i, :] = c_t0
h_t[i, :] = h_t0
f_t[i, :] = f_gate
return h_t, c_t, f_t
def cal_hidden_keras(self, test, layernum):
if layernum == 0:
acx = test
else:
acx = get_activations_single_layer(self.model, np.array(test),
self.layerName(layernum - 1))
units = int(
int(self.model.layers[layernum].trainable_weights[0].shape[1]) / 4)
inp = keras.layers.Input(batch_shape=(None, acx.shape[1],
acx.shape[2]),
name="input")
rnn, s, c = keras.layers.LSTM(units,
return_sequences=True,
stateful=False,
return_state=True,
name="RNN")(inp)
states = keras.models.Model(inputs=[inp], outputs=[s, c, rnn])
for layer in states.layers:
if layer.name == "RNN":
layer.set_weights(self.model.layers[layernum].get_weights())
h_t_keras, c_t_keras, rnn = states.predict(acx)
return rnn