예제 #1
0
def func():
    player = input("Please, choose and enter your username: "******"Привет, " + player + "!")
    i = 0
    while True:
        i += 1
        try:
            race = input(
                "Выбери страну, в которой хочешь играть: Carfagen, Serb ")
            if race.lower() == "carfagen":
                player = Units.CorfagenArmyFactory()
                print("Поздравляю! Твой стартовый капитал 100 монет\n")
                print(phr)
                break
            elif race.lower() == "serb":
                player = Units.SerbianArmyFactory()
                print("Поздравляю! Твой стартовый капитал 100 монет\n")
                print(phr)
                break
            else:
                print("Unknown race!")
                raise ValueError
        except ValueError:
            if i < 2:
                print("Choose again.")
            elif i == 2:
                print("Too many times entered wrong line, bye-bye baby)")
                print("I'm just joke, choose one more time!")
            else:
                return
            continue
    print()
    playing.play(player)
예제 #2
0
def browse_mode():

    cartoon_selector = 0
    cartoon = []
    cartoon_cursor = 1

    cartoons_number = selection.count_files("/media/PAP/cartoons/")
    c_path = "/media/PAP/cartoons/pap_"

    # if no USB key named PAP containing cartoons is found, displays an error and returns.
    # This will crash if it contains images that are not names pap_x and are not 1280 / 1024 size.
    if not os.path.exists("/media/PAP/cartoons/"):
        cv2.imshow("window", cv2.imread("./load_failed.png"))
        cv2.waitKey(0)
        return

    while (len(cartoon) == 0):
        cv2.imshow("window", cv2.imread("background2.png"))
        cv2.waitKey(10)
        
        # builds and displays the image containing thumbnails of the cartoons
        selection.build_selection(cartoon_selector, c_path, cartoons_number)
        cv2.waitKey(10)
        button_value = button.waitpressedbutton("browse")

        if (button_value == "mode"):  # the mode is no longer browse, so we return to go to the right mode
            return
        if (button_value == "next"): # sets the cursor to the next cartoon
            cartoon_selector += 1
        elif (button_value == "prev"): # sets the cursor to the previous cartoon
            cartoon_selector -= 1
        elif (button_value == "play"): # plays the cartoon
            cartoon = playing.load_selected(c_path + str(cartoon_selector % cartoons_number + 1) + "/")
            playing.play(cartoon)
예제 #3
0
 def UpdatePolicyFEList(self, weights, opt_count, scene_file_name, enlarge_lr):  
     # store feature expecations of a newly learned policy and its difference to the expert policy	
     print("Updating Policy FE list starts......")
     
     #start_time = timeit.default_timer()
     model_name, stop_status = QLearning(num_features, num_actions, self.params, weights, self.results_folder, self.behavior_type, self.train_frames, opt_count, scene_file_name, enlarge_lr=enlarge_lr)	
     
     #print("Total consumed time: ", timeit.default_timer() - start_time, " s")
         
     # get the trained model
     print("The latest Q-learning model is: ", model_name)
     model = net1(self.num_features, self.num_actions, self.params['nn'], model_name)
     
     # get feature expectations by executing the learned model
     temp_fe, aver_score, aver_dist = play(model, weights, self.play_frames, play_rounds=10, scene_file_name=scene_file_name)
     
     # t = (weights.tanspose)*(expertFE-newPolicyFE)
     # hyperdistance = t
     temp_hyper_dis = np.abs(np.dot(weights, np.asarray(self.expert_fe)-np.asarray(temp_fe))) 
     self.policy_fe_list[temp_hyper_dis] = temp_fe
     if opt_count == 1:
         del self.policy_fe_list[self.random_dis]
     self.model_list.append(model)
     
     print("Updating Policy FE list finished!")
     return temp_hyper_dis, aver_score, aver_dist, stop_status
