class App:
def __init__(self):
self.parser = configparser.ConfigParser()
self.parser.read("config.INI")
self.dataCenter = DataCenter(self.parser)
self.neuralNetworks = NeuralNetworks(self.parser)
def train(self):
self.neuralNetworks.train(*self.dataCenter.process_data())
def predict(self, data):
"""
API to predict the label of incoming question from user input
:param data:
:return:
"""
res = self.neuralNetworks.inference(
self.dataCenter.process_inference_data(data))
print(res)
def __init__(self):
self.parser = configparser.ConfigParser()
self.parser.read("config.INI")
self.dataCenter = DataCenter(self.parser)
self.neuralNetworks = NeuralNetworks(self.parser)
from DataCenter import DataCenter
from helper import logger
from NeuralNetworks import NeuralNetworks
if __name__ == "__main__":
logger.info("Job started!")
data = DataCenter().run()
neural_network = NeuralNetworks(data)
neural_network.train()
# new_text = neural_network.sample(1000, prime='Far')
# print(new_text)
logger.info("Job finished!")
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='CapitalOneAIEngine')
parser.add_argument('--task',
dest='task',
type=str,
help='Predict or Train from the model')
args = parser.parse_args()
logger.info("Task is :{}".format(args.task))
logger.info("Job started!")
save_model_path = './Model/AlertTransactionModel'
neural_network = NeuralNetworks(save_model_path)
task = args.task
if task == "predict":
new_transaction, _ = DataCenter().run(task)
predict = neural_network.sample(new_transaction)
print("*Predict result:{}".format(predict))
with open('prediction.txt', 'w') as outfile:
json.dump({'predict': predict}, outfile)
elif task == "train":
inputs, targets = DataCenter().run(task)
neural_network.train(inputs, targets)
else:
logger.fatal("!No task assigned, check the input arg '--task'")
logger.info("Job finished!")
from DataCenter import DataCenter
from NeuralNetworks import NeuralNetworks
from helper import logger
if __name__ == "__main__":
logger.info("Start Job...")
data = DataCenter().run()
para_dict = {
'lstm_size': 128,
'lstm_layers': 2,
'embedding_size': 25,
'batch_size': 256,
'epochs': 2,
'keep_prob': 0.5,
'learning_rate': 0.001
}
neuralNetworks = NeuralNetworks(data, para_dict)
neuralNetworks.train()
text = ["BigBig", 'tianwen']
neuralNetworks.seq_to_seq(text, 20)
logger.info("Job is done!")
from SVM import SVM
if __name__ == '__main__':
print(
"Please select the number against the learner you want to build the model for datasets:"
)
print("1 -> Decision Tree")
print("2 -> K-NN")
print("3 -> Neural Networks")
print("4 -> Boosting")
print("5 -> SVM")
switcher = {
1: DecisionTree(),
2: KNN(),
3: NeuralNetworks(),
4: Boosting(),
5: SVM(),
}
datasets = dataset_loader.load_datasets()
model_number = input("Enter your value: ")
model = switcher.get(int(model_number), "Invalid learner")
print("Please select the dataset:")
print("1 -> Diabetes Retinatherapy")
print("2 -> Phishing Website")
dataset_number = input("Enter your value: ")
if int(dataset_number) == 1:
item = datasets[0]
else:
X_s = np.std(X, axis=0)
X = Normalize(X, X_m, X_s)
X_star = Normalize(X_star, X_m, X_s)
# Normalize Output Data
if Normalize_output_data == 1:
Y_m = np.mean(Y, axis=0)
Y_s = np.std(Y, axis=0)
Y = Normalize(Y, Y_m, Y_s)
Y_star = Normalize(Y_star, Y_m, Y_s)
# Model creation
model = NeuralNetworks(X,
Y,
layers,
max_iter=10000,
N_batch=10,
monitor_likelihood=10,
lrate=1e-3)
model.train()
mean_star = model.forward_pass(X_star, model.layers, model.hyp)
plt.figure(1)
plt.rcParams.update({'font.size': 14})
plt.plot(X_star, Y_star, 'b-', linewidth=2)
plt.plot(X_star, mean_star, 'r--', linewidth=3)
plt.scatter(X, Y, alpha=1)
plt.xlabel('$x$')
plt.ylabel('$f(x)$')
from DataCenter import DataCenter
from NeuralNetworks import NeuralNetworks
from helper import logger
if __name__ == "__main__":
logger.info("Start Job...")
inputs, targets = DataCenter().run()
neural_network = NeuralNetworks(inputs,
targets,
split_fraction=0.8,
embed_size=300,
lstm_size=256)
neural_network.train()
neural_network.test()
logger.info("Job is done!")
y_train = data[0:int(data.shape[0] * 0.6), (data.shape[1] - 1):]
x_test = data[int(data.shape[0] * 0.6):, 0:(data.shape[1] - 1)]
y_test = data[int(data.shape[0] * 0.6):, (data.shape[1] - 1):]
def plot_func(x, y, x_label, y_label):
for i in range(x.shape[0]):
if y[i, :] == 0:
plt.scatter(x[i, 0], x[i, 1], color='red')
elif y[i, :] == 1:
plt.scatter(x[i, 0], x[i, 1], color='blue')
elif y[i, :] == 2:
plt.scatter(x[i, 0], x[i, 1], color='green')
else:
plt.scatter(x[i, 0], x[i, 1], color='yellow')
plt.xlabel(x_label)
plt.ylabel(y_label)
plt.show()
plot_func(x_train, y_train, "Trained X", "Trained Y")
plot_func(x_test, y_test, "Test X", "Test Y")
nn = NeuralNetworks(alpha=0.3, iterations=1000)
nn.neural_network(x_train, y_train)
predicted = nn.predict(x_test, y_test)
predicted = predicted.reshape(predicted.shape[0], 1)
print(np.hstack((predicted, y_test)))
acc = nn.accuracy(x_test, y_test)
print("Accuracy = " + str(acc))