强化学习笔记1-Python/OpenAI/TensorFlow/ROS-基础知识

import gym
env = gym.make('CartPole-v0')
env.reset()
for _ in range(1000):
    env.render()
    env.step(env.action_space.sample())

from gym import envs
print(envs.registry.all())

import gym
env = gym.make('CarRacing-v0')
env.reset()
for _ in range(1000):
    env.render()
    env.step(env.action_space.sample())

import gym
env = gym.make('BipedalWalker-v2')
for episode in range(100):
    observation = env.reset()
    # Render the environment on each step 
    for i in range(10000):
        env.render() 
        # we choose action by sampling random action from environment's action space. Every environment has
        # some action space which contains the all possible valid actions and observations,
        action = env.action_space.sample()
        # Then for each step, we will record the observation, reward, done, info
        observation, reward, done, info = env.step(action)  
   # When done is true, we print the time steps taken for the episode and break the current episode.
    if done:
        print("{} timesteps taken for the Episode".format(i+1))
        break

import gym
import universe 
import random

env = gym.make('flashgames.NeonRace-v0')
env.configure(remotes=1) 
observation_n = env.reset()

# Move left
left = [('KeyEvent', 'ArrowUp', True), ('KeyEvent', 'ArrowLeft', True),
         ('KeyEvent', 'ArrowRight', False)]

# Move right
right = [('KeyEvent', 'ArrowUp', True), ('KeyEvent', 'ArrowLeft', False),
         ('KeyEvent', 'ArrowRight', True)]

# Move forward

forward = [('KeyEvent', 'ArrowUp', True), ('KeyEvent', 'ArrowRight', False),
            ('KeyEvent', 'ArrowLeft', False), ('KeyEvent', 'n', True)]

# We use turn variable for deciding whether to turn or not
turn = 0

# We store all the rewards in rewards list
rewards = []

# we will use buffer as some kind of threshold
buffer_size = 100

# We set our initial action has forward i.e our car moves just forward without making any turns
action = forward  

while True:
    turn -= 1
    
    # Let us say initially we take no turn and move forward.
    # First, We will check the value of turn, if it is less than 0
    # then there is no necessity for turning and we just move forward
    
    if turn <= 0:
        action = forward
        turn = 0
    
    action_n = [action for ob in observation_n]
    
    # Then we use env.step() to perform an action (moving forward for now) one-time step
    
    observation_n, reward_n, done_n, info = env.step(action_n)
    
    # store the rewards in the rewards list
    rewards += [reward_n[0]]
     
    # We will generate some random number and if it is less than 0.5 then we will take right, else
    # we will take left and we will store all the rewards obtained by performing each action and
    # based on our rewards we will learn which direction is the best over several timesteps. 
    
    if len(rewards) >= buffer_size:
        mean = sum(rewards)/len(rewards)
        
        if mean == 0:
            turn = 20
            if random.random() < 0.5:
                 action = right
            else:
                action = left
        rewards = []
        
    env.render()