예제 #4
0
def free_mode():

    takes_list = []

    background = cv2.imread("background2.png", 1)
    cv2.imshow("window", background)
    cv2.waitKey(50)            
    while ("true"):

        mode = GPIO.input(13) # reads the circle switch

        if (mode == False or len(takes_list) < 3):
            cv2.imshow("window", background)
        else:
            cv2.imshow("window", image.averager(takes_list)) # displays a weighed average of the last 3 pictures taken
        cv2.waitKey(100)

        button_value = button.waitpressedbutton("free")

        if (button_value == "mode"):         # The mode is no longer freemode, we have to return to go to the selected mode
            return

        if (button_value == "record"):                        # takes and displays a picture
            cv2.imshow("window", background)
            cv2.waitKey(10)
            takes_list.append(camera.get_image())
            cv2.imshow("window", takes_list[len(takes_list) - 1])
            cv2.waitKey(200)

        if (button_value == "delete" and len(takes_list) > 0): # deletes the last picture taken
            img_supp = cv2.imread("img_supp.png", 1)
            cv2.imshow("window", img_supp)
            cv2.waitKey(10)
            del takes_list[-1]
            cv2.imshow("window", background)
            cv2.waitKey(300)
        if (button_value == "save"):                        # saves the cartoon and returns

            if (len(os.listdir("/media")) >= 2):
                os.system("mount /dev/sdb1 /home/pi/Pas_a_pas/bla")
                playing.save_other(takes_list)
                os.system("umount /home/pi/Pas_a_pas/bla")
            playing.save(takes_list)
            return
        if (button_value == "play"):                        # plays the cartoon
            playing.play(takes_list)
예제 #5
0
 def getRLAgentFE(self, W, i):
     # IRL_helper(W, path, self.num_frames, i)
     # saved_model = path
     # model = neural_net(self.num_states, [164, 150], saved_model)
     model = ddpg.train(W)
     print(
         '======================================= play ========================================'
     )
     return play(model, W)
예제 #6
0
def free_mode():

    takes_list = []

    background = cv2.imread("background2.png", 1)
    cv2.imshow("window", background)
    cv2.waitKey(50)
    while ("true"):

        mode = GPIO.input(13)  # reads the circle switch

        if (mode == False or len(takes_list) < 3):
            cv2.imshow("window", background)
        else:
            cv2.imshow(
                "window", image.averager(takes_list)
            )  # displays a weighed average of the last 3 pictures taken
        cv2.waitKey(100)

        button_value = button.waitpressedbutton("free")

        if (
                button_value == "mode"
        ):  # The mode is no longer freemode, we have to return to go to the selected mode
            return

        if (button_value == "record"):  # takes and displays a picture
            cv2.imshow("window", background)
            cv2.waitKey(10)
            takes_list.append(camera.get_image())
            cv2.imshow("window", takes_list[len(takes_list) - 1])
            cv2.waitKey(200)

        if (button_value == "delete"
                and len(takes_list) > 0):  # deletes the last picture taken
            del takes_list[-1]
            cv2.imshow("window", background)
            cv2.waitKey(300)
        if (button_value == "save"):  # saves the cartoon and returns
            playing.save(takes_list)
            return
        if (button_value == "play"):  # plays the cartoon
            playing.play(takes_list)
예제 #7
0
 def getRLAgentFE(
         self, W,
         i):  #get the feature expectations of a new poliicy using RL agent
     # saved_model = 'saved-models_brown/evaluatedPolicies/1-164-150-100-50000-100000.h5'
     # self.model.restore_model(saved_model)
     IRL_helper(W, self.behavior, self.num_frames, i, self.model
                )  # train the agent and save the model in a file used below
     # saved_model = 'saved-models_'+self.behavior+'/evaluatedPolicies/'+str(i)+'-164-150-100-50000-'+str(self.num_frames)+'.h5' # use the saved model to get the FE
     # model = Policy_Network(self.num_states, [164, 150], self.sess, saved_model)
     # self.model.restore(saved_model)
     # print('loaded_model--------')
     return play(
         self.model,
         W)  #return feature expectations by executing the learned policy
예제 #8
0
 def getRLAgentFE(self, W, i): #get the feature expectations of a new poliicy using RL agent
     IRL_helper(W, self.behavior, self.num_frames, i) # train the agent and save the model in a file used below
     saved_model = 'saved-models_'+self.behavior+'/evaluatedPolicies/'+str(i)+'-164-150-100-50000-'+str(self.num_frames)+'.h5' # use the saved model to get the FE
     model = neural_net(self.num_states, [164, 150], saved_model)
     return  play(model, W)#return feature expectations by executing the learned policy
