def __init__(self, env, save_dirs, learning_rate=0.0001):
BaseModel.__init__(self,
input_shape=env.observation_space.shape,
num_actions=env.action_space.n,
save_dirs=save_dirs)
self.env = env
self.blueprint = {
'conv_layers': 3,
'filters': [32, 64, 64],
'kernel_sizes': [(8, 8), (4, 4), (3, 3)],
'strides': [(4, 4), (2, 2), (1, 1)],
'paddings': ['valid', 'valid', 'valid'],
'activations': ['relu', 'relu', 'relu'],
'dense_units': 512,
'dense_activation': 'relu'
}
self.local_model_save_path = os.path.join(self.save_path,
'local-wts.h5')
self.local_model = NeuralNet(input_shape=self.input_shape,
num_actions=self.num_actions,
learning_rate=learning_rate,
blueprint=self.blueprint).model
def run_LSTM_prediction():
app = wx.App()
lstmNN = NeuralNet(XML)
app.MainLoop()
#if the LSTM has a valid h5 weight file, then load and use it to classify
if lstmNN.LoadLSTM():
lstmNN.Predict()
def __init__(self,
env,
save_dirs,
save_freq=10000,
gamma=0.99,
batch_size=32,
learning_rate=0.0001,
buffer_size=10000,
learn_start=10000,
target_network_update_freq=1000,
train_freq=4,
epsilon_min=0.01,
exploration_fraction=0.1,
tot_steps=int(1e7)):
DDQN.__init__(self,
env=env,
save_dirs=save_dirs,
learning_rate=learning_rate)
self.gamma = gamma
self.batch_size = batch_size
self.learning_rate = learning_rate
self.buffer_size = buffer_size
self.learn_start = learn_start
self.target_network_update_freq = target_network_update_freq
self.train_freq = train_freq
self.epsilon_min = epsilon_min
self.exploration_fraction = exploration_fraction
self.tot_steps = tot_steps
self.epsilon = 1.0
self.exploration = LinearSchedule(schedule_timesteps=int(
self.exploration_fraction * self.tot_steps),
initial_p=self.epsilon,
final_p=self.epsilon_min)
self.save_freq = save_freq
self.replay_buffer = ReplayBuffer(save_dirs=save_dirs,
buffer_size=self.buffer_size,
obs_shape=self.input_shape)
self.exploration_factor_save_path = os.path.join(
self.save_path, 'exploration-factor.npz')
self.target_model_save_path = os.path.join(self.save_path,
'target-wts.h5')
self.target_model = NeuralNet(input_shape=self.input_shape,
num_actions=self.num_actions,
learning_rate=learning_rate,
blueprint=self.blueprint).model
self.show_hyperparams()
self.update_target()
self.load()
def plot():
"""
Ploting the matrix of the coupling constants
"""
n = [400, 10000]
fig, axarr = plt.subplots(nrows=2, ncols=3)
cmap_args=dict(vmin=-1., vmax=1., cmap='seismic')
for i in range(len(n)):
n_samples = n[i]
X = Data[0][:n_samples]
Y = Data[1][:n_samples]
regs = [None, 'l2','l1']
Js = np.zeros((3, L**2))
for j in range(3):
nn = NeuralNet(X,Y, nodes=[X.shape[1], 1], activations=[None], regularization=regs[j], lamb=0.1)
nn.TrainNN(epochs = 500, batchSize = 200, eta0 = 0.01, n_print = 50)
Js[j] = nn.Weights['W1'].flatten()
J_ols = Js[0].reshape(L,L)
J_ridge = Js[1].reshape(L,L)
J_lasso = Js[2].reshape(L,L)
axarr[i][0].imshow(J_ols,**cmap_args)
axarr[i][0].set_title('$\\mathrm{OLS}$',fontsize=16)
axarr[i][0].tick_params(labelsize=16)
axarr[i][1].imshow(J_ridge,**cmap_args)
axarr[i][1].set_title('$\\mathrm{Ridge},\ \\lambda=%.4f$' %(0.1),fontsize=16)
axarr[i][1].tick_params(labelsize=16)
im=axarr[i][2].imshow(J_lasso,**cmap_args)
axarr[i][2].set_title('$\\mathrm{LASSO},\ \\lambda=%.4f$' %(0.1),fontsize=16)
axarr[i][2].tick_params(labelsize=16)
divider = make_axes_locatable(axarr[i][2])
cax = divider.append_axes("right", size="5%", pad=0.05)
cbar=fig.colorbar(im, cax=cax)
cbar.ax.set_yticklabels(np.arange(-1.0, 1.0+0.25, 0.25),fontsize=14)
cbar.set_label('$J_{i,j}$',labelpad=-40, y=1.12,fontsize=16,rotation=0)
#fig.subplots_adjust(right=2.0)
plt.show()
def main():
l, h, e, trainSetFile, testSetFile = getArgs()
trainDataSet = arff.load(open(trainSetFile, 'r'))
testDataSet = arff.load(open(testSetFile, 'r'))
labels = trainDataSet['attributes'][-1][1]
fullTrain, fullTest = dataprocess.process(trainDataSet, testDataSet,
labels)
ann = NeuralNet(h, 1, fullTrain)
trainInfo = ann.train(fullTrain, e, l)
for item in trainInfo:
print('Epoch: {0}\tCross-entropy error: {1}\tCorrectly classified instances: {2}\tMisclassified instances: {3}'.format\
(item[0], item[1], item[2], item[3]))
testInfo, correct, wrong = ann.test(fullTest, labels)
for item in testInfo:
print('Activation of output unit: {0}\tPredicted class: {1}\tCorrect class: {2}'.format\
(item[0], item[1], item[2]))
print('Correctly classified instances: {0}\tMisclassified instances: {1}'.
format(correct, wrong))
def __init__(self, input_vector_size, subnet_output_vector_size):
self.subNet = NeuralNet(no_of_in_nodes=input_vector_size,
no_of_out_nodes=subnet_output_vector_size,
no_of_hidden_nodes=60,
learning_rate=0.1)
self.superNet = NeuralNet(no_of_in_nodes=self.subNet.no_of_out_nodes,
no_of_out_nodes=2,
no_of_hidden_nodes=15,
learning_rate=0.1)
#TODO: This is a placeholder; it's supposed to grow as the alternet learns
self.number_of_alternet_labels = 26
#Placeholder alternate classifier
self.alterNet = NeuralNet(no_of_in_nodes=input_vector_size,
no_of_out_nodes=26,
no_of_hidden_nodes=60,
learning_rate=0.1)
#Offset the alterNet labelKeys by the number of subNet labels so we don't overlap
self.alterNet.set_label_key(
np.array([
i + subnet_output_vector_size
for i in range(self.number_of_alternet_labels)
]))
def reg():
"""
Doing the linear regression using
a neural network
"""
lambdas = np.logspace(-4, 2, 7)
#lambdas = [0.01, 0.1]
n = len(lambdas)
train_mse = np.zeros((3,n))
test_mse = np.zeros((3,n))
regs = [None, 'l1', 'l2']
for j in range(3):
for i in range(n):
nn = NeuralNet(X,Y, nodes=[X.shape[1], 1], activations=[None], regularization=regs[j], lamb=lambdas[i])
nn.TrainNN(epochs = 1000, batchSize = 200, eta0 = 0.01, n_print = 10)
ypred_test = nn.feed_forward(nn.xTest, isTraining=False)
mse_test = nn.cost_function(nn.yTest, ypred_test)
test_mse[j,i] = mse_test
if j == 0:
test_mse[0].fill(test_mse[0,0])
break
plt.semilogx(lambdas, test_mse.T)
plt.xlabel(r'$\lambda$')
plt.ylabel('MSE')
plt.title("MSE on Test Set, %i samples" %(n_samples))
plt.legend(['No Reg', 'L1', 'L2'])
plt.grid(True)
plt.ylim([0, 25])
plt.show()
class DDQN(BaseModel):
def __init__(self, env, save_dirs, learning_rate=0.0001):
BaseModel.__init__(self,
input_shape=env.observation_space.shape,
num_actions=env.action_space.n,
save_dirs=save_dirs)
self.env = env
self.blueprint = {
'conv_layers': 3,
'filters': [32, 64, 64],
'kernel_sizes': [(8, 8), (4, 4), (3, 3)],
'strides': [(4, 4), (2, 2), (1, 1)],
'paddings': ['valid', 'valid', 'valid'],
'activations': ['relu', 'relu', 'relu'],
'dense_units': 512,
'dense_activation': 'relu'
}
self.local_model_save_path = os.path.join(self.save_path,
'local-wts.h5')
self.local_model = NeuralNet(input_shape=self.input_shape,
num_actions=self.num_actions,
learning_rate=learning_rate,
blueprint=self.blueprint).model
def load_mdl(self):
if os.path.isfile(self.local_model_save_path):
self.local_model.load_weights(self.local_model_save_path)
print('Loaded Local Model...')
else:
print('No existing Local Model found...')
def load(self):
self.load_mdl()
def nn_resample(Pca: bool = 0,
smote: bool = 0,
over: bool = 0,
under: bool = 0,
X: np.ndarray = X,
Y: np.ndarray = Y) -> None:
np.random.seed(42)
if Pca:
pca = PCA(n_components=14)
X = pca.fit_transform(X)
##Initialize network###
node1 = X.shape[1]
nn = NeuralNet(X,
Y.flatten(),
nodes=[node1, 3, 2],
activations=['tanh', None],
cost_func='log',
regularization='l2',
lamb=0.001)
###Split Data###
nn.split_data(frac=0.5, shuffle=True)
##Choose resampling teqnique##
if smote:
# sm = SMOTE(random_state=42, sampling_strategy=1.0)
sm = SMOTE()
nn.xTrain, nn.yTrain = sm.fit_resample(nn.xTrain, nn.yTrain)
elif under:
resample = rs(nn.xTrain, nn.yTrain)
nn.xTrain, nn.yTrain = resample.Under()
elif over:
resample = rs(nn.xTrain, nn.yTrain)
nn.xTrain, nn.yTrain = resample.Over()
##Train network##
nn.TrainNN(epochs=100, batchSize=200, eta0=0.01, n_print=50)
import numpy as np
from read_data import get_data
import sys
sys.path.append("network/")
from NN import NeuralNet
X, Y = get_data(normalized=False, standardized=True, file='droppedX6-X11.csv')
nn = NeuralNet(X,
Y.flatten(),
nodes=[18, 50, 50, 2],
activations=['tanh', 'tanh', None],
cost_func='log',
regularization='l2',
lamb=0.001)
nn.split_data(frac=0.5, shuffle=True, resample=True)
nn.TrainNN(epochs=1000, batchSize=200, eta0=0.01, n_print=10)
"""
Neural network calcualting logistic regression
"""
import sys
sys.path.append('network')
sys.path.append('../')
sys.path.append('../../')
import numpy as np
from fetch_2D_data import fetch_data
from NN import NeuralNet
X, Y, X_crit, Y_crit = fetch_data()
nn = NeuralNet(X,
Y,
nodes=[X.shape[1], 2],
activations=[None],
cost_func='log')
nn.TrainNN(epochs=200, batchSize=130, eta0=0.001, n_print=20)
ypred_crit = nn.feed_forward(X_crit, isTraining=False)
critError = nn.cost_function(Y_crit, ypred_crit)
critAcc = nn.accuracy(Y_crit, ypred_crit)
print("Critical error: %g, Critical accuracy: %g" % (critError, critAcc))
run on all the data available in
network/fetch_2D_data"""
import numpy as np
import sys
sys.path.append('network')
sys.path.append('../')
sys.path.append('../../')
from fetch_2D_data import fetch_data
from NN import NeuralNet
X, Y, X_crit, Y_crit = fetch_data()
### LOG-REG CASE
# nn = NeuralNet(X,Y, nodes = [X.shape[1], 2], activations = [None], cost_func='log')
# nn.split_data(frac=0.5, shuffle=True)
# nn.feed_forward(nn.xTrain)
# nn.backpropagation()
# nn.TrainNN(epochs = 100, eta = 0.001, n_print=5)
# 100% ACCURACY MADDAFAKKA
nn = NeuralNet(X,Y, nodes = [X.shape[1],10,2], activations = ['tanh',None],\
cost_func='log', regularization='l2', lamb=0.01)
nn.split_data(frac=0.5, shuffle=True)
nn.TrainNN(epochs=200, eta0=0.01, n_print=5)
ypred_crit = nn.feed_forward(X_crit, isTraining=False)
critError = nn.cost_function(Y_crit, ypred_crit)
critAcc = nn.accuracy(Y_crit, ypred_crit)
print("Critical error: %g, Critical accuracy: %g" % (critError, critAcc))
def best_architecture():
"""
Finding best architectures for neural network
"""
#######################################################
###############Defining parameters#####################
#######################################################
# lambdas = np.logspace(-4, 0, 5)
lambdas = [0.01]
nodes = [5]
regularizations = [None]
n_samples = [10, 20]
activation_functions = [['relu', None]]
df = pd.DataFrame()
########################################################
################Fetching Data###########################
########################################################
X, Y, X_critical, Y_critical = fetch_data()
X, Y = shuffle(X, Y)
X_critical, Y_critical = shuffle(X_critical, Y_critical)
for sample in n_samples:
print(sample)
X_train = X[:sample]; Y_train = Y[:sample]
X_test = X[sample:2*sample]; Y_test = Y[sample:2*sample]
X_crit = X_critical[:sample]; Y_crit = Y_critical[:sample]
for reg in regularizations:
print(reg)
for activation in activation_functions:
print(activation)
for n in nodes:
print(n)
node = [X.shape[1], 2]
node[1:1] = [n]*(len(activation)-1)
print(node)
for lamb in lambdas:
print(lamb)
nn = NeuralNet(
X_train,
Y_train,
nodes = node,
activations = activation,
cost_func='log',
regularization=reg,
lamb=lamb)
nn.TrainNN(epochs = 100)
ypred_train = nn.feed_forward(X_train, isTraining=False)
ypred_test = nn.feed_forward(X_test, isTraining=False)
ypred_crit = nn.feed_forward(X_crit, isTraining=False)
df = df.append({
'Sample size': sample,
'Lambda': lamb,
'Regularization': reg,
'Nodes': n,
'Activation': (len(activation)-1)*activation[0],
'Train error': nn.cost_function(Y_train, ypred_train),
'Test error': nn.cost_function(Y_test, ypred_test),
'Critical error': nn.cost_function(Y_crit, ypred_crit),
'Train accuracy':nn.accuracy(Y_train, ypred_train),
'Test accuracy': nn.accuracy(Y_test, ypred_test),
'Critical accuracy': nn.accuracy(Y_crit, ypred_crit)
}, ignore_index=True)
df.to_csv('best_architecture.csv', index_label='Index')
from MTCS import MonteCarloTreeSearch
# Given the path of the assembly task
fpath = './task_1.xlsx'
# Creat the assembly chessboard via AssembleTask
at1 = AssembleTask(fpath)
# Set random seed
np.random.seed(seed=999)
# Create neural network for robot and human
# Note: the architecure of the neural network
# is given inside the class, one should
# go to NN.py if changes are needed
robot_net = NeuralNet(at1.h, at1.w, at1.d, 16, 1, value_norm=110)
human_net = NeuralNet(at1.h, at1.w, at1.d, 16, 1, value_norm=90)
# Create the MTCS object
mtcs1 = MonteCarloTreeSearch(MaxDepth=3,
MaxSearches=30,
MaxIters=10,
c_puct=100,
atask=at1,
robot_net=robot_net,
human_net=human_net,
switch=5,
tau=1000,
data_size=200
)
one_vs_all=one_vs_all)
if (one_trace):
input_channels = 1
else:
input_channels = 3
for i in range(numItera):
random_st = 42 * i
if (conv):
model = ConvNeuralNet2Dense(input_channels=input_channels,
units=units_CNN,
output_size=output_size)
else:
model = NeuralNet(input_size=inputs.shape[1],
units=units_NN,
output_size=output_size)
X_train, X_val, y_train, y_val = train_test_split(inputs,
labels,
test_size=0.2,
random_state=random_st)
# w = torch.Tensor([12.0,0.5])
loss = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(
model.parameters(),
lr=0.001,
betas=(0.09, 0.999), # eps=1e-08,
weight_decay=0.0)
dataset_train = Dataset(X_train, y_train)
training_generator = data.DataLoader(dataset_train, **params)
import sys
sys.path.append("network/")
from NN import NeuralNet
from metrics import gain_chart, prob_acc
#X, Y = get_data(normalized = False, standardized = False)
X, Y = get_data()
#with open("nn_arch.txt", "w+") as f:
f.write("Activation | Hidden layers | Nodes | Area Test | R2 Test | Error rate \n")
f.write("-"*70)
for act in ['tanh', 'sigmoid', 'relu']:
for size in [5, 10, 20, 50, 100]:
for n_lay in [1, 2, 3]:
nn = NeuralNet(X, Y.flatten(), nodes = [23] + [size]*n_lay + [2], \
activations = [act]*n_lay + [None], cost_func = 'log')
nn.split_data(frac = 0.5, shuffle = True)
nn.TrainNN(epochs = 2000, batchSize = 200, eta0 = 0.01, n_print = 100)
ypred_test = nn.feed_forward(nn.xTest, isTraining=False)
acc = nn.accuracy(nn.yTest, ypred_test)
err_rate = 1 - acc/100
area = gain_chart(nn.yTest, ypred_test, plot=False)
R2 = prob_acc(nn.yTest, ypred_test, plot=False)
f.write("\n %s | %i | %i | %.5f | %.5f | %.3f "\
%(act, n_lay, size, area, R2, err_rate))
f.write("\n" + "-"*70)
class MetaNet:
#TODO: Think about how to generalize this so that it can be built up
def __init__(self, input_vector_size, subnet_output_vector_size):
self.subNet = NeuralNet(no_of_in_nodes=input_vector_size,
no_of_out_nodes=subnet_output_vector_size,
no_of_hidden_nodes=60,
learning_rate=0.1)
self.superNet = NeuralNet(no_of_in_nodes=self.subNet.no_of_out_nodes,
no_of_out_nodes=2,
no_of_hidden_nodes=15,
learning_rate=0.1)
#TODO: This is a placeholder; it's supposed to grow as the alternet learns
self.number_of_alternet_labels = 26
#Placeholder alternate classifier
self.alterNet = NeuralNet(no_of_in_nodes=input_vector_size,
no_of_out_nodes=26,
no_of_hidden_nodes=60,
learning_rate=0.1)
#Offset the alterNet labelKeys by the number of subNet labels so we don't overlap
self.alterNet.set_label_key(
np.array([
i + subnet_output_vector_size
for i in range(self.number_of_alternet_labels)
]))
#superNet is the core of the MetaNet instance, but sub and alter can be swapped out
def setSubNet(self, subNet):
self.subNet = subNet
def setAlterNet(self, alterNet):
self.alterNet = alterNet
#Single Instance Training; returns predictions before altering weights
def trainSubNet(self, img, label):
print(np.argmax(self.subNet.train(img, label)))
return self.subNet.labelKey[np.argmax(self.subNet.train(img, label))]
#TODO: May become defunct if alternet is designed to cluster (eg. learn unsupervised)
def trainAlterNet(self, img, label):
#print(self.alterNet.labelKey[np.argmax(self.alterNet.train(img, label))])
return self.alterNet.labelKey[np.argmax(self.alterNet.train(
img, label))]
#Train super with the bit of input data.
#Returns prediction as (img_label, meta_label) tuple
def trainSuperNet(self, img, img_label, super_label):
subNet_outVector = self.subNet.run(img)
superNet_outVector = self.superNet.train(subNet_outVector.T,
super_label)
return np.argmax(superNet_outVector)
#Return result without altering weights
#TODO: Should this be a tuple as well to keep it in line with train?
def run(self, img):
subNet_outVector = self.subNet.run(img)
superNet_outVector = self.superNet.run(subNet_outVector.T)
if np.argmax(superNet_outVector) == 1:
return self.subNet.labelKey[np.argmax(subNet_outVector)]
else:
return self.alterNet.labelKey[np.argmax(self.alterNet.run(img))]
#TODO: Generalize this so it generates a MetaNet with a sub, meta, and alter net
def generateChild(self, training_set):
#Output vector size is equal to vector size of current network
#As we create new categories each "generation" of network will have more outnodes
child = MetaNet(input_vector_size=self.subNet.no_of_in_nodes,
subnet_output_vector_size=self.subNet.no_of_out_nodes +
self.alterNet.no_of_out_nodes)
accuracy = []
for datum in training_set:
img, label = datum
parentResult = self.run(img)
if (parentResult != label):
accuracy.append(0)
else:
accuracy.append(1)
child.subNet.train(img, parentResult)
return child, accuracy
class DDQNLearner(DDQN):
def __init__(self,
env,
save_dirs,
save_freq=10000,
gamma=0.99,
batch_size=32,
learning_rate=0.0001,
buffer_size=10000,
learn_start=10000,
target_network_update_freq=1000,
train_freq=4,
epsilon_min=0.01,
exploration_fraction=0.1,
tot_steps=int(1e7)):
DDQN.__init__(self,
env=env,
save_dirs=save_dirs,
learning_rate=learning_rate)
self.gamma = gamma
self.batch_size = batch_size
self.learning_rate = learning_rate
self.buffer_size = buffer_size
self.learn_start = learn_start
self.target_network_update_freq = target_network_update_freq
self.train_freq = train_freq
self.epsilon_min = epsilon_min
self.exploration_fraction = exploration_fraction
self.tot_steps = tot_steps
self.epsilon = 1.0
self.exploration = LinearSchedule(schedule_timesteps=int(
self.exploration_fraction * self.tot_steps),
initial_p=self.epsilon,
final_p=self.epsilon_min)
self.save_freq = save_freq
self.replay_buffer = ReplayBuffer(save_dirs=save_dirs,
buffer_size=self.buffer_size,
obs_shape=self.input_shape)
self.exploration_factor_save_path = os.path.join(
self.save_path, 'exploration-factor.npz')
self.target_model_save_path = os.path.join(self.save_path,
'target-wts.h5')
self.target_model = NeuralNet(input_shape=self.input_shape,
num_actions=self.num_actions,
learning_rate=learning_rate,
blueprint=self.blueprint).model
self.show_hyperparams()
self.update_target()
self.load()
def update_exploration(self, t):
self.epsilon = self.exploration.value(t)
def update_target(self):
self.target_model.set_weights(self.local_model.get_weights())
def remember(self, obs, action, rew, new_obs, done):
self.replay_buffer.add(obs, action, rew, new_obs, done)
def step_update(self, t):
hist = None
if t <= self.learn_start:
return hist
if t % self.train_freq == 0:
hist = self.learn()
if t % self.target_network_update_freq == 0:
self.update_target()
return hist
def act(self, obs):
if np.random.rand() < self.epsilon:
return self.env.action_space.sample()
q_vals = self.local_model.predict(
np.expand_dims(obs, axis=0).astype(float) / 255, batch_size=1)
return np.argmax(q_vals[0])
def learn(self):
if self.replay_buffer.meta_data['fill_size'] < self.batch_size:
return
curr_obs, action, reward, next_obs, done = self.replay_buffer.get_minibatch(
self.batch_size)
target = self.local_model.predict(curr_obs.astype(float) / 255,
batch_size=self.batch_size)
done_mask = done.ravel()
undone_mask = np.invert(done).ravel()
target[done_mask,
action[done_mask].ravel()] = reward[done_mask].ravel()
Q_target = self.target_model.predict(next_obs.astype(float) / 255,
batch_size=self.batch_size)
Q_future = np.max(Q_target[undone_mask], axis=1)
target[undone_mask, action[undone_mask].ravel(
)] = reward[undone_mask].ravel() + self.gamma * Q_future
hist = self.local_model.fit(curr_obs.astype(float) / 255,
target,
batch_size=self.batch_size,
verbose=0).history
return hist
def load_mdl(self):
super().load_mdl()
if os.path.isfile(self.target_model_save_path):
self.target_model.load_weights(self.target_model_save_path)
print('Loaded Target Model...')
else:
print('No existing Target Model found...')
def save_mdl(self):
self.local_model.save_weights(self.local_model_save_path)
print('Local Model Saved...')
self.target_model.save_weights(self.target_model_save_path)
print('Target Model Saved...')
def save_exploration(self):
np.savez(self.exploration_factor_save_path, exploration=self.epsilon)
print('Exploration Factor Saved...')
def load_exploration(self):
if os.path.isfile(self.exploration_factor_save_path):
with np.load(self.exploration_factor_save_path) as f:
self.epsilon = np.asscalar(f['exploration'])
print('Exploration Factor Loaded...')
else:
print('No existing Exploration Factor found...')
def save(self, t, logger):
ep = logger.data['episode']
if (self.save_freq is not None and t > self.learn_start and ep > 100
and t % self.save_freq == 0):
if logger.update_best_score():
logger.save_state()
self.save_mdl()
self.save_exploration()
self.replay_buffer.save()
def load(self):
self.load_mdl()
self.load_exploration()
self.replay_buffer.load()
def show_hyperparams(self):
print('Discount Factor (gamma): {}'.format(self.gamma))
print('Batch Size: {}'.format(self.batch_size))
print('Replay Buffer Size: {}'.format(self.buffer_size))
print('Training Frequency: {}'.format(self.train_freq))
print('Target network update Frequency: {}'.format(
self.target_network_update_freq))
print('Replay start size: {}'.format(self.learn_start))
import numpy as np
from game import Game
from NN import NeuralNet
import json
numLayers = int(input("# Layers:"))
nodesPerLayer = int(input("# Nodes:"))
forceValidMoves = (input("Force Valid Moves? ") == "Y");
filename = "NetProgress_"+str(numLayers)+"x"+str(nodesPerLayer)+"_"+str(forceValidMoves)+".json"
population = []
with open(filename) as f:
x = json.load(f)
for y in x:
population.append(NeuralNet(17, 4, numLayers, nodesPerLayer, y))
testing = population[0]
numMoves = 0
game = Game()
while True:
#Pick the move with the highest rating (+1 is the bias)
moveChoices = testing.run(game.getLogState()+[1])
s = sorted(zip(moveChoices, [0,1,2,3]), reverse=True)
moveChoices = [x[1] for x in s]
print(game)
input("")
print("")
def plot_regularization():
"""
Ploting different models as a function of regularization strength
"""
#######################################################
###############Defining parameters#####################
#######################################################
lambs = np.logspace(-4, 0, 5)
# n_samples =[100, 1000, 4000, 10000]
n_samples = [3000]
# nodes = [10]
nodes=[50]
#######################################################
###############Fetching Data###########################
#######################################################
X, Y, X_critical, Y_critical = fetch_data()
X, Y = shuffle(X, Y)
X_critical, Y_critical = shuffle(X_critical, Y_critical)
for node in nodes:
for sample in n_samples:
X_train = X[:sample]; Y_train = Y[:sample]
X_test = X[sample:2*sample]; Y_test = Y[sample:2*sample]
X_crit = X_critical[:sample]; Y_crit = Y_critical[:sample]
#######################################################
###########Dictionaries for ploting####################
#######################################################
errors = {'ols': {'Train': [], 'Test': [], 'Crit': []},
'l1': {'Train': [], 'Test': [], 'Crit': []},
'l2': {'Train': [], 'Test': [], 'Crit': []}}
accuracies = {'ols': {'Train': [], 'Test': [], 'Crit': []},
'l1': {'Train': [], 'Test': [], 'Crit': []},
'l2': {'Train': [], 'Test': [], 'Crit': []}}
for lamb in lambs:
#######################################################
###########Initializing networks#######################
#######################################################
nn = NeuralNet( X_train, Y_train, nodes = [X.shape[1], node, 2],
activations = ['sigmoid', None], cost_func='log')
nn_l1 = NeuralNet( X_train, Y_train, nodes = [X.shape[1], node, 2],
activations = ['sigmoid', None], cost_func='log', regularization='l1', lamb=lamb)
nn_l2 = NeuralNet( X_train, Y_train, nodes = [X.shape[1], node, 2],
activations = ['sigmoid', None], cost_func='log', regularization='l2', lamb=lamb)
#######################################################
###########Spliting data#######################
#######################################################
nn.split_data(frac=0.5, shuffle=True)
nn_l1.split_data(frac=0.5, shuffle=True)
nn_l2.split_data(frac=0.5, shuffle=True)
#######################################################
###########Training network#######################
#######################################################
nn.TrainNN(epochs = 250, eta0 = 0.05, n_print=250)
nn_l1.TrainNN(epochs = 250, eta0 = 0.05, n_print=250)
nn_l2.TrainNN(epochs = 250, eta0 = 0.05, n_print=250)
#######################################################
###########Error and accuracies ols#######################
#######################################################
ypred_train = nn.feed_forward(X_train, isTraining=False)
ypred_test = nn.feed_forward(X_test, isTraining=False)
ypred_crit = nn.feed_forward(X_crit, isTraining=False)
errors['ols']['Train'].append(nn.cost_function(Y_train, ypred_train))
errors['ols']['Test'].append(nn.cost_function(Y_test, ypred_test))
errors['ols']['Crit'].append(nn.cost_function(Y_crit, ypred_crit))
accuracies['ols']['Train'].append(nn.accuracy(Y_train, ypred_train))
accuracies['ols']['Test'].append(nn.accuracy(Y_test, ypred_test))
accuracies['ols']['Crit'].append(nn.accuracy(Y_crit, ypred_crit))
#######################################################
###########Error and accuracies l1#######################
#######################################################
ypred_train = nn_l1.feed_forward(X_train, isTraining=False)
ypred_test = nn_l1.feed_forward(X_test, isTraining=False)
ypred_crit = nn_l1.feed_forward(X_crit, isTraining=False)
errors['l1']['Train'].append(nn_l1.cost_function(Y_train, ypred_train))
errors['l1']['Test'].append(nn_l1.cost_function(Y_test, ypred_test))
errors['l1']['Crit'].append(nn_l1.cost_function(Y_crit, ypred_crit))
accuracies['l1']['Train'].append(nn_l1.accuracy(Y_train, ypred_train))
accuracies['l1']['Test'].append(nn_l1.accuracy(Y_test, ypred_test))
accuracies['l1']['Crit'].append(nn_l1.accuracy(Y_crit, ypred_crit))
#######################################################
###########Error and accuracies l2#######################
#######################################################
ypred_train = nn_l2.feed_forward(X_train, isTraining=False)
ypred_test = nn_l2.feed_forward(X_test, isTraining=False)
ypred_crit = nn_l2.feed_forward(X_crit, isTraining=False)
errors['l2']['Train'].append(nn_l2.cost_function(Y_train, ypred_train))
errors['l2']['Test'].append(nn_l2.cost_function(Y_test, ypred_test))
errors['l2']['Crit'].append(nn_l2.cost_function(Y_crit, ypred_crit))
accuracies['l2']['Train'].append(nn_l2.accuracy(Y_train, ypred_train))
accuracies['l2']['Test'].append(nn_l2.accuracy(Y_test, ypred_test))
accuracies['l2']['Crit'].append(nn_l2.accuracy(Y_crit, ypred_crit))
datasetnames = ['Train', 'Test']
errfig, errax = plt.subplots()
accfig, accax = plt.subplots()
colors = ['#1f77b4', '#ff7f0e', '#2ca02c']
linestyles = ['-', '--']
for i, key in enumerate(accuracies):
for j, name in enumerate(datasetnames):
errax.set_xlabel(r'$\lambda$')
errax.set_ylabel('Error')
errax.semilogx(lambs[:-2], errors[str(key)][str(name)][:-2],
color=colors[i], linestyle=linestyles[j], label=str(key).capitalize()+'_'+str(name))
errax.legend()
accax.set_xlabel(r'$\lambda$')
accax.set_ylabel('Accuracy')
accax.semilogx(lambs, accuracies[str(key)][str(name)],
color=colors[i], linestyle=linestyles[j], label=str(key).capitalize()+'_'+str(name))
accax.legend()
critfig, critax = plt.subplots()
critax.set_xlabel(r'$\lambda$')
critax.set_ylabel('Accuracy')
for i, key in enumerate(accuracies):
critax.semilogx(lambs, accuracies[str(key)]['Crit'],
label=str(key).capitalize()+'_Crit')
critax.legend()
plt.show()
y_test = y[train_len + val_len:]
print("x_train len : [ " + str(len(x_train)) + " ]")
print("x_val len : [ " + str(len(x_val)) + " ]")
print("x_test len : [ " + str(len(x_test)) + " ]")
train_size = x_train.shape[0]
batch_size = 20
iters_num = 10000
learning_rate = 0.01
train_loss_list = []
val_loss_list = []
iter_per_epoch = max(train_size / batch_size, 1)
network = NeuralNet(input_size=4, hidden_size=5, output_size=3)
print("Training...")
for _ in range(iters_num):
grad = network.propagation(x_train, y_train)
for key in ('W1', 'b1', 'W2', 'b2'):
network.params[key] -= learning_rate * grad[key]
if _ % 1000 == 0:
train_cost = network.loss(x_train, y_train)
val_cost = network.loss(x_val, y_val)
train_loss_list.append(train_cost)
val_loss_list.append(val_cost)
if _ % 1000 == 0:
train_cost2 = network.loss(x_train, y_train)
def plot_convergence():
"""
Ploting the convergence rate of the 6 best models
calculated in best_architectures.
"""
########################################################
################Fetching Data###########################
########################################################
sample = 10000
X, Y, X_critical, Y_critical = fetch_data()
X, Y = shuffle(X, Y)
X_critical, Y_critical = shuffle(X_critical, Y_critical)
X_train = X[:sample]; Y_train = Y[:sample]
X_test = X[sample:2*sample]; Y_test = Y[sample:2*sample]
X_crit = X_critical[:sample]; Y_crit = Y_critical[:sample]
#######################################################
###############Defining parameters#####################
#######################################################
best_architectures = [['tanh', None], ['tanh', None], ['tanh', None],
['tanh','tanh', None], ['tanh', 'tanh', 'tanh', None],
['sigmoid', 'sigmoid', None]]
nodes = [[X.shape[1], 100, 2], [X.shape[1], 50, 2], [X.shape[1], 10, 2],
[X.shape[1], 100, 100, 2], [X.shape[1], 100, 100, 100, 2],
[X.shape[1], 100, 100, 2]]
regularizations = ['l2', 'l2', 'l2', 'l2', 'l1', None]
lambdas = [0.1, 0.1, 0.1, 0.1, 0.001, 0.01]
df = pd.DataFrame()
convergence_dict = {}
walltime_list = []
i = 0
for activation, lamb, node, reg in zip(best_architectures, lambdas, nodes, regularizations):
nn = NeuralNet(
X_train,
Y_train,
nodes = node,
activations = activation,
cost_func='log',
regularization=reg,
lamb=lamb)
start = time()
nn.TrainNN(epochs = 100, n_print=1)
stop = time()
convergence = nn.convergence_rate
walltime = (stop - start)
convergence_dict[activation[0]*(len(activation)-1)+str(node[1])] = convergence['Test Accuracy']
walltime_list.append(walltime)
i += 1
fig, ax = plt.subplots()
for key in convergence_dict:
ax.plot(np.arange(101), convergence_dict[key], label=key)
ax.set_xlabel('Epochs')
ax.set_ylabel('Accuracy')
plt.legend()
# plt.savefig('../plots/convergence_rate.png')
figb, bx = plt.subplots()
names = list(convergence_dict.keys())
bx.bar(np.arange(len(walltime_list)), walltime_list, tick_label=names)
bx.set_ylabel('Walltime [s]')
plt.xticks(rotation=-20)
plt.savefig('../plots/walltime.png')
plt.tight_layout()
plt.show()
if result != -1:
break
if z + 1 == len(moveChoices):
return -10 + numMoves + (3 *
np.log2(np.amax(game.board)))
else:
if (printBoard):
print("Fail End")
print(game)
return -10 + numMoves + (3 * np.log2(np.amax(game.board)))
if result == 0:
if (printBoard):
print("Normal End")
print(game)
return numMoves + (3 * np.log2(np.amax(game.board)))
numMoves += 1
#Tries to import the progress of existing neural net
filename = "NetProgress_" + str(numLayers) + "x" + str(
nodesPerLayer) + "_" + str(forceValidMoves) + ".json"
fitnesses = []
with open(filename) as f:
x = json.load(f)
for weights in x:
net = NeuralNet(17, 4, numLayers, nodesPerLayer, weights)
fitnesses.append(fitnessFunction(net))
plt.plot(sorted(fitnesses))
plt.show()
output_size=output_size,
input_size=[batch_size, input_channels, 200])
conv_blocks = [block1, block2, block3]
model = ConvNeuralNet2Dense3Tanks(
input_channels=input_channels,
units=units_CNN,
output_size=output_size,
conv_blocks=conv_blocks,
input_size=[batch_size, input_channels, 200],
exo_size=[],
exo=False)
else:
model = NeuralNet(input_size=inputs.shape[2],
units=units_NN,
output_size=output_size)
model = model.cuda()
if (three_convs):
optimizer = torch.optim.SGD(
filter(lambda p: p.requires_grad, model.parameters()),
lr=0.01, #eps=1e-08,
momentum=0.9000,
weight_decay=0.0000)
else:
optimizer = torch.optim.SGD(
model.parameters(),
lr=0.01, #eps=1e-08,
momentum=0.9000,
weight_decay=0.0000)