def main(): my_date_time = '_'.join( datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S").split()) parameters = { 'n_folds': n_folds, 'n_repeats': n_repeats, 'batch_size': batch_size, 'nb_epochs': nb_epochs, 'my_patience': my_patience, 'drop_rate': drop_rate, 'my_optimizer': my_optimizer } path_root = sys.path[0] name_save = path_root + '/results/' + my_date_time print('========== loading samples ==========') samples = np.load("sample_all_Train10000_200.npy") entry_model = Entry() tf = samples[:, 0, -1] altitute = (samples[:, 1, 0] - entry_model.constant['R0']) / 1000 downrange = samples[:, 2, -1] * entry_model.constant['R0'] / 1000 - 100 velocity = samples[:, 3, 0] gamma = samples[:, 4, 0] * 180 / np.pi print('Tf range: max:%.2f,min:%.2f, [s],' % (np.amax(tf), np.amin(tf))) print('Downrange range: max:%.2f,min:%.2f [km],' % (np.amax(downrange), np.amin(downrange))) print('Initial Altitute range: max:%.2f,min:%.2f,[km]' % (np.amax(altitute), np.amin(altitute))) print('Initial Velocity range:max:%d,min:%d, [m/s]' % (np.amax(velocity), np.amin(velocity))) print('Initial Flight Path Angle range: max:%.2f,min:%.2f,' % (np.amax(gamma), np.amin(gamma))) alpha = samples[:, -1, :] ys = alpha.flatten() #output row style r = (samples[:, 1, :].flatten() - entry_model.constant['R0']) / entry_model.constant['h0'] theta = samples[:, 2, :].flatten() v = samples[:, 3, :].flatten() / entry_model.constant['v0'] g = samples[:, 4, :].flatten() tensors = np.column_stack((r, theta, v, g)) tensors = tensors.astype(np.float32) print('input shape:', tensors.shape) print('========== shuffling data ==========') shuffled_idxs = random.sample(range(tensors.shape[0]), int(tensors.shape[0])) # sample w/o replct tensors = tensors[shuffled_idxs] ys = ys[shuffled_idxs] shuffled_idxs = np.array(shuffled_idxs) print('========== conducting', n_folds, 'fold cross validation ==========') print('repeating each fold:', n_repeats, 'times') folds = np.array_split(tensors, n_folds, axis=0) print('fold sizes:', [fold.shape[0] for fold in folds]) folds_labels = np.array_split(ys, n_folds, axis=0) outputs = [] histories = [] for i in range(n_folds): t = time.time() x_train = np.concatenate( [fold for j, fold in enumerate(folds) if j != i], axis=0) x_test = [fold for j, fold in enumerate(folds) if j == i] y_train = np.concatenate( [y for j, y in enumerate(folds_labels) if j != i], axis=0) y_test = [y for j, y in enumerate(folds_labels) if j == i] for repeating in range(n_repeats): print('clearing Keras session') K.clear_session() my_input = Input(shape=(4, ), dtype='float32') dense_1 = Dense(dense_units, activation=activation_hidden)(my_input) dense_2 = Dense(dense_units, activation=activation_hidden)(dense_1) dense_3 = Dense(dense_units, activation=activation_hidden)(dense_2) dense_4 = Dense(dense_units, activation=activation_hidden)(dense_3) dense_5 = Dense(dense_units, activation=activation_hidden)(dense_4) dense_6 = Dense(dense_units, activation=activation_hidden)(dense_5) prob = Dense(1)(dense_6) # instantiate model model = Model(my_input, prob) # configure model for training model.compile(loss=my_loss_function, optimizer=my_optimizer, metrics=['mae', 'mse']) print('model compiled') # early_stopping = EarlyStopping(monitor='val_mean_absolute_error', # go through epochs as long as acc on validation set increases # patience=my_patience, # mode='max') history = model.fit( x_train, y_train, batch_size=batch_size, nb_epoch=nb_epochs, validation_data=(x_test, y_test), ) # callbacks=[early_stopping]) # save [min loss,max acc] on test set max_acc = max(model.history.history['val_mean_absolute_error']) max_idx = model.history.history['val_mean_absolute_error'].index( max_acc) output = [model.history.history['val_loss'][max_idx], max_acc] outputs.append(output) # also save full history for sanity checking histories.append(model.history.history) print('**** fold', i + 1, 'done in ' + str(math.ceil(time.time() - t)) + ' second(s) ****') # save results to disk with open(name_save + '_parameters.json', 'w') as my_file: json.dump(parameters, my_file, sort_keys=True, indent=4) print('========== parameters defined and saved to disk ==========') with open(name_save + '_results.json', 'w') as my_file: json.dump({ 'outputs': outputs, 'histories': histories }, my_file, sort_keys=False, indent=4) print('========== results saved to disk ==========')
from TwoD_Entry_bvp import Entry from keras.models import load_model import numpy as np import matplotlib.pyplot as plt entry_model = Entry() samples = np.load("/work/yshi/two/sample_all_Train10000_200.npy") r = samples[:,1,:].flatten() v = samples[:,3,:].flatten() def normalize(state,r,v): r0 = state[0] v0 = state[2] v0 = (v0-np.mean(v))/np.std(v) r0 = (r0-np.mean(r))/np.std(r) return np.array([r0,state[1],v0,state[-1]]) def anti_normalize(state,r,v): r0 = state[0] v0 = state[2] v0 = v0*np.std(v) + np.mean(v) r0 = r0*np.std(r) + np.mean(r) return np.array([r0,state[1],v0,state[-1]]) state = [entry_model.constant['r0'],0,entry_model.constant['v0'],entry_model.constant['gamma0']] #r,theta,v,gamma next_state = normalize(state,r,v)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Mon Jun 17 12:17:36 2019 @author: Yang Shi """ from TwoD_Entry_bvp import Entry from keras.models import load_model import numpy as np import matplotlib.pyplot as plt entry_model = Entry() samples = np.load("sample_all_Train10000_200.npy") r = samples[:, 1, :].flatten() v = samples[:, 3, :].flatten() def normalize(state, r, v): r0 = state[0] v0 = state[2] v0 = (v0 - np.mean(v)) / np.std(v) r0 = (r0 - np.mean(r)) / np.std(r) return np.array([r0, state[1], v0, state[-1]]) def anti_normalize(state, r, v): r0 = state[0]
from keras.models import load_model import numpy as np from keras import backend as K import os from TwoD_Entry_bvp import Entry model_path = '/home/yshi/two/model/43/' train = np.load("/work/yshi/two/sample_all_Train10000_200.npy") samples = np.load('/work/yshi/two/sample_all_Train.npy') entry_model = Entry() hs = entry_model.constant['hs'] R0 = entry_model.constant['R0'] rho0 = entry_model.constant['rho0'] b0 = entry_model.constant['b0'] b2 = entry_model.constant['b2'] c1 = entry_model.constant['c1'] A = entry_model.constant['A'] m = entry_model.constant['m'] g0 = 9.81 alpha = samples[:,-1,:]*np.pi/180 theta = samples[:,2,:].flatten() gamma = samples[:,4,:].flatten() r = samples[:,1,:].flatten() r_normalized = r/R0 v = samples[:,3,:].flatten()
import numpy as np import matplotlib.pyplot as plt from TwoD_Entry_bvp import Entry entry_model = Entry() data = np.load( '/Users/User/Desktop/code/trajectory/Entry30_fold_1_repeating_2_0.npy') contorl = data[:, -1] trajectory = data[:, :-1] step = 1e-4 time = [i * step for i in range(len(contorl))] #indirect method results sol = entry_model.get_optimize([14]) #14 initial guess of tf for 0 downrange plt.figure(figsize=(14, 7)) plt.subplot(221) plt.plot(trajectory[:, 1] * entry_model.constant['R0'] / 1000, (trajectory[:, 0] - entry_model.constant['R0']) / 1000, label='DNN-based Approach') plt.plot(sol.y[1] * entry_model.constant['R0'] / 1000, (sol.y[0] - entry_model.constant['R0']) / 1000, label='Indirect Method') plt.xlabel('Downrange [km]', ) plt.ylabel('Altitude [km]', )
def main(): my_date_time = '_'.join( datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S").split()) parameters = { 'dataset': dataset, 'n_folds': n_folds, 'n_repeats': n_repeats, 'batch_size': batch_size, 'nb_epochs': nb_epochs, 'my_patience': my_patience, 'drop_rate': drop_rate, 'my_optimizer': my_optimizer, 'my_loss_function': my_loss_function, 'dense_units': dense_units, 'layer_numer': layer_numer, 'learning_rate': learning_rate, } path_root = sys.path[0] name_save = path_root + '/results/' + dataset + '_augmentation_' + my_date_time print('========== loading samples ==========') samples = np.load("/work/yshi/two/sample_all_Train10000_200.npy") entry_model = Entry() tf = samples[:, 0, -1] altitute = (samples[:, 1, 0] - entry_model.constant['R0']) / 1000 downrange = samples[:, 2, -1] * entry_model.constant['R0'] / 1000 - 100 velocity = samples[:, 3, 0] gamma = samples[:, 4, 0] * 180 / np.pi print('Tf range: max:%.2f,min:%.2f, [s],' % (np.amax(tf), np.amin(tf))) print('Downrange range: max:%.2f,min:%.2f [km],' % (np.amax(downrange), np.amin(downrange))) print('Initial Altitute range: max:%.2f,min:%.2f,[km]' % (np.amax(altitute), np.amin(altitute))) print('Initial Velocity range:max:%d,min:%d, [m/s]' % (np.amax(velocity), np.amin(velocity))) print('Initial Flight Path Angle range: max:%.2f,min:%.2f,' % (np.amax(gamma), np.amin(gamma))) alpha = samples[:, -1, :] * np.pi / 180 trajectory_time = 1 - samples[:, 0, :] trajectory_time[:, -1] = 0 for tra_index in range(tf.size): trajectory_time[ tra_index, :] = trajectory_time[tra_index, :] * tf[tra_index] ys = trajectory_time.flatten() #output row style #r = (samples[:,1,:].flatten() - entry_model.constant['R0'])/entry_model.constant['h0'] theta = samples[:, 2, :].flatten() #v = samples[:,3,:].flatten()/ entry_model.constant['v0'] g = samples[:, 4, :].flatten() r = samples[:, 1, :].flatten() r = (r - np.mean(r)) / np.std(r) v = samples[:, 3, :].flatten() v = (v - np.mean(v)) / np.std(v) tensors = np.column_stack((r, theta, v, g)) tensors = tensors.astype(np.float32) print('input shape:', tensors.shape) print('========== shuffling data ==========') shuffled_idxs = random.sample(range(tensors.shape[0]), int(tensors.shape[0])) # sample w/o replct tensors = tensors[shuffled_idxs] ys = ys[shuffled_idxs] shuffled_idxs = np.array(shuffled_idxs) print('========== conducting', n_folds, 'fold cross validation ==========') print('repeating each fold:', n_repeats, 'times') folds = np.array_split(tensors, n_folds, axis=0) print('fold sizes:', [fold.shape[0] for fold in folds]) folds_labels = np.array_split(ys, n_folds, axis=0) outputs = [] histories = [] for i in range(n_folds): t = time.time() x_train = np.concatenate( [fold for j, fold in enumerate(folds) if j != i], axis=0) x_test = [fold for j, fold in enumerate(folds) if j == i] y_train = np.concatenate( [y for j, y in enumerate(folds_labels) if j != i], axis=0) y_test = [y for j, y in enumerate(folds_labels) if j == i] for repeating in range(n_repeats): print('clearing Keras session') K.clear_session() # instantiate model model = Sequential() model.add(Dense(dense_units, input_dim=4)) for _ in range(layer_numer): model.add(Dense(dense_units, activation=activation_hidden)) model.add(Dense(1, activation='softplus')) # configure model for training model.compile(loss=my_loss_function, optimizer=Adam(lr=learning_rate), metrics=['mse', 'mae']) print('model compiled') early_stopping = EarlyStopping( monitor= 'val_loss', # go through epochs as long as acc on validation set increases patience=my_patience) history = model.fit(x_train, y_train, batch_size=batch_size, nb_epoch=nb_epochs, validation_data=(x_test, y_test)) # callbacks=[early_stopping]) # save [min loss,max acc] on test set max_acc = min(history.history['val_loss']) max_idx = history.history['val_mean_absolute_error'].index(max_acc) output = [history.history['val_loss'][max_idx], max_acc] outputs.append(output) ## save model #save_name = dataset + '_fold_%d_repeating_%d_'%(i,repeating) + my_date_time #model.save('model/%s.h5'%save_name) # also save full history for sanity checking histories.append(history.history) print('**** fold', i + 1, 'done in ' + str(math.ceil(time.time() - t)) + ' second(s) ****') # save results to disk with open(name_save + '_parameters.json', 'w') as my_file: json.dump(parameters, my_file, sort_keys=True, indent=4) print('========== parameters defined and saved to disk ==========') with open(name_save + '_results.json', 'w') as my_file: json.dump({ 'outputs': outputs, 'histories': histories }, my_file, sort_keys=False, indent=4) print('========== results saved to disk ==========')
from TwoD_Entry_bvp import Entry from keras.models import load_model import numpy as np entry_model = Entry() hs = entry_model.constant['hs'] R0 = entry_model.constant['R0'] rho0 = entry_model.constant['rho0'] b0 = entry_model.constant['b0'] b2 = entry_model.constant['b2'] c1 = entry_model.constant['c1'] A = entry_model.constant['A'] m = entry_model.constant['m'] g0 = 9.81 def anti_normalize(state): r0 = state[0] v0 = state[2] v0 = v0 * np.sqrt(R0 * g0) r0 = r0 * R0 return np.array([r0, state[1], v0, state[-1]]) r = entry_model.constant['r0'] v = entry_model.constant['v0'] theta = 0 gamma = entry_model.constant['gamma0']
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Sat May 25 15:12:50 2019 @author: Yang Shi """ import numpy as np from TwoD_Entry_bvp import Entry model = Entry(random=True) print( '------------------Random Starting Optimization--------------------------') optimization_num = 0 op_round_max = 10000 # 成功比例 mesh_size = 200 sample_all = [] while len(sample_all) < op_round_max: model.reset() for jjj in range(100): tf = np.random.randint(12, 18) # print(tf) result = model.get_optimize([tf]) optimization_num += 1 if result: print('random Starting--', 'round:', len(sample_all), 'step', jjj) sample = model.get_sample(result, mesh_size) #处理多余节点