예제 #9
0
def assisted_mode():

    # The model is loaded first
    model_list = selection.select_cartoon("/media/PAP/models/", "assisted")
    if model_list == None:
        return

    takes_list = []
    background = cv2.imread("background2.png", 1)
    model_cursor = 0
    takes_cursor = 0

    # When this condition is false, the program saves automatically the cartoon and returns
    while (len(model_list) > len(takes_list)):

        if ((GPIO.input(6) == False) or (len(takes_list) == 0)):
            cv2.imshow("window", model_list[model_cursor % len(model_list)])
            cv2.waitKey(100)
        else:
            cv2.imshow("window", takes_list[takes_cursor % len(takes_list)])
            cv2.waitKey(100)

        # I move the window again because of a window issue, that still occurs the first time model_cursor = 1
        cv2.moveWindow("window", 0, -30)

        button_value = button.waitpressedbutton("assisted")
        if (button_value == "mode"):
            return

        if (button_value == "record"):  # take the picture
            model_cursor += 1
            cv2.imshow("window", background)
            cv2.waitKey(20)
            takes_list.append(camera.get_image())

        if (button_value == "delete" and len(takes_list) >
                0):  # delete the last picture from takes_list
            del (takes_list[-1])
            cv2.waitKey(300)

        if (button_value == "save"):  # save the cartoon and returns
            if not os.path.exists("/media/PAP/cartoons"):
                cv2.imshow("window", cv2.imread("./save_failed"))
                cv2.waitKey(100)
            else:
                playing.save(takes_list)
                return

        if (button_value == "play"):  # plays the cartoon
            playing.play(takes_list)
        if (button_value == "next"):  # move to next image
            if (GPIO.input(6) == False):
                model_cursor += 1
            else:
                takes_cursor += 1
            cv2.waitKey(100)

        if (button_value == "prev"):  # move to previous image
            if (GPIO.input(6) == False):
                model_cursor -= 1
            else:
                takes_cursor -= 1
            cv2.waitKey(100)

    # end of while loop, save and return
    if not os.path.exists("/media/PAP/cartoons"):
        cv2.imshow("window", cv2.imread("./save_failed"))
        cv2.waitKey(100)
    else:
        playing.save(takes_list)
        return
예제 #10
0
파일: assisted.py 프로젝트: Klausto/Pas-pas
def assisted_mode():

    # The model is loaded first
    model_list = selection.select_cartoon("/media/PAP/models/", "assisted")
    if model_list == None:
        return

    takes_list = []
    background = cv2.imread("background2.png", 1)
    model_cursor = 0
    takes_cursor = 0

    # When this condition is false, the program saves automatically the cartoon and returns
    while len(model_list) > len(takes_list):

        if (GPIO.input(6) == False) or (len(takes_list) == 0):
            cv2.imshow("window", model_list[model_cursor % len(model_list)])
            cv2.waitKey(100)
        else:
            cv2.imshow("window", takes_list[takes_cursor % len(takes_list)])
            cv2.waitKey(100)

        # I move the window again because of a window issue, that still occurs the first time model_cursor = 1
        cv2.moveWindow("window", 0, -30)

        button_value = button.waitpressedbutton("assisted")
        if button_value == "mode":
            return

        if button_value == "record":  # take the picture
            model_cursor += 1
            cv2.imshow("window", background)
            cv2.waitKey(20)
            takes_list.append(camera.get_image())

        if button_value == "delete" and len(takes_list) > 0:  # delete the last picture from takes_list
            del (takes_list[-1])
            cv2.waitKey(300)

        if button_value == "save":  # save the cartoon and returns
            if not os.path.exists("/media/PAP/cartoons"):
                cv2.imshow("window", cv2.imread("./save_failed"))
                cv2.waitKey(100)
            else:
                playing.save(takes_list)
                return

        if button_value == "play":  # plays the cartoon
            playing.play(takes_list)
        if button_value == "next":  # move to next image
            if GPIO.input(6) == False:
                model_cursor += 1
            else:
                takes_cursor += 1
            cv2.waitKey(100)

        if button_value == "prev":  # move to previous image
            if GPIO.input(6) == False:
                model_cursor -= 1
            else:
                takes_cursor -= 1
            cv2.waitKey(100)

    # end of while loop, save and return
    if not os.path.exists("/media/PAP/cartoons"):
        cv2.imshow("window", cv2.imread("./save_failed"))
        cv2.waitKey(100)
    else:
        playing.save(takes_list)
        return
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Fri Oct 13 19:20:56 2017

