def test_run(self): # Test correctness of run method network = NeuralNetwork(3, 2, 1, 0.5) network.weights_input_to_hidden = test_w_i_h.copy() network.weights_hidden_to_output = test_w_h_o.copy() self.assertTrue(np.allclose(network.run(inputs), 0.09998924))
def __init__(self, host, port, model_path): self.server_socket = socket.socket() self.server_socket.bind((host, port)) self.server_socket.listen(0) # accept a single connection self.connection = self.server_socket.accept()[0].makefile('rb') self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.client_socket.connect(('192.168.0.115', 1234)) #pi # load trained neural network self.nn = NeuralNetwork() self.nn.load_modelKeras("model_test.h5") self.h1 = 5.5 #stop sign - measure manually #self.stop_cascade = cv2.CascadeClassifier(cv2.data.haarcascades +"C:/Users/My\ PC/Anaconda3/envs/tf/Lib/site-packages/cv2/data/stop_sign.xml") #self.stop_cascade = cv2.CascadeClassifier(cv2.data.haarcascades +"D:/Downloads/self-driving-car2/neural networks/stop_sign.xml") self.stop_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + "stop_sign.xml") self.d_stop_light_thresh = 70 self.d_stop_sign = self.d_stop_light_thresh self.stop_start = 0 # start time when stop at the stop sign self.stop_finish = 0 self.stop_time = 0 self.drive_time_after_stop = 0 self.alpha = 8.0 * math.pi / 180 # degree measured manually self.v0 = 119.865631204 # from camera matrix self.ay = 332.262498472 # from camera matrix
def __init__(self, host_str, model_path): # load trained neural network self.nn = NeuralNetwork() self.nn.load_model(model_path) self.car_ctrl = sock_car_control()
def test_case_2(): import time dataset = IRISDataset() X_test, X_train, y_test, y_train = dataset.split_to_train_test(seed=10) model = NeuralNetwork() model.create_graph() hl_1, hl_2, hl_3, prediction = model.predict(X_train) numb_features = 8 feature_list = [str(i) for i in range(1, numb_features + 1)] influencer = QII(hl_1, feature_list) data_point = hl_1[0] with tf.Session(graph=model.graph) as sess: saver = tf.train.Saver() saver.restore(sess, model.CHECK_POINT) start_time = time.time() print('Approximation with Random Sampling') shapley_val = influencer.banzhaf(data_point, model.predict_hl_1, sess, is_exhaustive=False) print(shapley_val) print("--- %s seconds ---" % (time.time() - start_time)) start_time = time.time() print('Correct value with Exhaustive Computation') shapley_val = influencer.banzhaf(data_point, model.predict_hl_1, sess, is_exhaustive=True) print(shapley_val) print("--- %s seconds ---" % (time.time() - start_time))
class CollectTrainingData(object): def __init__(self, client, steer): self.client = client self.steer = steer # 정지선 검출 모델 선언 self.stopline = StopLine.Stop() # YOLO 모델 선언 self.dect = Object.Object_Detection(self.steer) # model create # 주행 모델 선언 self.model = NeuralNetwork() self.model.load_model(path='model_data/video_model_1.h5') def collect(self): print("Start video stream") stream_bytes = b' ' while True: stream_bytes += self.client.recv(1024) first = stream_bytes.find(b'\xff\xd8') last = stream_bytes.find(b'\xff\xd9') if first != -1 and last != -1: try: jpg = stream_bytes[first:last + 2] stream_bytes = stream_bytes[last + 2:] image = cv2.imdecode(np.frombuffer(jpg, dtype=np.uint8), cv2.IMREAD_GRAYSCALE) rgb = cv2.imdecode(np.frombuffer(jpg, dtype=np.uint8), cv2.IMREAD_COLOR) rgb2 = rgb.copy() roi = image[120:240, :] roi2 = rgb2[120:240, :] #for line roi cv2.imshow('Origin', rgb) cv2.imshow('GRAY', image) cv2.imshow('roi', roi) # reshape the roi image into a vector image_array = np.reshape(roi, (-1, 120, 320, 1)) # neural network makes prediction self.steer.Set_Line(self.model.predict(image_array)) self.steer.Set_Stopline(self.stopline.GetStopLine(roi2)) self.dect.Detection(rgb) # steer의 주행함수 실행 self.steer.Control() except: continue if cv2.waitKey(1) & 0xFF == ord('q'): break
def use_QII_with_model(X_train): model = NeuralNetwork() model.create_graph() hl_1, hl_2, hl_3, prediction = model.predict(X_train) numb_features = 4 # hidden layer 3 has 4 units feature_list = [str(i) for i in range(1, numb_features + 1)] influencer = QII(hl_3, feature_list) # value of one data points we want to observe data_point = hl_3[0] with tf.Session(graph=model.graph) as sess: saver = tf.train.Saver() saver.restore(sess, model.CHECK_POINT) print('Correct value with Exhaustive Computation') banzhaf_val = influencer.banzhaf(data_point, model.predict_hl_3, sess, is_exhaustive=True) print(banzhaf_val) influence_scores = np.array([banzhaf_val[i] for i in feature_list]) influence_scores = np.expand_dims(influence_scores, axis=0) weight_name_list = ['w1', 'w2', 'w3'] influence_scores = influencer.mapback(model, X_train, influence_scores, weight_name_list) influencer.plot_influence_score(influence_scores, feature_list)
def use_QII_with_model(X_train): model = NeuralNetwork() model.create_graph() hl_1, hl_2, hl_3, prediction = model.predict(X_train) numb_features = 4 # hidden layer 3 has 4 units feature_list = [str(i) for i in range(1, numb_features + 1)] influencer = QII(hl_3, feature_list) # value of one data points we want to observe data_point = hl_3[0] assignment_list = ['normalized', 'ranking', 'nochange'] propagate_list = [ 'transpose_mul', 'inverse_mul', 'softmax_dist', 'shift_dist', 'shift_softmax_dist' ] with tf.Session(graph=model.graph) as sess: saver = tf.train.Saver() saver.restore(sess, model.CHECK_POINT) for assignment in assignment_list: for propagate in propagate_list: banzhaf_val = influencer.banzhaf(data_point, model.predict_hl_3, sess, is_exhaustive=False) influence_scores = np.array( [banzhaf_val[i] for i in feature_list]) influence_scores = np.expand_dims(influence_scores, axis=0) weight_name_list = ['w1', 'w2', 'w3'] influence_scores = influencer.mapback( model, X_train, influence_scores, weight_name_list, assignment, propagate) influencer.plot_influence_score(influence_scores, feature_list)
def worker(args, STD_NOISE, STATE_DIM, ACTION_DIM, params_queue, output_queue, elite_queue): # Function execute by each worker: get the agent' NN, sample noise and evaluate the agent adding the noise. Then return the seed and the rewards to the central unit env = gym.make(args.env) # env = CyclicMDP() actor = NeuralNetwork(STATE_DIM, ACTION_DIM.shape[0], args.hidden_size) while True: # get the new actor's params act_params = params_queue.get() if act_params != None: # load the actor params actor.load_state_dict(act_params) # get a random seed seed = np.random.randint(1e6) # set the new seed np.random.seed(seed) noise = sample_noise(actor) pos_rew = evaluate_noisy_net(STD_NOISE, noise, actor, env, elite_queue) # Mirrored sampling neg_rew = evaluate_noisy_net(STD_NOISE, -noise, actor, env, elite_queue) output_queue.put([[pos_rew, neg_rew], seed]) else: break
def main(): # load dataset adata = load_data('./data/') train_adata, test_adata = train_test(adata, 0.8) dataset = KidneyDataset('./data/') train_set, test_set = random_split(dataset, [math.floor(len(dataset) * 0.8), len(dataset) - math.floor(len(dataset) * 0.8)]) # not sure about batch sizes, need to figure this out more train_dl = DataLoader(train_set, batch_size=64) test_dl = DataLoader(test_set, batch_size=64) device = 'cuda' if torch.cuda.is_available() else 'cpu' print(f'Using {device} device') model = NeuralNetwork() model = model.to(device) wandb.watch(model) loss_fn = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(model.parameters(), lr=1e-3) for i in range(4): print(f"Epoch {i+1}\n-------------------------------") train(train_dl, model, loss_fn, optimizer) test(test_dl, model)
def __init__(self, host, port, _host, _port, model_path): # load trained neural network self.nn = NeuralNetwork(model_path) self.cap = cv2.VideoCapture(0) self.rc_car = RCControl(_h, _p)
class RCDriverNNOnly(object): def __init__(self, host, port, serial_port, model_path): self.server_socket = socket.socket() self.server_socket.bind((host, port)) self.server_socket.listen(0) # accept a single connection self.connection = self.server_socket.accept()[0].makefile('rb') # connect to a seral port self.ser = serial.Serial(serial_port, 115200, timeout=1) # load trained neural network self.nn = NeuralNetwork() self.nn.load_model(model_path) self.rc_car = RCControl(serial_port) def drive(self): stream_bytes = b' ' try: # stream video frames one by one while True: stream_bytes += self.connection.read(1024) first = stream_bytes.find(b'\xff\xd8') last = stream_bytes.find(b'\xff\xd9') if first != -1 and last != -1: jpg = stream_bytes[first:last + 2] stream_bytes = stream_bytes[last + 2:] gray = cv2.imdecode(np.frombuffer(jpg, dtype=np.uint8), cv2.IMREAD_GRAYSCALE) image = cv2.imdecode(np.frombuffer(jpg, dtype=np.uint8), cv2.IMREAD_COLOR) # lower half of the image height, width = gray.shape roi = gray[int(height / 2):height, :] cv2.imshow('image', image) # cv2.imshow('mlp_image', roi) # reshape image image_array = roi.reshape(1, int(height / 2) * width).astype( np.float32) # neural network makes prediction prediction = self.nn.predict(image_array) self.rc_car.steer(prediction) if cv2.waitKey(1) & 0xFF == ord('q'): print("car stopped") self.rc_car.stop() break finally: cv2.destroyAllWindows() self.connection.close() self.server_socket.close()
def train_model(X_test, X_train, y_test, y_train): print_steps = 50 epoch = 100 model = NeuralNetwork() model.initialize_variables() model.create_graph() model.train(X_train, y_train, print_steps, epoch) model.test(X_test, y_test) return model
def main(): """Main entry to the application """ args = get_console_args() # Define the network's architecture architecture = JsonProcessor.load(args.architecture_file) # Initialize the Neural Network nn = NeuralNetwork(**architecture) # Set its parameters nn.set_parameters() # Loads the data nn.load_data(args.training_data) # Train the neural network nn.train(args.epochs) # Get its predictions predictions = nn.predict(JsonProcessor.load(args.testing_data)['input']) # Save its predictions JsonProcessor.beautify(args.output_file, {'output': predictions.tolist()})
class RCDriverNNOnly(object): def __init__(self, host, port, serial_port, model_path): self.server_socket = socket.socket() self.server_socket.bind((host, port)) self.server_socket.listen(0) # accept a single connection self.connection = self.server_socket.accept()[0].makefile('rb') # load trained neural network self.nn = NeuralNetwork() self.nn.load_model(model_path) self.rc_car = RCControl(serial_port) def drive(self): stream_bytes = b' ' try: # stream video frames one by one while True: stream_bytes += self.connection.read(1024) first = stream_bytes.find(b'\xff\xd8') last = stream_bytes.find(b'\xff\xd9') if first != -1 and last != -1: jpg = stream_bytes[first:last + 2] stream_bytes = stream_bytes[last + 2:] gray = cv2.imdecode(np.frombuffer(jpg, dtype=np.uint8), cv2.IMREAD_GRAYSCALE) image = cv2.imdecode(np.frombuffer(jpg, dtype=np.uint8), cv2.IMREAD_COLOR) # lower half of the image height, width = gray.shape roi = gray[int(height/2):height, :] cv2.imshow('image', image) # cv2.imshow('mlp_image', roi) # reshape image image_array = roi.reshape(1, int(height/2) * width).astype(np.float32) # neural network makes prediction prediction = self.nn.predict(image_array) self.rc_car.steer(prediction) if cv2.waitKey(1) & 0xFF == ord('q'): print("car stopped") self.rc_car.stop() break finally: cv2.destroyAllWindows() self.connection.close() self.server_socket.close()
def __init__(self, client, steer): self.client = client self.steer = steer self.stopline = StopLine.Stop() self.dect = Object.Object_Detection(self.steer) # model create self.model = NeuralNetwork() self.model.load_model(path = 'model_data/video_model_1.h5')
def __init__(self, hidden_sizes, batch_size, learning_rate, activator): """The entry of project. Load data and build Neural Network model. """ self.hidden_sizes = hidden_sizes self.batch_size = batch_size self.learning_rate = learning_rate self.activator = activator self.data = Data(SHELL_ARGS.prefix) self.model = NeuralNetwork(self.data.input_size(), self.hidden_sizes, self.data.output_size(), self.batch_size, self.activator)
def __init__(self, host, port, serial_port, model_path): self.server_socket = socket.socket() self.server_socket.bind((host, port)) self.server_socket.listen(0) # accept a single connection self.connection = self.server_socket.accept()[0].makefile('rb') # load trained neural network self.nn = NeuralNetwork() self.nn.load_model(model_path) self.rc_car = RCControl(serial_port)
class RCDriverNNOnly(object): def __init__(self, host_str, model_path): # load trained neural network self.nn = NeuralNetwork() self.nn.load_model(model_path) self.car_ctrl = sock_car_control() def drive(self): stream_bytes = b' ' stream = urllib.request.urlopen(host_str) try: # stream video frames one by one while True: stream_bytes += stream.read(1024) first = stream_bytes.find(b'\xff\xd8') last = stream_bytes.find(b'\xff\xd9') if first != -1 and last != -1: jpg = stream_bytes[first:last + 2] stream_bytes = stream_bytes[last + 2:] gray = cv2.imdecode(np.frombuffer(jpg, dtype=np.uint8), cv2.IMREAD_GRAYSCALE) image = cv2.imdecode(np.frombuffer(jpg, dtype=np.uint8), cv2.IMREAD_COLOR) # lower half of the image height, width = gray.shape roi = gray[int(height / 2):height, :] cv2.imshow('image', image) # cv2.imshow('mlp_image', roi) # reshape image image_array = roi.reshape(1, int(height / 2) * width).astype( np.float32) # neural network makes prediction prediction = self.nn.predict(image_array) self.car_ctrl.steer(prediction) if cv2.waitKey(1) & 0xFF == ord('q'): print("car stopped") self.car_ctrl.stop() break finally: cv2.destroyAllWindows() self.car_ctrl.close()
def __init__(self, client, steer): self.client = client self.steer = steer self.stopline = StopLine.Stop() self.objDetect = Object.Object_Detection( self.steer) # class - load object detection model # model create print("Load VGGNet") self.model = NeuralNetwork() self.model.load_model( path='../model_data/posicar_binary_v11.h5') # self-driving model print("Complete")
def __init__(self, model_path): print('initing...') # load trained neural network if model_num == 1: import model_b as model self.model = model elif model_num == 0: load_model_start = time.time() from model import NeuralNetwork self.model = NeuralNetwork(model_path) load_model_end = time.time() print('loading model costs {:02f} second(s)'.format(load_model_end - load_model_start)) self.cap = cv2.VideoCapture(0) self.servo = PyServo.Servo(SerialID,Baudrate)
def run(): # Initialize size of network with inode = 3 hnode = 4 onode = 2 n = NeuralNetwork(inode, hnode, onode) entry = [1.0, 0.5, -1.5] result = n.query(entry) print("Init:") print(n.w_input_hidden) target = list(result.T[0]) n.train(entry, target) print("") print("Target:") print(n.w_input_hidden) target[0] += 1 n.train(entry, target) print("") print("Error:") print(n.w_input_hidden)
def run(data_obj, training_size): data_obj.split_dataset(training_size) data_obj.preprocess() #-------------------------------- Autoencoder model ae_model = AutoEncoder(data_obj.x_train_scaled.shape[1], training_size, data_obj.name) ae_model.train(data_obj.x_train_scaled, data_obj.x_val_scaled) #-------------------------------- Encoded representation x_train_encoded, x_val_encoded, x_test_encoded = ae_model.encoded_data( data_obj.x_train_scaled, data_obj.x_val_scaled, data_obj.x_test_scaled) #-------------------------------- Neural Network model nn_model = NeuralNetwork( data_obj.x_train_scaled.shape[1], data_obj.y_train.shape[1], training_size, data_obj.name) nn_model.train( x_train_encoded, data_obj.y_train, x_val_encoded, data_obj.y_val) nn_model.evaluate(x_test_encoded, data_obj.y_test) #-------------------------------- reset data from memory data_obj.reset_scalar() return nn_model.result()
class VideoStreamHandler(socketserver.StreamRequestHandler): # load trained neural network model = NeuralNetwork() model.modified_model() model.load_model() # # hard coded thresholds for stopping, sensor 30cm, other two 25cm d_sensor_thresh = 15 def handle(self): global prediction global sensor_data stream_bytes = b' ' try: # stream video frames one by one while True: stream_bytes += self.rfile.read(1024) first = stream_bytes.find(b'\xff\xd8') last = stream_bytes.find(b'\xff\xd9') if first != -1 and last != -1: jpg = stream_bytes[first:last + 2] stream_bytes = stream_bytes[last + 2:] gray = cv2.imdecode(np.frombuffer(jpg, dtype=np.uint8), cv2.IMREAD_GRAYSCALE) image = cv2.imdecode(np.frombuffer(jpg, dtype=np.uint8), cv2.IMREAD_COLOR) # lower half of the image height, width = gray.shape roi = gray[int(height / 1.25):height, :] cv2.imshow('image', image) # reshape image gray = (np.expand_dims(roi, 0)) gray = gray[:, :, :, np.newaxis] # neural network makes prediction prediction = self.model.predict(gray) # stop conditions if sensor_data and int(sensor_data) < self.d_sensor_thresh: print("Dur, Nesne Algılandı...!\n") prediction = 4 sensor_data = None if cv2.waitKey(1) & 0xFF == ord('q'): print("car stopped") break finally: cv2.destroyAllWindows() sys.exit()
def joint_actuate(clientID, Body, primitive, frame): model = NeuralNetwork() model.load_state_dict(torch.load('C:\\Users\\lenovo\\Desktop\\AI-Project-Portfolio\\Amendments\\new_angle_mapping\\weights_2.pth')) model.eval() angle = model(torch.from_numpy(primitive[frame].reshape(1, -1)).float()) HP, HY, LSP, LSR, LER, LEY, RSP, RSR, RER, REY, LHP, LHR, LHYP, LKP, RHP, RHR, RHYP, RKP, LAP, LAR, RAP, RAR = angle.detach().numpy().reshape(-1) print(LSP, LSR, LER, LEY) def control(joint, angel): sim.simxSetJointTargetPosition(clientID, Body[joint], angel, sim.simx_opmode_oneshot) sim.simxPauseCommunication(clientID,1) control('HeadPitch', HP) control('HeadYaw', HY) control('LShoulderPitch', 1*LSP) control('LShoulderRoll', 1*LSR) control('LElbowRoll', 1*LER) control('LElbowYaw', 1*LEY) control('RShoulderPitch', RSP) control('RShoulderRoll', RSR) control('RElbowRoll', RER) control('RElbowYaw', REY) control('LHipPitch', LHP) control('LHipRoll', LHR) control('LHipYawPitch', LHYP) control('LKneePitch', LKP) control('RHipPitch', RHP) control('RHipRoll', RHR) control('RHipYawPitch', RHYP) control('RKneePitch', RKP) control('LAnklePitch', LAP) control('LAnkleRoll', LAR) control('RAnklePitch', RAP) control('RAnkleRoll', RAR) sim.simxPauseCommunication(clientID,0) #time.sleep(.04)
def use_QII_with_model(X_train): model = NeuralNetwork() model.create_graph() # get input data for each layer hl_1, hl_2, hl_3, prediction = model.predict(X_train) # PREDEFINE PARAMETERS # Number of features available for sampling, we want to observe # input layer, hence number of units is 4 numb_features = 4 # initializes QII class with name for each features, here we use index only feature_list = [str(i) for i in range(1, numb_features + 1)] influencer = QII(X_train, feature_list) # value of one data points we want to observe data_point = X_train[0] with tf.Session(graph=model.graph) as sess: saver = tf.train.Saver() saver.restore(sess, model.CHECK_POINT) # user can choose to calculate shapley by random sampling of permutation # or exhaustively check each of them with is_exhaustive # since 4! = 24 is not a big number, we can try both here print('Approximation with Random Sampling') shapley_val = influencer.shapley(data_point, model.predict_input, sess, is_exhaustive=False) print(shapley_val) print('Correct value with Exhausive Computation') shapley_val = influencer.shapley(data_point, model.predict_input, sess, is_exhaustive=True) print(shapley_val)
def crossover(args, STATE_DIM, ACTION_DIM, gene1, gene2): actor_1 = NeuralNetwork(STATE_DIM, ACTION_DIM.shape[0], args.hidden_size) actor_1.load_state_dict(gene1) actor_2 = NeuralNetwork(STATE_DIM, ACTION_DIM.shape[0], args.hidden_size) actor_2.load_state_dict(gene2) for param1, param2 in zip(actor_1.parameters(), actor_2.parameters()): # References to the variable tensors W1 = param1.data W2 = param2.data if len(W1.shape) == 2: #Weights no bias num_variables = W1.shape[0] # Crossover opertation [Indexed by row] num_cross_overs = random.randrange( num_variables * 2) # Lower bounded on full swaps for i in range(num_cross_overs): receiver_choice = random.random( ) # Choose which gene to receive the perturbation if receiver_choice < 0.5: ind_cr = random.randrange(W1.shape[0]) # W1[ind_cr, :] = W2[ind_cr, :] else: ind_cr = random.randrange(W1.shape[0]) # W2[ind_cr, :] = W1[ind_cr, :] elif len(W1.shape) == 1: #Bias num_variables = W1.shape[0] # Crossover opertation [Indexed by row] num_cross_overs = random.randrange( num_variables) # Lower bounded on full swaps for i in range(num_cross_overs): receiver_choice = random.random( ) # Choose which gene to receive the perturbation if receiver_choice < 0.5: ind_cr = random.randrange(W1.shape[0]) # W1[ind_cr] = W2[ind_cr] else: ind_cr = random.randrange(W1.shape[0]) # W2[ind_cr] = W1[ind_cr]
def use_QII_with_model(X_train): model = NeuralNetwork() model.create_graph() hl_1, hl_2, hl_3, prediction = model.predict(X_train) numb_features = 4 # hidden layer 3 has 4 units feature_list = [str(i) for i in range(1, numb_features + 1)] influencer = QII(X_train, feature_list) # value of one data points we want to observe data_point = X_train[101] with tf.Session(graph=model.graph) as sess: saver = tf.train.Saver() saver.restore(sess, model.CHECK_POINT) observed_feature_list = [0, 1, 3] banzhaf_val = influencer.banzhaf(data_point, model.predict_input, sess, observed_feature_list, is_exhaustive=True) influence_scores = np.array([banzhaf_val[i] for i in feature_list]) influence_scores = np.expand_dims(influence_scores, axis=0) influencer.plot_influence_score(influence_scores, feature_list)
def main(): # ----DATA PREPARATION---- # x, y = make_moons(1000, noise=0.20) plt.scatter(x[:, 0], x[:, 1], s=10, c=y, cmap=plt.cm.Spectral) np.random.seed(0) np.random.shuffle(y) np.random.seed(0) np.random.shuffle(x) # ----MODEL TRAINING---- # settings = { 'layer_sizes': [x.shape[1], 3, len(np.unique(y))], 'epochs': 100, 'alpha': 0.01, 'lmbda': 0.001 } nn = NeuralNetwork(**settings) nn.train(x, y)
def load(path): if not os.path.exists(path): print("Training can not be continued, cause it does not exist!") exit() with open(f"{path}/training_info.txt", "r") as info_file: lines = info_file.readlines() iterration = int(lines[0]) pop_size = int(lines[1]) sigma = float(lines[2]) learning_rate = float(lines[3]) best_main = float(lines[4]) best_all = float(lines[5]) model = NeuralNetwork.load(f"{path}/model.h5") return Training(path, iterration, pop_size, sigma, learning_rate, model=model, best_main=best_main, best_all=best_all)
def __init__(self, layer_sizes, env_name, invert_reward=True, amount_threads=None, cpu_only=True, number_repeats=5, seed=8, reward_offset=0): self.reward_offset = reward_offset self.invert_reward = invert_reward self.amount_threads = multiprocessing.cpu_count( ) if amount_threads == None else amount_threads self.envs = [gym.make(env_name) for _ in range(self.amount_threads)] for env in self.envs: env.seed(seed) self.env_name = env_name input_size = self.envs[0].observation_space.shape[0] if isinstance(self.envs[0].action_space, spaces.Discrete): print(env_name, "has a discrete action space") output_activation = softmax output_size = self.envs[0].action_space.n self.discrete_action = True output_activation = softmax else: print(env_name, "has a non-discrete action space") output_activation = None output_size = self.envs[0].action_space.shape[0] self.discrete_action = False output_activation = np.tanh self.models = [ NeuralNetwork(input_size=input_size, hidden_sizes=layer_sizes, output_size=output_size, output_activation=output_activation, discrete_action=self.discrete_action) for _ in range(self.amount_threads) ] self.solution_size = len(self.models[0].get_weights()) self.number_repeats = number_repeats self.interrupt = False
def train(args, data_info): n_user = data_info[0] n_item = data_info[1] train_data = data_info[2] val_data = data_info[3] test_data = data_info[4] model = NeuralNetwork(args, n_user, n_item) train_rmse_ls = [] val_rmse_ls = [] test_rmse_ls = [] epoch = [] with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for step in range(args.n_epochs): np.random.shuffle(train_data) start = random.randint(0, train_data.shape[0] - args.batch_size) _ = model.train(sess, feed_dict=get_feed_dict(train_data, model, start, start + args.batch_size)) #start = 0 #while start < len(train_data): # model.train(sess, feed_dict=get_feed_dict(train_data, model, start, start + args.batch_size)) # start += args.batch_size train_loss, train_rmse = model.validation(sess, feed_dict=get_feed_dict( train_data, model, 0, len(train_data))) val_loss, val_rmse = model.validation(sess, feed_dict=get_feed_dict( val_data, model, 0, len(val_data))) test_loss, test_rmse = model.validation(sess, feed_dict=get_feed_dict( test_data, model, 0, len(test_data))) train_rmse_ls.append(train_rmse) val_rmse_ls.append(val_rmse) test_rmse_ls.append(test_rmse) epoch.append(step) print( 'epoch %d train loss: %.4f rmse: %.4f val loss: %.4f rmse: %.4f test loss: %.4f rmse: %.4f' % (step, train_loss, train_rmse, val_loss, val_rmse, test_loss, test_rmse)) return train_rmse_ls, val_rmse_ls, test_rmse_ls, epoch
__author__ = 'zhengwang' from model import load_data, NeuralNetwork input_size = 120 * 320 data_path = "training_data/*.npz" X_train, X_valid, y_train, y_valid = load_data(input_size, data_path) # train a neural network layer_sizes = [input_size, 32, 4] nn = NeuralNetwork() nn.create(layer_sizes) nn.train(X_train, y_train) # evaluate on train data train_accuracy = nn.evaluate(X_train, y_train) print("Train accuracy: ", "{0:.2f}%".format(train_accuracy * 100)) # evaluate on validation data validation_accuracy = nn.evaluate(X_valid, y_valid) print("Validation accuracy: ", "{0:.2f}%".format(validation_accuracy * 100)) # save model model_path = "saved_model/nn_model.xml" nn.save_model(model_path)