def train(epochs, prev_data): if prev_data is None: data_saves = sorted(glob.glob('fine_tune_data/data*.npz')) else: data_saves = sorted(glob.glob('fine_tune_data/data*.npz'))[-prev_data:] x = list() y = list() for data_save in data_saves: data = np.load(data_save) x.append(data['x']) y.append(data['y']) x = np.concatenate(x, axis=0) y = np.concatenate(y, axis=0) single_frame_encoder = model.single_frame_model() multi_frame_encoder = model.multi_frame_model(num_frames=None) full_model = model.full_model(single_frame_encoder, multi_frame_encoder, num_frames=None) training_run = 'run12' single_frame_encoder_loc = os.path.join('./inference', training_run, 'single_frame.h5') multi_frame_encoder_loc = os.path.join('./inference', training_run, 'multi_frame.h5') single_frame_encoder.load_weights(single_frame_encoder_loc, by_name=True) multi_frame_encoder.load_weights(multi_frame_encoder_loc, by_name=True) for layer in single_frame_encoder.layers: if layer.name in { 'separable_conv2d_15', 'separable_conv2d_16', 'separable_conv2d_18' }: layer.trainable = True else: layer.trainable = False for layer in multi_frame_encoder.layers: if layer.name in {'dense_1'}: layer.trainable = True else: layer.trainable = False full_model.compile(optimizer=SGD(learning_rate=1e-3, momentum=0.9, nesterov=True), loss=temporal_crossentropy, metrics=[temporal_accuracy, temporal_top_k_accuracy]) full_model.fit(x, y, batch_size=BATCH_SIZE, epochs=epochs, shuffle=True) single_frame_encoder.save(single_frame_encoder_loc) multi_frame_encoder.save(multi_frame_encoder_loc)
def evaluate(): data_saves = sorted(glob.glob('fine_tune_data/data*.npz')) x = list() y = list() for data_save in data_saves: data = np.load(data_save) x.append(data['x']) y.append(data['y']) x = np.concatenate(x, axis=0) y = np.concatenate(y, axis=0) total_samples = y.sum(axis=0).astype(np.int) for gesture, num_samples in zip(GESTURES, total_samples): print('{} : {}'.format(gesture, num_samples)) single_frame_encoder = model.single_frame_model() multi_frame_encoder = model.multi_frame_model(num_frames=None) full_model = model.full_model(single_frame_encoder, multi_frame_encoder, num_frames=None) training_run = 'run12' single_frame_encoder_loc = os.path.join('./inference', training_run, 'single_frame.h5') multi_frame_encoder_loc = os.path.join('./inference', training_run, 'multi_frame.h5') single_frame_encoder.load_weights(single_frame_encoder_loc, by_name=True) multi_frame_encoder.load_weights(multi_frame_encoder_loc, by_name=True) y_pred = full_model.predict(x) y_pred = np.average(y_pred, axis=1) conf_matrix = tf.math.confusion_matrix(y.argmax(axis=1), y_pred.argmax(axis=1), num_classes=27).numpy() conf_matrix = conf_matrix.astype('float') / conf_matrix.sum( axis=1)[:, np.newaxis] plt.figure(figsize=(14, 10)) sns.heatmap(conf_matrix, annot=True) plt.title('Confusion Matrix') plt.yticks(np.arange(len(GESTURES)), GESTURES, rotation='horizontal') plt.xticks(np.arange(len(GESTURES)), GESTURES, rotation='vertical') plt.ylabel('True label') plt.xlabel('Predicted label') plt.tight_layout() plt.show()
def plot_model(this, C_mix, C_dyn, cascade=False): v = this['viscosity'] c = this['conductivity'] times, heights, mix = filter_trajectory(this['time'], this['height2'], this['mixed_mass'], this['extent_mesh'][2]) mix = 2 * (64 - mix) #times = this['time']; heights = this['height2'] if len(times) < len(this['time']): print("TRUNC: {} {} stopped at {}".format(v, c, times[-1])) if heights.size < 4: return L = np.sqrt(2) / this["kmin"] Atwood = this['atwood'] * this['g'] y0 = [this["amp0"] / this["kmin"], 0.] Gr = Atwood * L**3 / (v * v) Ra = Gr * v / c Sc = v / c gamma = np.sqrt(Atwood * 2. * np.pi / L) offset = this['delta']**2. / c h_spline = UnivariateSpline(times, heights, k=3, s=0.00000001) v_spline = h_spline.derivative() m_spline = UnivariateSpline(times, mix, k=3, s=0.00000001) #T, H, V = dyn_model(exp_dyn(C_dyn), Atwood, v, L, m_spline, y0, times) T, HB, VB, MB = full_model(exp_dyn(C_dyn), exp_mix(C_mix), Atwood, v, L, c, this['delta'], y0, times) dyn_error, mix_error = both_error(exp_dyn(C_dyn), exp_mix(C_mix), Atwood, v, L, c, this['delta'], y0, times, heights, mix) fig, axs = plt.subplots(3, 1, figsize=(8, 12), sharex=True) fig.subplots_adjust(hspace=0) axs[0].plot(times * gamma, heights / L, label="Simulation") axs[0].plot(times * gamma, HB / L, label="Model") axs[0].set_ylabel("Bubble Height ($h / \\lambda$)") axs[0].set_ylim(0.0, 1.2 * np.max(heights) / L) axs[0].legend(loc=2) axs[0].grid() axs[1].plot(times * gamma, v_spline(times) / np.sqrt(Atwood * L), label="Simulation") axs[1].plot(times * gamma, VB / np.sqrt(Atwood * L), label="Model") #axs[1].legend() axs[1].axhline(1. / np.sqrt(np.pi), color='black', linestyle='dashed') #axs[1].axhline(L * np.sqrt(Atwood * L) / (results[v,c]['C_dyn'][1] * v)) axs[1].set_ylim(0.0, 1.2 * np.max(v_spline(times)) / np.sqrt(Atwood * L)) axs[1].set_ylabel("Froude number") axs[1].grid() axs[2].plot(times * gamma, mix / (2 * L * L * L), label="Simulation") axs[2].plot(times * gamma, MB / (2 * L * L * L), label="Model") axs[2].set_ylim(0.0, 1.2 * np.max(mix / (2 * L * L * L))) axs[2].set_ylabel("Mixing height ($M / \lambda^3$) ") axs[2].set_xlabel("Time ($\\gamma_0 T$)") axs[2].grid() #axs[2].legend() if title: axs[1].set_title(r"Fit of $\nu=${} and D={}".format(v, c)) plt.savefig('H-{:d}-{:d}.{}'.format(int(v * 10000), int(c * 10000), img_format)) plt.close() res = results[v, c] #print("V={}, D={}, C=[{:8.3f}], Err={err:8.3f}".format(v, c, *(C_mix), err=res['E_mix'])) #print("V={}, D={}, T={}, Err={}\n >> C=".format(v, c, data_table[v,c,'time'][-1], res['E_',0]) + str(res['coef',:].values())) if np.max(heights) < np.sqrt(2): return print( "LW: V={}, D={}, C_dyn=[{:6.3f}, {:8.3f}, {:6.3f}, {:6.3f}], C_mix=[{C5:6.3f}]: [{derr:6.3f}, {merr:6.3f}]" .format(v, c, *(C_dyn), C5=C_mix[0], derr=dyn_error / np.max(heights), merr=mix_error / np.max(mix))) #print(" >> S=" + str(res['std',:].values())) print( "T: {Grashof} {Rayleigh} {Schmidt} {C1:6.3f} {C2:8.3f} {C3:6.3f} {C7:6.3f} {C5:6.3f} {E_dyn} {E_mix}" .format(Grashof=Gr, Rayleigh=Ra, Schmidt=Sc, C1=C_dyn[0], C2=C_dyn[1], C3=C_dyn[2], C7=C_dyn[3], C5=C_mix[0], E_dyn=dyn_error / np.max(heights), E_mix=mix_error / np.max(mix))) if not cascade: return fig, axs = plt.subplots(1, 1) axs.plot(heights / L, v_spline(times) / np.sqrt(Atwood * L), label="Simulation", color='black') axs.set_ylim(0.0, 2 * np.max(v_spline(times)) / np.sqrt(Atwood * L)) #axs.set_xlim(0.0, np.max(heights)/L) axs.set_xlabel("Bubble Height ($h/\lambda$)") axs.set_ylabel("Froude number") C_mix_tmp = [0., 0.] C_dyn_tmp = [0., 0., 0., 0.] T, HB, VB, MB = full_model(exp_dyn(C_dyn_tmp), exp_mix(C_mix_tmp), Atwood, v, L, c, this['delta'], y0, times) axs.plot(HB / L, VB / np.sqrt(Atwood * L), label='$C_4,C_6,C_8 > 0$') C_mix_tmp = [0., 0.] C_dyn_tmp = [0., 0., C_dyn[2], 0.] T, HB, VB, MB = full_model(exp_dyn(C_dyn_tmp), exp_mix(C_mix_tmp), Atwood, v, L, c, this['delta'], y0, times) axs.plot(HB / L, VB / np.sqrt(Atwood * L), label='$C_3 > 0$') C_mix_tmp = [0., 0.] C_dyn_tmp = [C_dyn[0], 0., C_dyn[2], 0.] T, HB, VB, MB = full_model(exp_dyn(C_dyn_tmp), exp_mix(C_mix_tmp), Atwood, v, L, c, this['delta'], y0, times) axs.plot(HB / L, VB / np.sqrt(Atwood * L), label='$C_1 > 0$') C_mix_tmp = [0., 0.] C_dyn_tmp = [C_dyn[0], C_dyn[1], C_dyn[2], 0.] T, HB, VB, MB = full_model(exp_dyn(C_dyn_tmp), exp_mix(C_mix_tmp), Atwood, v, L, c, this['delta'], y0, times) axs.plot(HB / L, VB / np.sqrt(Atwood * L), label='$C_2 > 0$') C_mix_tmp = [C_mix[0], 0.] C_dyn_tmp = [C_dyn[0], C_dyn[1], C_dyn[2], C_dyn[3]] T, HB, VB, MB = full_model(exp_dyn(C_dyn_tmp), exp_mix(C_mix_tmp), Atwood, v, L, c, this['delta'], y0, times) axs.plot(HB / L, VB / np.sqrt(Atwood * L), label='$C_5,C_7 > 0$') axs.axvline(0.05, color='black', linestyle='dashed') axs.axvline(np.pi * Gr / (128.**2.) / 4., color='black', linestyle='dashed') axs.axvline(Ra / (128. * 64) / 2., color='black', linestyle='dashed') #axs.axvline(1.5, color='black', linestyle='dashed') axs.grid() axs.set_xlim(0.0, 2) if v < 0.0008: axs.legend(loc=2, ncol=1) else: axs.legend(loc=4, ncol=2) plt.savefig('Cascade-short-{:d}-{:d}.{}'.format(int(v * 10000), int(c * 10000), img_format)) axs.set_xlim(0.0, np.max(heights) / L) axs.legend(loc=8, ncol=2) plt.savefig('Cascade-{:d}-{:d}.{}'.format(int(v * 10000), int(c * 10000), img_format)) plt.close() return
min_lr=1e-6), keras.callbacks.TensorBoard(log_dir='./logs', histogram_freq=0, batch_size=32, write_graph=True, write_grads=False, write_images=False, embeddings_freq=0, embeddings_layer_names=None, embeddings_metadata=None, embeddings_data=None, update_freq='epoch') #NotifyCB ] model = full_model(period) model.compile(optimizer='adam', loss='mse') model.fit(x_train, y_train, batch_size=16, validation_data=(x_test, y_test), epochs=100, verbose=1, callbacks=callbacks) model.load_weights("Resnet_50_100.hdf5") y_pred = [] test = x_test[0] print(test.shape) # for i in range(len(x_test)): # test_new=np.reshape(test,(1,period)) # val=model.predict(test_new, verbose=0)
except Exception as e: print(f'Unable to save: {e}') else: print('Saved tf lite') if __name__ == '__main__': tf.keras.backend.set_learning_phase(0) training_run = sys.argv[1] model_loc = sys.argv[2] os.makedirs(os.path.join('./inference', training_run), exist_ok=True) single_frame_encoder = model.single_frame_model() multi_frame_encoder = model.multi_frame_model(num_frames=12) full_model = model.full_model(single_frame_encoder, multi_frame_encoder, num_frames=12) full_model.load_weights(model_loc, by_name=True) print('Loaded model') single_frame_encoder.summary() multi_frame_encoder.summary() if 'tflite' in sys.argv: convert_to_tflite() if 'coreml' in sys.argv: convert_to_coreml() else: single_frame_encoder.save(os.path.join('./inference', training_run, 'single_frame.h5')) multi_frame_encoder.save(os.path.join('./inference', training_run, 'multi_frame.h5')) single_frame_encoder.save(os.path.join('./inference', training_run, 'single_frame.tf')) multi_frame_encoder.save(os.path.join('./inference', training_run, 'multi_frame.tf'))
def main(model_loc): fig, ax = plt.subplots() ax.set_ylim(0, 1) ax.figure.set_size_inches(10, 10) bars = ax.bar(data.labels, np.zeros(NUM_CLASSES, dtype=np.float32)) plt.xticks(rotation=90) plt.tight_layout() num_frames = 7 frame_time = 1 / MIN_FPS * 1000 single_frame_model = model.single_frame_model() multi_frame_model = model.multi_frame_model(num_frames=num_frames) full_model = model.full_model(single_frame_model, multi_frame_model, num_frames=num_frames + 1) full_model.load_weights(model_loc) cap = cv2.VideoCapture(0) image_size = (IMAGE_WIDTH, IMAGE_HEIGHT) prev = np.zeros((4 * 6 * 2048), dtype=np.float32) model_input = np.zeros((1, num_frames, 4 * 6 * 2048), dtype=np.float32) def animate(i): start = time.time() ret, frame = cap.read() if not ret: print("Couldn't read input") return frame = cv2.resize(frame, image_size) frame = frame.astype(np.float32) / 255.0 frame_encoded = single_frame_model.predict(frame[None, ...])[0] frame_encoded = frame_encoded.reshape(4 * 6 * 2048) frame_diff = frame_encoded - prev prev[:] = frame_encoded model_input[0, :-1] = model_input[0, 1:] model_input[0, -1] = frame_diff pred = multi_frame_model.predict(model_input)[0] pred = np.max(pred, axis=0) pred = softmax(pred) for bar, p in zip(bars, pred): bar.set_height(p) # Display the resulting frame cv2.imshow('frame', frame) if cv2.waitKey(max(1, int((time.time() - start) * 1000 - frame_time))) & 0xFF == ord('q'): cap.release() cv2.destroyAllWindows() exit(0) if pred.max() > 0.5: predictions = pred.argsort() print(data.labels[predictions[-1]]) print(data.labels[predictions[-2]]) return bars animation.FuncAnimation(fig, animate, frames=None, interval=1, blit=True) plt.show()