@author: lakshya
"""

import board_generator
import playing

for size in range(23, 26):
    for fruits in range(2, 11):
        board_generator.makeBoard(size, fruits)
        print(size, fruits)
        time_1, score_1, time_2, score_2 = playing.play()
        with open("test.txt", "a") as myfile:
            myfile.write(str(size) + " " + str(fruits) + "\n")
            myfile.write(
                str(time_1) + " " + str(score_1) + " " + str(time_2) + " " +
                str(score_2) + "\n")
예제 #12
0
def QLearning(num_features,
              num_actions,
              params,
              weights,
              results_folder,
              behavior_type,
              train_frames,
              opt_count,
              scene_file_name,
              continue_train=True,
              hitting_reaction_mode=0,
              enlarge_lr=0):
    '''
    The goal of this function is to train a function approximator of Q which can take 
    a state (eight inputs) and predict the Q values of three actions (three outputs)
    '''
    print("Q learning starts...")

    # init variables
    epsilon = 1  # the threshold for choosing a random action over the best action according to a Q value
    if continue_train:
        epsilon = 0.5
    d_epsilon = epsilon / train_frames
    observe_frames = 100  # we train our first model after observing certain frames
    replay = [
    ]  # store tuples of (state, action, reward, next_state) for training
    survive_data = []  # store how long the car survived until die
    loss_log = []  # store the train loss of each model
    score_log = []  # store the train loss of each model
    dist_log = []  # store the train loss of each model
    my_batch_size = params['batch_size']
    buffer = params['buffer']
    assert (
        observe_frames >= my_batch_size
    ), "Error: The number of observed frames is less than the batch size!"

    # create a folder and process the file name for saving trained models
    model_dir = results_folder + 'models-' + behavior_type + '/'
    if not os.path.exists(model_dir):
        os.makedirs(model_dir)
    filename = params_to_filename(params) + '-' + str(
        train_frames) + '-' + str(opt_count)
    model_name = model_dir + filename + '.h5'
    weights_name = model_dir + filename + '_weights.npy'

    pretrained_model = ''
    if continue_train and (opt_count > 1):
        pretrained_model = model_dir + params_to_filename(params) + '-' + str(
            train_frames) + '-' + str(opt_count - 1) + '.h5'

    # init a neural network as an approximator for Q function
    epochCount = 1
    if continue_train:
        epochCount = opt_count
    model = net1(num_features,
                 num_actions,
                 params['nn'],
                 weightsFile=pretrained_model,
                 epochCount=epochCount,
                 enlarge_lr=enlarge_lr)

    # create a new game instance and get the initial state by moving forward
    game_state = carmunk.GameState(weights, scene_file_name)
    _, state, _, _, _ = game_state.frame_step((11))
    #_, state, _ = game_state.frame_step((0,1))

    # let's time it
    start_time = timeit.default_timer()

    expert_count = 0

    stop_status = 0

    # run the frames
    frame_idx = 0
    car_move_count = 0  # track the number of moves the car is making
    car_surivive_move_count = 0  # store the maximum moves the car made before run into something
    print("In QLearning - the total number of training frames is: ",
          train_frames)
    while frame_idx < train_frames:

        if frame_idx % 1000 == 0:
            print("In QLearning - current training frame is: ", frame_idx)

        frame_idx += 1
        car_move_count += 1

        # choose an action.
        # before we reach the number of observing frame (for training) we just sample random actions
        if expert_count > 0:
            action = game_state.get_expert_action()
            expert_count -= 1
        elif random.random() < epsilon or frame_idx < observe_frames:
            action = np.random.randint(0, 25)  # produce action 0, 1, or 2
            #action = np.random.random([2])*2-1
        else:
            # get Q values for each action. Q values are scores associated with each action (there are in total 3 actions)
            qval = model.predict(state, batch_size=1)
            action = (np.argmax(qval))  # get the best action
            #action = model.predict(state, batch_size=1)

        # execute action, receive a reward and get the next state
        reward, next_state, _, _, _ = game_state.frame_step(
            action, hitting_reaction_mode=hitting_reaction_mode)
        if hitting_reaction_mode == 2:  # use expert when hitting
            if next_state[0][-1] == 1:  # hitting
                if expert_count == 0:
                    expert_count = game_state.max_history_num
                else:
                    expert_count = 0

        # store experiences
        replay.append((state, action, reward, next_state))

        # if we're done observing, start training
        if frame_idx > observe_frames:

            # If we've stored enough in our buffer, pop the oldest
            if len(replay) > buffer:  # currently buffer = 50000
                replay.pop(0)

            # sample our experience
            mini_batch = random.sample(
                replay, my_batch_size)  # currently batchSize = 100

            # get training data
            X_train, y_train = process_minibatch(mini_batch, model,
                                                 num_features, num_actions)

            # train a model on this batch
            history = LossHistory()
            model.fit(X_train,
                      y_train,
                      batch_size=my_batch_size,
                      epochs=1,
                      verbose=0,
                      callbacks=[history])

            #outPutW(model.get_weights())

            loss_log.append(history.losses)
            if frame_idx % 100 == 0:
                print("history.losses ", history.losses)

            if frame_idx % 100 == 0:
                temp_fe, aver_score, aver_dist = play(
                    model,
                    weights,
                    play_rounds=10,
                    scene_file_name=scene_file_name)
                if len(score_log) == 0 or (len(score_log) > 0
                                           and aver_score > np.max(score_log)
                                           and aver_dist > np.max(dist_log)):
                    model.save_weights(model_name, overwrite=True)
                    np.save(weights_name, weights)
                    print("Saving model inner: ", model_name)
                score_log.append([aver_score])
                dist_log.append([aver_dist])
            '''
            if frame_idx % 4000 == 0:
                lr = 0.001 / 2**(frame_idx/4000)
                print('===============lr===============', lr)

                #optimizer = keras.optimizers.SGD(learning_rate=0.01, momentum=0.0, nesterov=False)
                #optimizer = keras.optimizers.RMSprop(learning_rate=0.001, rho=0.9)
                optimizer = keras.optimizers.Adam(learning_rate=lr, beta_1=0.9, beta_2=0.999, amsgrad=False)
                #optimizer = keras.optimizers.Adamax(learning_rate=0.002, beta_1=0.9, beta_2=0.999)
                #optimizer = keras.optimizers.Nadam(learning_rate=0.002, beta_1=0.9, beta_2=0.999)
                model.compile(optimizer=optimizer, loss='mse')
            '''

            # diverges, early stop
            '''
            if history.losses[0] > 1000:
                model = net1(num_features, num_actions, params['nn'], weightsFile=pretrained_model)
                model.save_weights(model_name, overwrite=True)
                np.save(weights_name, weights)
                print("Diverges, early stop, loss=", history.losses[0])
                print("Saving model: ", model_name)
                stop_status = -1
                break

            #converges, early stop
            if history.losses[0] < 1e-6:
                model.save_weights(model_name, overwrite=True)
                np.save(weights_name, weights)
                print("Converges, early stop, loss=", history.losses[0])
                print("Saving model: ", model_name)
                stop_status = 1
                break
            '''

        # update the state
        state = next_state

        # decrease epsilon over time to reduce the chance taking a random action over the best action based on Q values
        if epsilon > 0.1 and frame_idx > observe_frames:
            epsilon -= d_epsilon

        # car died, update
        if state[0][-1] == 1:
            # log the car's distance at this frame index
            survive_data.append([frame_idx, car_move_count])

            # update
            if car_move_count > car_surivive_move_count:
                car_surivive_move_count = car_move_count

            # time it
            survive_time = timeit.default_timer() - start_time
            fps = car_move_count / survive_time

            # reset
            car_move_count = 0
            start_time = timeit.default_timer()

        # save the current model
        if frame_idx == train_frames:
            #model.save_weights(model_name, overwrite=True)
            #np.save(weights_name, weights)
            print("Saving model: ", model_name)

    # log results after we're done with all training frames
    log_results(results_folder, filename, survive_data, loss_log, score_log,
                dist_log)
    print("Q learning finished!")
    return model_name, stop_status