def strategyAction(strategy, state, DQN_model=None): """ Determines the action of the given strategy on the state. Parameters: strategy (str): strategy to use state (State): current State of the environment Returns: action (str): action of the strategy given the state. """ if strategy == "DQN": if DQN_model is None: print("No DQN model given in the function strategyAction") return ACTIONS[0] q_value = [predict(DQN_model, state, a) for a in ACTIONS] return ACTIONS[np.argmax(q_value)] if strategy == "Random": return np.random.choice(ACTIONS) if strategy == "Trade": return ACTIONS[-1] if strategy == "Nothing": return ACTIONS[-2] if strategy == "RandomBattery": return np.random.choice(ACTIONS[0:2]) if strategy == "SmartBattery": if state.panelProd > state.consumption: return ACTIONS[0] else: return ACTIONS[1] if strategy == "SmartBattery2": if state.panelProd > state.consumption and state.battery < BATTERY_CAPACITY * 0.9999: return ACTIONS[0] elif state.panelProd > state.consumption: return ACTIONS[-1] else: return ACTIONS[1]
parser.add_argument('--num_class', type=int, default=10) args = parser.parse_args() testfolder = args.testfolder print(args.testfolder) # read true_ids true_ids = np.load(os.path.join(testfolder, 'true_ids.npy')) # read files files = os.listdir(testfolder) files.sort() # predict the ids predict_ids = [] time_use = [] for filename in files: # ignore true_ids.npy if filename == 'true_ids.npy': continue data = np.load(os.path.join(testfolder, filename)) predict_id = predict(data, true_ids, args.num_class) predict_ids.append(predict_id) # compute the test accuracy test_accuracy = np.mean(np.array(predict_ids) == np.array(true_ids)) print('Test Accuracy: {:.2f}'.format(test_accuracy))
def test(env: Env, nb_step, DQN_model=None): """ Displays figures to compare the result of the DQN algorithm to other predefined strategies. Parameters: env (Env): environment on which the strategies are tested nb_step (int): number of steps on which to evaluate strategies DQN_model: the model returned by the DQN algorithm. If this parameter is set to None, then only the predefined strategies are tested. This is useful to check the environment. """ env.reset(nb_step=nb_step) initState = copy.deepcopy(env.currentState) conso, prod, price = [], [], [] actions_qvalue = {} for a in ACTIONS: actions_qvalue[a] = [] for i in range(nb_step): env.step(ACTIONS[0]) conso.append(env.currentState.consumption) prod.append(env.currentState.panelProd) price.append(env.currentState.price) actions, cost = {}, {} battery, charge, discharge, generate, trade = {}, {}, {}, {}, {} strategies_list = STRATEGIES[:] if DQN_model is None: strategies_list.remove("DQN") for strategy in strategies_list: actions[strategy], cost[strategy] = [], [] ( battery[strategy], charge[strategy], discharge[strategy], generate[strategy], trade[strategy], ) = ([], [], [], [], []) env.currentState = copy.deepcopy(initState) for i in range(nb_step): if strategy == "DQN": q_value = predict(DQN_model, env.currentState, ACTIONS) action = ACTIONS[np.argmax(q_value)] for q, a in zip(q_value, ACTIONS): actions_qvalue[a].append(float(q)) else: action = strategyAction(strategy, env.currentState) _, _, step_cost = env.step(action) cost[strategy].append(step_cost) actions[strategy].append(action) battery[strategy].append(env.currentState.battery) charge[strategy].append(env.currentState.charge) discharge[strategy].append(env.currentState.discharge) generate[strategy].append(env.currentState.generate) trade[strategy].append(env.currentState.trade) fig, axs = plt.subplots(len(strategies_list)) for i, s in enumerate(strategies_list): axs[i].plot(trade[s]) axs[i].plot(battery[s]) axs[i].legend(["Trade", "Battery"]) axs[i].title.set_text(s) plt.figure(1) fig, axs = plt.subplots(len(strategies_list)) for i, s in enumerate(strategies_list): axs[i].plot(actions[s]) axs[i].legend(["Actions"]) axs[i].title.set_text(s) plt.figure(2) fig, axs = plt.subplots(2) axs[0].plot(conso) axs[0].plot(prod) axs[1].plot(price) axs[0].legend(["Consumption", "Production"]) axs[1].title.set_text("Price") plt.figure(3) fig, ax = plt.subplots() for s in strategies_list: ax.plot(np.cumsum(cost[s])) ax.legend(strategies_list) ax.title.set_text("Cost") plt.figure(4) fig, ax = plt.subplots() for a in ACTIONS: ax.plot(actions_qvalue[a]) ax.legend(ACTIONS) ax.title.set_text("Q-value") plt.figure(5) plt.show()
# assuming that shuffle=True in keras.fit is shuffling correctly history = model.fit(trainX, trainY, shuffle=True, validation_data=(testX, testY), batch_size=batchSize, epochs=nrOfEpochs) model.summary() model.save('models/model_' + str(int(round(time.time()))) + '.h5') # saving acc and loss graph as png plotAndSaveHistory(history) # predicting classes for 1% of the dataset mX # predict(model, mX, mY, 0.01) elif mode is Mode.PREDICT: X, Y = loadData() (mX, mY) = preProcess(X, Y, numberOfChannels, numberOfClasses, cropWindowSize, cropWindowShift, fs) # visuals some spectrograms visualizeSpectrogram(mX, spectroWindowSize, spectroWindowShift, fs, nrOfSpectrogram=1) model = loadModel(modelPath) print("keras.evaluate() result: ", model.evaluate(mX, mY)) # predicting classes for 100% of the dataset mX predict(model, mX, mY, amount=1, verbose=0) elif mode is Mode.LIVE: raise NotImplementedError("Live mode not implemented yet")
print("kfold value: " + str(kfold)) x_train = train_set.loc[train_set['kfold'] != kfold] y_train = target_df.loc[target_df['kfold'] != kfold] x_train.drop('kfold', inplace=True, axis=1) y_train.drop('kfold', inplace=True, axis=1) x_val = train_set.loc[train_set['kfold'] == kfold] y_val = target_df.loc[target_df['kfold'] == kfold] x_val.drop('kfold', inplace=True, axis=1) y_val.drop('kfold', inplace=True, axis=1) model = train(x_train, y_train) print(str(datetime.now() - beginning)) log_loss_score, precision_score, recall_score = validate( model, x_val, y_val) if log_loss_score < log_loss and (precision_score + recall_score) / 2 > precall: print("log_loss: " + str(log_loss_score)) print("precision: " + str(precision_score)) print("recall: " + str(recall_score)) predict(model, test_set, test_df['sig_id']) log_loss = log_loss_score best_model = model best_kfold = kfold precall = (precision_score + recall_score) / 2