def __init__(self, layers, batch, explore, explore_l, explore_d, learning, decay, path): # layers: architecture of Q network # batch: number of observations in mini-batch set # explore: exploration rate # decay: future reward decay rate # path: model path self.layers = layers self.batch_size = batch self.decay_rate = decay self.learning_rate = learning self.explore_low = explore_l self.explore_decay = explore_d self.explore_rate = explore self.directory = path self.num_action = self.layers[len(self.layers) - 1].num_output ##### build Q network self.Q = NeuralNet(self.layers, self.learning_rate, 'mean_square', 'RMSprop') self.Q.initialize() ##### data-related variables self.feat = [] self.gt = [] self.memory = Memo() self.selection = []
class Model(Observable, Observer): def __init__(self, structure): Observable.__init__(self) self.neural_net = NeuralNet(structure, random_init_bound=0.05) self.commands = [] def load(self, path): self.neural_net.load(path) def predict(self, x): return self.neural_net.evaluate(x) def update(self, command): self.notify_observers() def add_command(self, command): self.commands.append(command) command.add_observer(self) self.notify_observers() def undo(self): if self.commands: self.commands.pop() self.notify_observers() def clear(self): self.commands.clear() self.notify_observers()
def __init__(self, crop: bool = False): self.to_crop = crop try: self.net = NeuralNet() except Exception as e: print(f"Failed while NN initialization. Error: {e}") raise e print("Aim assistant successfully initialized")
def train(net: NeuralNet, inputs: Tensor, targets: Tensor, num_epochs: int = 5000, iterator: DataIterator = BatchIterator(), loss: Loss = MSE(), optimizer: Optimizer = SGD() ) -> None: for epoch in range(num_epochs): epoch_loss = 0.0 for batch in iterator(inputs, targets): predicted = net.forward(batch.inputs) epoch_loss += loss.loss(predicted, batch.targets) grad = loss.grad(predicted, batch.targets) net.backward(grad) optimizer.step(net) print(epoch, epoch_loss)
def main(weight_file=None): if weight_file: with open(weight_file, "r") as f: weights = json.load(f) mlp = NeuralNet(weights["mlp"]) lr = NeuralNet(weights["lr"]) else: mlp = NeuralNet.create(10, 10, 1) lr = NeuralNet.create(10, 1) train(mlp) train(lr) with open("weights.json", "w") as f: json.dump({ "mlp": mlp.weights, "lr": lr.weights, }, f) tournament(NeuralNetAgent("MLP", mlp), NeuralNetAgent("LR", lr))
def __init__(self, file, template, method='chauvenet', nn_params=None, verbose=False, **kwargs): self.file = file if "cal" in self.file: raise ValueError(f"File {self.file} is not in PSR format.") elif "59071" in self.file: raise ValueError(f"Not doing 59071...") self.method = method self.verbose = verbose self.ar = Archive(file, verbose=False) if method != 'NN': _, self.template = u.get_data_from_asc(template) self.opw = u.get_1D_OPW_mask(self.template, windowsize=128) self.omit, self.rms_mu, self.rms_sigma = self.get_omission_matrix( **kwargs) unique, counts = np.unique(self.omit, return_counts=True) print(f"Good channels: {100*(counts[0]/sum(counts)):.3f}%") print(f"Bad channels: {100*(counts[1]/sum(counts)):.3f}%") elif nn_params != None: df = pd.DataFrame( np.reshape(self.ar.getData(), (self.ar.getNsubint() * self.ar.getNchan(), self.ar.getNbin()))) scaler = MinMaxScaler() scaled_df = scaler.fit_transform(df.iloc[:, :]) scaled_df = pd.DataFrame(scaled_df) self.x = scaled_df.iloc[:, :].values.transpose() self.nn = NeuralNet(self.x, np.array([[0], [0]])) self.nn.dims = [self.ar.getNbin(), 512, 10, 13, 8, 6, 6, 4, 4, 1] self.nn.threshold = 0.5 self.nn.load_params(root=nn_params) self.omit = self.nn_get_omission() np.set_printoptions(threshold=sys.maxsize) unique, counts = np.unique(self.omit, return_counts=True) print(f"Good channels: {100*(counts[0]/sum(counts)):.3f}%") print(f"Bad channels: {100*(counts[1]/sum(counts)):.3f}%") else: sys.exit()
def __init__(self, nactions, input_size, max_experiences=500, gamma=0.6, alpha=0.1, use_sarsa=False): #Default uses 2 hidden layers of equal size lay = [input_size, int((nactions+input_size)/2.0), int((nactions+input_size)/2.0), nactions] self.nactions = nactions self.NN = NeuralNet(layers=lay, epsilon=0.154, learningRate=alpha) self.experiences = [] self.max_experiences = max_experiences self.gamma = gamma self.use_sarsa = use_sarsa self.prob_remember = 0.1 self.num_replay_samples = 10
def load_model(): ''' Loads a pre-trained model and settings used to generate it. ''' try: with open(f'{PATH_TO_MODEL}.json', 'r') as json_file: settings = json.load(json_file) model = NeuralNet(len(settings['all_labels'])) model.load_state_dict( torch.load(f'{PATH_TO_MODEL}.pth', map_location=torch.device('cpu'))) except: print('Could not locate a trained model.') sys.exit() model.eval() return model, settings
with open("cost_iris.pkl", "rb") as c: cost = pickle.load(c) with open("acc_iris.pkl", "rb") as c: accuracy = pickle.load(c) # Plot training cost and accuracy vs epochs plt.figure(1) plt.plot(list(range(0, 1000, 10)), cost) plt.ylabel("Training Error/Cost"), plt.xlabel("Epochs") plt.figure(2) plt.plot(list(range(0, 1000, 10)), accuracy) plt.ylabel("Training Accuracy"), plt.xlabel("Epochs") plt.show() op_nodes = 3 iris = load_iris() X = iris.data y = np.array([np.eye(op_nodes)[i] for i in iris.target]) # Shuffle random = np.random.permutation(len(X)) X = X[random] y = y[random] # Load the model nnet = NeuralNet(load=True, model_file="trained.pkl") op = nnet.predict(X, return_max=True) print("-" * 30 + "\nTEST SET ACCURACY\n" + "-" * 30) print(classification_report(y.argmax(axis=1), op))
data_x, data_y = None, None if (args.dataset == "train"): data_x, data_y = train_x, train_y elif (args.dataset == "test"): data_x, data_y = test_x, test_y elif (args.dataset == "valid"): data_x, data_y = valid_x, valid_y test_dataset = Dataset(root_dir, data_x, data_y, transforms=transform) test_generator = torch.utils.data.DataLoader(test_dataset, **params) print("Loaded dataloaders...") criterion = torch.nn.CrossEntropyLoss() model = NeuralNet(0.001, criterion, 64, 2) state_dict = torch.load(model_name) model.load_state_dict(state_dict) for parameter in model.parameters(): parameter.requires_grad = False if (use_cuda): model.cuda() model.eval() summary(model, (1, 64, 64)) print("Loaded model...") preds = [] labels = [] for local_batch, local_labels in tqdm(test_generator):
# dataset = datasets.load_digits() X = digitsX[:] y = digitsY[:] n,d = X.shape nTrain = 0.2*n #training on 50% of the data # shuffle the data # idx = np.arange(n) # np.random.seed(13) # np.random.shuffle(idx) # X = X[idx] # y = y[idx] # split the data Xtrain = X[:nTrain,:] ytrain = y[:nTrain] # Xtest = X[nTrain:,:] # ytest = y[nTrain:] model = NeuralNet(np.array([25]), .80, 0.12, 600) # 100 @ 2.5 = 0.885, 400 @ 1.6 = 0.88, 1000 @ 1 = 0.8542, model.fit(X,y) ypred = model.predict(Xtrain) accuracy = accuracy_score(ytrain, ypred) print "NeuralNet Accuracy = "+str(accuracy) # model.visualizeHiddenNodes('hiddenLayers.png')
""" Sample of function that can't be learnt with simple linear model """ import numpy as np from train import train from nn import NeuralNet from layers import Linear, Tanh inputs = np.array([[0, 0], [1, 0], [0, 1], [1, 1]]) targets = np.array([[1, 0], [0, 1], [0, 1], [1, 0]]) net = NeuralNet([ Linear(input_size=2, output_size=2), # not able to learn xor function just with linear layer Tanh(), Linear(input_size=2, output_size=2) ]) train(net, inputs, targets) for x, y in zip(inputs, targets): predicted = net.forward(x) print(x, predicted, y)
from numpy import loadtxt, ones, zeros, where import numpy as np from sklearn import datasets from sklearn.tree import DecisionTreeClassifier from sklearn.metrics import accuracy_score import sys, traceback from sklearn.neighbors import KNeighborsClassifier from sklearn.svm import SVC from nn import NeuralNet # load the data set filename = 'data/digitsX.dat' data = loadtxt(filename, delimiter=',') X = data[:,:] filename = 'data/digitsY.dat' data1 = loadtxt(filename, delimiter=',') y = data1 layers = np.array([25]) clf = NeuralNet(layers = layers, learningRate = 2.0, numEpochs = 10) clf.fit(X,y) predicted = clf.predict(X) # print predicted print np.mean(predicted == y)
import numpy as np from sklearn import datasets from sklearn.metrics import accuracy_score from nn import NeuralNet filename_X = 'data/digitsX.dat' filename_y = 'data/digitsY.dat' X = np.loadtxt(filename_X, delimiter=',') y = np.loadtxt(filename_y, delimiter=',') # takes roughly 1s for each epoch clf_NN = NeuralNet(layers=np.array([25]), learningRate=2.0, numEpochs=450) clf_NN.fit(X, y) y_predict = clf_NN.predict(X) accuracy_NN = accuracy_score(y_predict, y) print "Accuracy: \t" + str(accuracy_NN)
from nn import NeuralNet from node import Node nn=NeuralNet() print "Enter trained Neural Net filename" infile=raw_input() print "Enter test filename" testfile = raw_input() print "Enter output filename" results = raw_input() nn.importFile(infile) nn.test(testfile,results);
def step(self, net: NeuralNet) -> None: for param, grad in net.params_and_grads(): param -= self.lr * grad #adjust params by declining learning rate * gradient
class Zap(): """ Master class for zapping data. Requires: file - .FITS (must be PSRFITS v5+ format) Optional: template - ASCII format: BIN# Flux (Required if not doing NN exicison) method - Either 'chauvenet', 'DMAD' or 'NN' verbose - Prints more information to the console **kwargs - Get parsed to plot.histogram_and_curves() or """ def __init__(self, file, template, method='chauvenet', nn_params=None, verbose=False, **kwargs): self.file = file if "cal" in self.file: raise ValueError(f"File {self.file} is not in PSR format.") elif "59071" in self.file: raise ValueError(f"Not doing 59071...") self.method = method self.verbose = verbose self.ar = Archive(file, verbose=False) if method != 'NN': _, self.template = u.get_data_from_asc(template) self.opw = u.get_1D_OPW_mask(self.template, windowsize=128) self.omit, self.rms_mu, self.rms_sigma = self.get_omission_matrix( **kwargs) unique, counts = np.unique(self.omit, return_counts=True) print(f"Good channels: {100*(counts[0]/sum(counts)):.3f}%") print(f"Bad channels: {100*(counts[1]/sum(counts)):.3f}%") elif nn_params != None: df = pd.DataFrame( np.reshape(self.ar.getData(), (self.ar.getNsubint() * self.ar.getNchan(), self.ar.getNbin()))) scaler = MinMaxScaler() scaled_df = scaler.fit_transform(df.iloc[:, :]) scaled_df = pd.DataFrame(scaled_df) self.x = scaled_df.iloc[:, :].values.transpose() self.nn = NeuralNet(self.x, np.array([[0], [0]])) self.nn.dims = [self.ar.getNbin(), 512, 10, 13, 8, 6, 6, 4, 4, 1] self.nn.threshold = 0.5 self.nn.load_params(root=nn_params) self.omit = self.nn_get_omission() np.set_printoptions(threshold=sys.maxsize) unique, counts = np.unique(self.omit, return_counts=True) print(f"Good channels: {100*(counts[0]/sum(counts)):.3f}%") print(f"Bad channels: {100*(counts[1]/sum(counts)):.3f}%") else: sys.exit() def nn_get_omission(self): pred = np.around(np.squeeze(self.nn.pred_data(self.x, False)), decimals=0).astype(np.int) pred = np.reshape(pred, (self.ar.getNsubint(), self.ar.getNchan())) return pred def get_omission_matrix(self, **kwargs): rms, lin_rms, mu, sigma = u.rms_arr_properties( self.ar.getData(), self.opw, 1.0) # Needs to input 2D array # Creates the histogram plot.histogram_and_curves( lin_rms, mean=mu, std_dev=sigma, bins=(self.ar.getNchan() * self.ar.getNsubint()) // 4, x_axis='Root Mean Squared', y_axis='Frequency Density', title=r'$M={},\ \sigma={}$'.format(mu, sigma), **kwargs) if self.method == 'chauvenet': rej_arr = physics.chauvenet(rms, median=mu, std_dev=sigma, threshold=2.0) elif self.method == 'DMAD': rej_arr = physics.DMAD(lin_rms, threshold=3.5) rej_arr = np.reshape(rej_arr, (self.ar.getNsubint(), self.ar.getNchan())) if self.verbose: print("Rejection criterion created.") return rej_arr, mu, sigma def plot_mask(self, **kwargs): fig = plt.figure(figsize=(7, 7)) ax = fig.add_subplot(111) ax.imshow(self.omit.T, cmap=plt.cm.gray, interpolation='nearest', aspect='auto') plt.show() def save_training_set(self, val_size=0.2): # From Chauvenet or DMAD. 1 is bad channel with open( f'{self.ar.getName()}_{int(self.ar.getMJD())}_{self.ar.getFrontend()}_{self.ar.getNbin()}.training', 'w') as t: t.write( f'# Training set for {self.ar.getName()} taken on {int(self.ar.getMJD())} at {self.ar.getFrontend()}\n' ) with open( f'{self.ar.getName()}_{int(self.ar.getMJD())}_{self.ar.getFrontend()}_{self.ar.getNbin()}.validation', 'w') as t: t.write( f'# Validation set for {self.ar.getName()} taken on {int(self.ar.getMJD())} at {self.ar.getFrontend()}\n' ) ps_0 = np.zeros(2049)[np.newaxis, :] ps_1 = np.zeros(2049)[np.newaxis, :] d = self.ar.getData().reshape( (self.ar.getNchan() * self.ar.getNsubint(), self.ar.getNbin())) omission = self.omit.reshape( (self.ar.getNchan() * self.ar.getNsubint())) i = 1 for omit, profile in zip(omission, d): try: choice = int(omit) if choice == 1: choice = 0 elif choice == 0: choice = 1 except ValueError: choice = -1 print(i, end='\r') if choice != -1: # Creates the profile / choice pairs and doubles up with the reciprocal profiles. p = np.append(profile, choice) #inv_p = np.append( -1*profile, choice ) if choice == 0: ps_0 = np.append(ps_0, p[np.newaxis, :], axis=0) else: ps_1 = np.append(ps_1, p[np.newaxis, :], axis=0) i += 1 ps_0, ps_1 = np.delete(ps_0, 0, 0), np.delete(ps_1, 0, 0) # Sort into training / validation sets train, validation = train_test_split(ps_0, test_size=val_size) ones_t, ones_v = train_test_split(ps_1, test_size=val_size) train, validation = np.append(train, ones_t, axis=0), np.append(validation, ones_v, axis=0) np.random.shuffle(train), np.random.shuffle(validation) for k in train: with open( f'{self.ar.getName()}_{int(self.ar.getMJD())}_{self.ar.getFrontend()}_{self.ar.getNbin()}.training', 'a') as t: np.savetxt(t, k, fmt='%1.5f ', newline='') t.write("\n") #np.savetxt( t, inv_p, fmt = '%1.5f ', newline = '' ) #t.write( "\n" ) for k in validation: with open( f'{self.ar.getName()}_{int(self.ar.getMJD())}_{self.ar.getFrontend()}_{self.ar.getNbin()}.validation', 'a') as t: np.savetxt(t, k, fmt='%1.5f ', newline='') t.write("\n") # Save as ASCII text file def save(self, outroot="zap_out", ext='.ascii'): outfile = outroot + ext with open(outfile, 'w+') as f: for i, t in enumerate(self.omit): for j, rej in enumerate(t): if rej == True: f.write(str(i) + " " + str(self.ar.freq[i][j]) + "\n") #f.write( f'{k} {self.ar.freq[k][i]}\n' ) return outfile
train_interface.train(cfg.TRAINING.EPOCHS) def test(network): test_loader = get_dataloader(cfg.DATASET.NAME, cfg.DATASET.PATH, 0, None, smoothing=cfg.DATASET.TARGET_SMOOTHING, normalize=cfg.DATASET.NORMALIZE, test=True) interface = Trainer(network, None, None, test_loader) interface.validate() accuracy = interface.val_accuracy[-1] logger.info(f'TEST Accuracy: {accuracy:.4f}') def get_args(): parser = argparse.ArgumentParser(description='Train a neural network') parser.add_argument('--cfg', type=str, help='Config containing network, dataset, and training information') return parser.parse_args() if __name__ == '__main__': args = get_args() cfg.merge_from_file(args.cfg) net_cfg = cfg.NETWORK nn = NeuralNet(net_cfg.INPUTS, net_cfg.HIDDEN_LAYERS, net_cfg.OUTPUTS) train(nn) test(nn)
# neural nets doesnt really make sense import math import numpy as np import sys from import_train import import_training_file from import_train import rmsle from sklearn.neural_network import BernoulliRBM from nn import NeuralNet if __name__ == '__main__': (X, y) = import_training_file(sys.argv[1], True) hidden_layers = [5] learningRate = 1.6 epsil = 0.12 eps = 1000 neural_network = NeuralNet(hidden_layers, learningRate, epsilon=epsil, numEpochs=eps) neural_network.fit(X, y) nn_predict = neural_network.predict(X)
# names of test videos test_name = ['MP7'] test_num = 1 # define neural network layout l1 = Layer(4096, 400, 'relu') l2 = Layer(400, 200, 'relu') l3 = Layer(200, 100, 'relu') l4 = Layer(100, 25, 'linear') layers = [l1, l2, l3, l4] learning_rate = 0.0002 loss_type = 'mean_square' opt_type = 'RMSprop' Q = NeuralNet(layers, learning_rate, loss_type, opt_type) Q.recover('model/', 'Q_net_all_11_0_1000') for i in range(test_num): video = Episode(i, test_num, test_name, feat_path, gt_path) frame_num = np.shape(video.feat)[0] summary = np.zeros(frame_num) Q_value = [] id_curr = 0 while id_curr < frame_num: action_value = Q.forward([video.feat[id_curr]]) a_index = np.argmax(action_value[0]) id_next = id_curr + a_index + 1 if id_next > frame_num - 1:
''' AUTHOR Wenqi Xian ''' from numpy import loadtxt import numpy as np from nn import NeuralNet X_train = loadtxt('data/digitsX.dat', delimiter=',') y_train = loadtxt('data/digitsY.dat', delimiter=',') layers = np.array([25]) NN = NeuralNet(layers = layers, learningRate = 1.8, numEpochs = 700) NN.fit(X_train,y_train) predicted = NN.predict(X_train) accuracy = 100.0 * (predicted == y_train).sum() / y_train.shape[0] print accuracy
class QNN(): """ Neural Q-Network. Includes experience replay. nactions: the number of actions input_size: the number of inputs max_experiences: the total number of experiences to save for replay gamma: future rewards discount rate alpha: learning rate for underlying NN use_sarsa: flag whether to use the SARSA update rule """ def __call__(self,s,a=None): """ implement here the returned Qvalue of state (s) and action(a) e.g. Q.GetValue(s,a) is equivalent to Q(s,a) """ if a==None: return self.GetValue(s) return self.GetValue(s,a) def __init__(self, nactions, input_size, max_experiences=500, gamma=0.6, alpha=0.1, use_sarsa=False): #Default uses 2 hidden layers of equal size lay = [input_size, int((nactions+input_size)/2.0), int((nactions+input_size)/2.0), nactions] self.nactions = nactions self.NN = NeuralNet(layers=lay, epsilon=0.154, learningRate=alpha) self.experiences = [] self.max_experiences = max_experiences self.gamma = gamma self.use_sarsa = use_sarsa self.prob_remember = 0.1 self.num_replay_samples = 10 def GetValue(self, s, a=None): """ Return the Q(s,a) value of state (s) for action (a) or all values for Q(s) """ out = self.NN.propagate(s) if (a==None): return out return out[a] def Update(self, s1, a1, r, s2, a2): """ update action value for action(a) """ if (self.use_sarsa): v = r + self.gamma*self.GetValue(s2, a2) else: v = r + self.gamma*max(self.GetValue(s2)) a = np.zeros(self.nactions) a[a1] = v self.NN.propagateAndUpdate(s1, a) def RememberExperience(self, s1, a1, r, s2, a2): if (random.random() < self.prob_remember): if (len(self.experiences) >= self.max_experiences): #TODO: Something more intelligent about how we determine what is worth forgetting self.experiences.pop(random.randint(0, self.max_experiences-1)) self.experiences.append(Experience(s1, a1, r, s2, a2)) def ExperienceReplay(self): #Skip until we have enough experience if (len(self.experiences) < self.num_replay_samples): return for i in xrange(self.num_replay_samples): index = random.randint(0, len(self.experiences)-1) exp = self.experiences[index] self.Update(exp.s1, exp.a1, exp.r, exp.s2, exp.a2)
class Agent(object): def __init__(self, layers, batch, explore, explore_l, explore_d, learning, decay, path): # layers: architecture of Q network # batch: number of observations in mini-batch set # explore: exploration rate # decay: future reward decay rate # path: model path self.layers = layers self.batch_size = batch self.decay_rate = decay self.learning_rate = learning self.explore_low = explore_l self.explore_decay = explore_d self.explore_rate = explore self.directory = path self.num_action = self.layers[len(self.layers) - 1].num_output ##### build Q network self.Q = NeuralNet(self.layers, self.learning_rate, 'mean_square', 'RMSprop') self.Q.initialize() ##### data-related variables self.feat = [] self.gt = [] self.memory = Memo() self.selection = [] # initialize with data def data_init(self, current_eps): self.feat = current_eps.feat self.gt = current_eps.gt # select an action based on policy def policy(self, id_curr): exploration = np.random.choice( range(2), 1, p=[1 - self.explore_rate, self.explore_rate]) # exploration==1: explore # exploration==0: exploit if exploration == 1: # exploration action_index = np.random.choice(range(self.num_action), 1)[0] #print('\r') #print(' explore: '+str(action_index)) #print('\r') action_value = self.Q.forward([self.feat[id_curr]]) # record average Q value self.Q.ave_value.append(np.mean(action_value[0])) # print(action_value[0]) return action_index else: # exploitation action_value = self.Q.forward([self.feat[id_curr]]) # record average Q value self.Q.ave_value.append(np.mean(action_value[0])) # self.Q.ave_value = np.append(self.Q.ave_value,np.mean(action_value[0])) action_index = np.argmax(action_value[0]) #print('\r') ##print('exploit: '+str(action_index)) #print('\r') # print(action_value[0]) return action_index # perform action to get next state def action(self, id_curr, a_index): id_next = id_curr + a_index + 1 #action 0,1,2,... return id_next # compute the reward # REWARD 3:reward with distribution and terms on length of skipping def reward(self, id_curr, a_index, id_next): gaussian_value = [ 0.0001, 0.0044, 0.0540, 0.2420, 0.3989, 0.2420, 0.0540, 0.0044, 0.0001 ] # skipping interval,missing part seg_gt = self.gt[0][id_curr + 1:id_next] total = len(seg_gt) n1 = sum(seg_gt) n0 = total - n1 miss = (0.8 * n0 - n1) / 25 #largest action step. # accuracy acc = 0 if id_next - 4 > -1: if self.gt[0][id_next - 4] == 1: acc = acc + 0.0001 if id_next - 3 > -1: if self.gt[0][id_next - 3] == 1: acc = acc + 0.0044 if id_next - 2 > -1: if self.gt[0][id_next - 2] == 1: acc = acc + 0.0540 if id_next - 1 > -1: if self.gt[0][id_next - 1] == 1: acc = acc + 0.2420 if self.gt[0][id_next] == 1: acc = acc + 0.3989 if id_next + 1 < len(self.gt[0]): if self.gt[0][id_next + 1] == 1: acc = acc + 0.2420 if id_next + 2 < len(self.gt[0]): if self.gt[0][id_next + 2] == 1: acc = acc + 0.0540 if id_next + 3 < len(self.gt[0]): if self.gt[0][id_next + 3] == 1: acc = acc + 0.0044 if id_next + 4 < len(self.gt[0]): if self.gt[0][id_next + 4] == 1: acc = acc + 0.0001 r = miss + acc return r # update target Q value def update(self, r, id_curr, id_next, a_index): target = self.Q.forward([self.feat[id_curr]]) # target:[ [] ] target[0][a_index] = r + self.decay_rate * max( self.Q.forward([self.feat[id_next]])[0]) return target # run an episode to get case set for training def episode_run(self): frame_num = np.shape(self.feat)[0] self.selection = np.zeros(frame_num) id_curr = 0 self.selection[id_curr] = 1 while id_curr < frame_num: a_index = self.policy(id_curr) id_next = self.action(id_curr, a_index) if id_next > frame_num - 1: break self.selection[id_next] = 1 r = self.reward(id_curr, a_index, id_next) target_vector = self.update(r, id_curr, id_next, a_index)[0] input_vector = self.feat[id_curr] self.memorize(input_vector, target_vector) if self.memory.get_size() == self.batch_size: #print('training') self.train() id_curr = id_next # training Q net using one batch data def train(self): self.explore_rate = max(self.explore_rate - self.explore_decay, self.explore_low) x = self.memory.state y = self.memory.target self.Q.train(x, y) self.memory.reset() # store current observation to memory def memorize(self, state, target): # observation: new observation (s,a,r,s') self.memory.add(state, target) # reset data-related variables def data_reset(self): self.feat = [] self.gt = [] self.selection = [] # save trained Q net def save_model(self, filename): # module backup path = self.directory self.Q.saving(path, filename)
''' return [x >> i & 1 for i in range(10)] inputs = np.array([ binary_encode(x) for x in range(101, 1024) ]) targets = np.array([ fizz_buzz_encode(x) for x in range(101, 1024) ]) net = NeuralNet([ Linear(input_size = 10, output_size = 50), Tanh(), Linear(input_size = 50, output_size = 4) ]) train(net, inputs, targets, num_epochs = 5000, optimizer = SGD(lr = 0.001)) for x in range(1, 101): predicted = net.forward(binary_encode(x)) predicted_idx = np.argmax(predicted) actual_idx = np.argmax(fizz_buzz_encode(x)) labels = [str(x), "fizz", "buzz", "fizzbuzz"] print(x, labels[predicted_idx], labels[actual_idx])
import matplotlib.pyplot as plt use_cuda = torch.cuda.is_available() device = torch.device("cuda:0" if use_cuda else "cpu") root_dir = os.path.join("data") classes_to_idx = { v: k for k, v in enumerate( open(os.path.join(root_dir, "classes.txt")).read().strip().split("\n")) } idx_to_classes = {v: k for k, v in classes_to_idx.items()} criterion = nn.BCELoss() model = NeuralNet(0.01, criterion, 256, len(classes_to_idx)) model.load_state_dict(torch.load(sys.argv[1])) if use_cuda: model.cuda() model.eval() id = random.choice(os.listdir(os.path.join(root_dir, "images"))).split(".")[0] data = torch.load(os.path.join(root_dir, "images", id + ".pt")) true_labels = torch.load(os.path.join(root_dir, "labels", id + ".pt")) diseases = [] for x in range(len(true_labels)): if (true_labels[x] == 1.0): diseases.append(idx_to_classes[x]) print(id)
from nn import NeuralNet from node import Node nn = NeuralNet() nn.importFile("sample.NNGrades.init") nn.printFile("sup.txt")
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.4, random_state=27) # Config layer_nodes = [4, 10, 3] # Add more elements for more layers model_name = "iris2" activation = "sigmoid" # (sigmoid, tanh) op_activation = "sigmoid" # (sigmoid, softmax) loss = "crossentropy" # (crossentropy, mse) # Build the architecture nnet = NeuralNet(layer_nodes=layer_nodes, name=model_name, loss=loss, activation=activation, output_activation=op_activation) # Training config epochs = 2000 alpha = 1e-3 reg_para = 0.05 batch_size = 20 epochs_bw_details = 50 dropout_percent = 0.25 # Probability of a node dropping out d_layers = [2] # Only these layers will have dropout # Training cost, accuracy = nnet.train(x_train, y_train,
""" Train a model to predict exclusive or of its inputs """ import numpy as np from nn import NeuralNet from layers import Linear, Tanh from train import train inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) targets = np.array([[1, 0], [0, 1], [0, 1], [1, 0]]) net = NeuralNet([ Linear(input_size=2, output_size=2), Tanh(), Linear(input_size=2, output_size=2) ]) train(net, inputs, targets, num_epochs=5000) for x, y in zip(inputs, targets): print(x, net.forward(x), y)
def __init__(self, structure): Observable.__init__(self) self.neural_net = NeuralNet(structure, random_init_bound=0.05) self.commands = []
return [0, 0, 0, 1] elif x % 5 == 0: return [0, 0, 1, 0] elif x % 3 == 0: return [0, 1, 0, 0] else: return [1, 0, 0, 0] inputs = np.array([binary_encode(x) for x in range(101, 1024)]) targets = np.array([fizz_buzz_encode(x) for x in range(101, 1024)]) net = NeuralNet([ Linear(input_size=10, output_size=50), Tanh(), Linear(input_size=50, output_size=4) ]) train(net, inputs, targets, num_epochs=5000, optimizer=SGD(lr=0.001)) for x in range(1, 101): inputs = binary_encode(x) prediction = net.forward(inputs) actual = fizz_buzz_encode(x) labels = [str(x), "fizz", "buzz", "fizzbuzz"] prediction_idx = np.argmax(prediction) actual_idx = np.argmax(actual) print(x, labels[prediction_idx], labels[actual_idx])
""" The canonical example of a function that can't be learned with a simple linear model is XOR """ import numpy as np from train import train from nn import NeuralNet from layers import Linear, Tanh inputs = np.array([[0, 0], [1, 0], [0, 1], [1, 1]]) targets = np.array([[1, 0], [0, 1], [0, 1], [1, 0]]) net = NeuralNet([ Linear(input_size=2, output_size=2), Tanh(), Linear(input_size=2, output_size=2) ]) train(net, inputs, targets) for x, y in zip(inputs, targets): predicted = net.forward(x) print(x, predicted, y)
from nn import NeuralNet from node import Node nn=NeuralNet() print "Enter Neural Net filename" infile=raw_input() print "Enter training filename" trainfile = raw_input() print "Enter learning rate" lrate = raw_input() print "Enter # of Epochs" ep = raw_input() print "Enter output filename" outfile = raw_input() nn.importFile(infile) nn.train(trainfile,float(lrate), int(ep)); nn.printFile(outfile)
import numpy as np from numpy import loadtxt from sklearn import datasets from sklearn.metrics import accuracy_score from nn import NeuralNet # learning rate parameters to be trained by hand numEpochs = 100 learningRate = 0.3 epsilon = 0.12 regularization_parameter = 0.001 nodes_in_hidden_layers = [25] # load the data filenameX = "data/digitsX.dat" dataX = loadtxt(filenameX, delimiter=",") filenameY = "data/digitsY.dat" dataY = loadtxt(filenameY, delimiter=",") n, d = dataX.shape # create NeuralNet class modelNN = NeuralNet(nodes_in_hidden_layers, epsilon, learningRate, numEpochs) # train neural network on digits data modelNN.fit(dataX, dataY) # find the training accuracy # report the training accuracy
X = digitsX[:] y = digitsY[:] n, d = X.shape nTrain = 0.2 * n #training on 50% of the data # shuffle the data # idx = np.arange(n) # np.random.seed(13) # np.random.shuffle(idx) # X = X[idx] # y = y[idx] # split the data Xtrain = X[:nTrain, :] ytrain = y[:nTrain] # Xtest = X[nTrain:,:] # ytest = y[nTrain:] model = NeuralNet( np.array([25]), .80, 0.12, 600) # 100 @ 2.5 = 0.885, 400 @ 1.6 = 0.88, 1000 @ 1 = 0.8542, model.fit(X, y) ypred = model.predict(Xtrain) accuracy = accuracy_score(ytrain, ypred) print "NeuralNet Accuracy = " + str(accuracy) # model.visualizeHiddenNodes('hiddenLayers.png')
X = X[idx] y = y[idx] # split the data Xtrain = X[:nTrain, :] ytrain = y[:nTrain] Xtest = X[nTrain:, :] ytest = y[nTrain:] # train the decision tree modelDT = DecisionTreeClassifier() modelDT.fit(Xtrain, ytrain) # train the naive Bayes layers = np.array(([25])) modelNN = NeuralNet(layers=layers, learningRate =2, numEpochs=500, epsilon=.62) modelNN.fit(Xtrain, ytrain) ypred_NNtrain = modelNN.predict(Xtrain) # output predictions on the remaining data ypred_NN = modelNN.predict(Xtest) # compute the training accuracy of the model accuracyNT = accuracy_score(ytrain, ypred_NNtrain) accuracyNN = accuracy_score(ytest, ypred_NN) print "Training = "+str(accuracyNT) print "Neural Net accuracy = "+str(accuracyNN) modelNN.visualizeHiddenNodes("visualizeHiddenNodes.bmp")
from nn import NeuralNet from node import Node nn=NeuralNet() nn.importFile("sample.NNGrades.init") nn.printFile("sup.txt")
def step(self, net: NeuralNet) -> None: for param, grad in net.params_and_grads(): param -= self.lr * grad
print("Loaded data...") train_dataset = Dataset(root_dir, train_x, train_y, transforms=transforms["train"]) valid_dataset = Dataset(root_dir, valid_x, valid_y, transforms=transforms["val"]) training_generator = torch.utils.data.DataLoader(train_dataset, **params) validation_generator = torch.utils.data.DataLoader(valid_dataset, **params) print("Created datasets...") criterion = torch.nn.CrossEntropyLoss() model = NeuralNet(0.001, criterion, 64, 2) if (use_cuda): model.cuda() summary(model, (1, 64, 64)) print("Starting training...") writer = SummaryWriter() global_train_step = 0 global_val_step = 0 # Loop over epochs for epoch in range(max_epochs): tqdm.write("Epoch: {}".format(epoch)) progress_bar = tqdm(total=len(train_dataset), leave=True, position=0)