深度强化学习－用卷积神经网络实现AI玩Flappy Bird游戏

In [12]:

    

# 加载游戏中的所有资源，包括图片以及音频
# 调用PyGame包，关于该包的安装，请参看：http://www.pygame.org/wiki/GettingStarted
import pygame

# 需要获取操作系统类型，故而调用sys包
import sys
def load():
    # 加载各类资源的函数
    # 精灵在不同状态下的图片
    PLAYER_PATH = (
            'assets/sprites/redbird-upflap.png',
            'assets/sprites/redbird-midflap.png',
            'assets/sprites/redbird-downflap.png'
    )

    # 背景图地址
    BACKGROUND_PATH = 'assets/sprites/background-black.png'

    # 管道图片所在的地址
    PIPE_PATH = 'assets/sprites/pipe-green.png'

    IMAGES, SOUNDS, HITMASKS = {}, {}, {}

    # 加载成绩数字所需的图片
    IMAGES['numbers'] = (
        pygame.image.load('assets/sprites/0.png').convert_alpha(),
        pygame.image.load('assets/sprites/1.png').convert_alpha(),
        pygame.image.load('assets/sprites/2.png').convert_alpha(),
        pygame.image.load('assets/sprites/3.png').convert_alpha(),
        pygame.image.load('assets/sprites/4.png').convert_alpha(),
        pygame.image.load('assets/sprites/5.png').convert_alpha(),
        pygame.image.load('assets/sprites/6.png').convert_alpha(),
        pygame.image.load('assets/sprites/7.png').convert_alpha(),
        pygame.image.load('assets/sprites/8.png').convert_alpha(),
        pygame.image.load('assets/sprites/9.png').convert_alpha()
    )

    # 加载地面的图片
    IMAGES['base'] = pygame.image.load('assets/sprites/base.png').convert_alpha()

    # 加载声音文件（在不同的系统中，声音文件扩展名不同）
    if 'win' in sys.platform:
        soundExt = '.wav'
    else:
        soundExt = '.ogg'

    SOUNDS['die']    = pygame.mixer.Sound('assets/audio/die' + soundExt)
    SOUNDS['hit']    = pygame.mixer.Sound('assets/audio/hit' + soundExt)
    SOUNDS['point']  = pygame.mixer.Sound('assets/audio/point' + soundExt)
    SOUNDS['swoosh'] = pygame.mixer.Sound('assets/audio/swoosh' + soundExt)
    SOUNDS['wing']   = pygame.mixer.Sound('assets/audio/wing' + soundExt)

    # 加载背景图
    IMAGES['background'] = pygame.image.load(BACKGROUND_PATH).convert()

    # s加载精灵图
    IMAGES['player'] = (
        pygame.image.load(PLAYER_PATH[0]).convert_alpha(),
        pygame.image.load(PLAYER_PATH[1]).convert_alpha(),
        pygame.image.load(PLAYER_PATH[2]).convert_alpha(),
    )

    # 加载水管
    IMAGES['pipe'] = (
        pygame.transform.rotate(
            pygame.image.load(PIPE_PATH).convert_alpha(), 180),
        pygame.image.load(PIPE_PATH).convert_alpha(),
    )

    # 获得水管的蒙板
    HITMASKS['pipe'] = (
        getHitmask(IMAGES['pipe'][0]),
        getHitmask(IMAGES['pipe'][1]),
    )

    # 玩家的蒙板
    HITMASKS['player'] = (
        getHitmask(IMAGES['player'][0]),
        getHitmask(IMAGES['player'][1]),
        getHitmask(IMAGES['player'][2]),
    )

    #返回了三个字典，每个字典的值分别存储图像、声音和蒙板
    return IMAGES, SOUNDS, HITMASKS

def getHitmask(image):
    """根据图像的alpha，获得蒙板"""
    #所谓蒙板就是指将图像中的主体从整个图像中抠出来的技术，从而方便与其它的对象合成到一起
    #蒙板用一个boolean类型的列表来存储
    mask = []
    for x in range(image.get_width()):
        mask.append([])
        for y in range(image.get_height()):
            mask[x].append(bool(image.get_at((x,y))[3]))
    return mask


    

In [13]:

    

# 加载程序所需的包
import numpy as np
import sys
import random
import pygame
import pygame.surfarray as surfarray
from pygame.locals import *
from itertools import cycle

FPS = 30 #帧率
SCREENWIDTH  = 288 #屏幕的宽度
SCREENHEIGHT = 512 #屏幕的高度

pygame.init() #游戏初始化
FPSCLOCK = pygame.time.Clock() #定义程序时钟
SCREEN = pygame.display.set_mode((SCREENWIDTH, SCREENHEIGHT)) #定义屏幕对象
pygame.display.set_caption('Flappy Bird') #设定窗口名称

IMAGES, SOUNDS, HITMASKS = load() #加载游戏资源
PIPEGAPSIZE = 100 # 定义两个水管之间的宽度
BASEY = SCREENHEIGHT * 0.79 #设定基地的高度

# 设定小鸟属性：宽度、高度等
PLAYER_WIDTH = IMAGES['player'][0].get_width()
PLAYER_HEIGHT = IMAGES['player'][0].get_height()

# 设定水管属性：高度、宽度
PIPE_WIDTH = IMAGES['pipe'][0].get_width()
PIPE_HEIGHT = IMAGES['pipe'][0].get_height()

#背景宽度
BACKGROUND_WIDTH = IMAGES['background'].get_width()

PLAYER_INDEX_GEN = cycle([0, 1, 2, 1])

# 游戏模型类
class GameState:
    def __init__(self):
        # 初始化
        # 初始成绩、玩家索引、循环迭代都为0
        self.score = self.playerIndex = self.loopIter = 0
        
        #设定玩家的初始位置
        self.playerx = int(SCREENWIDTH * 0.2)
        self.playery = int((SCREENHEIGHT - PLAYER_HEIGHT) / 2)
        self.basex = 0
        # 地面的初始移位
        self.baseShift = IMAGES['base'].get_width() - BACKGROUND_WIDTH

        # 生成两个随机的水管
        newPipe1 = getRandomPipe()
        newPipe2 = getRandomPipe()
        
        # 设定初始水管的位置x，y坐标
        self.upperPipes = [
            {'x': SCREENWIDTH, 'y': newPipe1[0]['y']},
            {'x': SCREENWIDTH + (SCREENWIDTH / 2), 'y': newPipe2[0]['y']},
        ]
        self.lowerPipes = [
            {'x': SCREENWIDTH, 'y': newPipe1[1]['y']},
            {'x': SCREENWIDTH + (SCREENWIDTH / 2), 'y': newPipe2[1]['y']},
        ]

        # 定义玩家的属性
        self.pipeVelX = -4
        self.playerVelY    =  0    # 小鸟在y轴上的速度，初始设置维playerFlapped
        self.playerMaxVelY =  10   # Y轴上的最大速度, 也就是最大的下降速度
        self.playerMinVelY =  -8   # Y轴向上的最大速度
        self.playerAccY    =   1   # 小鸟往下落的加速度
        self.playerFlapAcc =  -9   # 扇动翅膀的加速度
        self.playerFlapped = False # 玩家是否煽动了翅膀

    def frame_step(self, input_actions):
        # input_actions是一个行动数组，分别存储了0或者1两个动作的激活情况
        # 游戏每一帧的循环
        pygame.event.pump()

        # 每一步的默认回报
        reward = 0.1
        terminal = False

        # 限定每一帧只能做一个动作
        if sum(input_actions) != 1:
            raise ValueError('Multiple input actions!')

        # input_actions[0] == 1: 对应什么都不做
        # input_actions[1] == 1: 对应小鸟煽动了翅膀
        if input_actions[1] == 1:
            # 小鸟煽动翅膀向上
            if self.playery > -2 * PLAYER_HEIGHT:
                self.playerVelY = self.playerFlapAcc
                self.playerFlapped = True
                #SOUNDS['wing'].play()

        # 检查是否通过了管道，如果通过，则增加成绩
        playerMidPos = self.playerx + PLAYER_WIDTH / 2
        for pipe in self.upperPipes:
            pipeMidPos = pipe['x'] + PIPE_WIDTH / 2
            if pipeMidPos <= playerMidPos < pipeMidPos + 4:
                self.score += 1
                #SOUNDS['point'].play()
                reward = 1

        # playerIndex轮换
        if (self.loopIter + 1) % 3 == 0:
            self.playerIndex = next(PLAYER_INDEX_GEN)
        self.loopIter = (self.loopIter + 1) % 30
        self.basex = -((-self.basex + 100) % self.baseShift)

        # 小鸟运动
        if self.playerVelY < self.playerMaxVelY and not self.playerFlapped:
            self.playerVelY += self.playerAccY
        if self.playerFlapped:
            self.playerFlapped = False
        self.playery += min(self.playerVelY, BASEY - self.playery - PLAYER_HEIGHT)
        if self.playery < 0:
            self.playery = 0

        # 管道的移动
        for uPipe, lPipe in zip(self.upperPipes, self.lowerPipes):
            uPipe['x'] += self.pipeVelX
            lPipe['x'] += self.pipeVelX

        # 当管道快到左侧边缘的时候，产生新的管道
        if 0 < self.upperPipes[0]['x'] < 5:
            newPipe = getRandomPipe()
            self.upperPipes.append(newPipe[0])
            self.lowerPipes.append(newPipe[1])

        # 当第一个管道移出屏幕的时候，就把它删除
        if self.upperPipes[0]['x'] < -PIPE_WIDTH:
            self.upperPipes.pop(0)
            self.lowerPipes.pop(0)

        # 检查碰撞
        isCrash= checkCrash({'x': self.playerx, 'y': self.playery,
                             'index': self.playerIndex},
                            self.upperPipes, self.lowerPipes)
        # 如果有碰撞发生，则游戏结束，terminal＝True
        if isCrash:
            #SOUNDS['hit'].play()
            #SOUNDS['die'].play()
            terminal = True
            self.__init__()
            reward = -1

        # 将所有角色都根据每个角色的坐标画到屏幕上
        SCREEN.blit(IMAGES['background'], (0,0))

        for uPipe, lPipe in zip(self.upperPipes, self.lowerPipes):
            SCREEN.blit(IMAGES['pipe'][0], (uPipe['x'], uPipe['y']))
            SCREEN.blit(IMAGES['pipe'][1], (lPipe['x'], lPipe['y']))

        SCREEN.blit(IMAGES['base'], (self.basex, BASEY))
        
        # print score so player overlaps the score
        # showScore(self.score)
        SCREEN.blit(IMAGES['player'][self.playerIndex],
                    (self.playerx, self.playery))

        # 将当前的游戏屏幕生成一个二维画面返回
        image_data = pygame.surfarray.array3d(pygame.display.get_surface())
        pygame.display.update()
        FPSCLOCK.tick(FPS)
        #print self.upperPipes[0]['y'] + PIPE_HEIGHT - int(BASEY * 0.2)
        # 该函数的输出有三个变量：游戏当前帧的游戏画面，当前获得的游戏得分，游戏是否已经结束
        return image_data, reward, terminal
    

def getRandomPipe():
    #随机生成管道的函数
    """returns a randomly generated pipe"""
    # 两个管道之间的竖直间隔从下列数中直接取
    gapYs = [20, 30, 40, 50, 60, 70, 80, 90]
    index = random.randint(0, len(gapYs)-1)
    gapY = gapYs[index]

    #设定新生成管道的位置
    gapY += int(BASEY * 0.2)
    pipeX = SCREENWIDTH + 10

    # 返回管道的坐标
    return [
        {'x': pipeX, 'y': gapY - PIPE_HEIGHT},  # upper pipe
        {'x': pipeX, 'y': gapY + PIPEGAPSIZE},  # lower pipe
    ]


def showScore(score):
    # 在屏幕上直接展示成绩的函数
    """displays score in center of screen"""
    scoreDigits = [int(x) for x in list(str(score))]
    totalWidth = 0 # total width of all numbers to be printed

    for digit in scoreDigits:
        totalWidth += IMAGES['numbers'][digit].get_width()

    Xoffset = (SCREENWIDTH - totalWidth) / 2

    for digit in scoreDigits:
        SCREEN.blit(IMAGES['numbers'][digit], (Xoffset, SCREENHEIGHT * 0.1))
        Xoffset += IMAGES['numbers'][digit].get_width()


def checkCrash(player, upperPipes, lowerPipes):
    # 检测碰撞的函数，基本思路为：将每一个物体都看作是一个矩形区域，然后检查两个矩形区域是否有碰撞
    # 检查碰撞是细到每个对象的图像蒙板级别，而不单纯是看矩形之间的碰撞
    """returns True if player collders with base or pipes."""
    pi = player['index']
    player['w'] = IMAGES['player'][0].get_width()
    player['h'] = IMAGES['player'][0].get_height()

    # 检查小鸟是否碰撞到了地面
    if player['y'] + player['h'] >= BASEY - 1:
        return True
    else:
        # 检查小鸟是否与管道碰撞
        playerRect = pygame.Rect(player['x'], player['y'],
                      player['w'], player['h'])

        for uPipe, lPipe in zip(upperPipes, lowerPipes):
            # 上下管道矩形
            uPipeRect = pygame.Rect(uPipe['x'], uPipe['y'], PIPE_WIDTH, PIPE_HEIGHT)
            lPipeRect = pygame.Rect(lPipe['x'], lPipe['y'], PIPE_WIDTH, PIPE_HEIGHT)

            # 获得每个元素的蒙板
            pHitMask = HITMASKS['player'][pi]
            uHitmask = HITMASKS['pipe'][0]
            lHitmask = HITMASKS['pipe'][1]

            # 检查是否与上下管道相撞
            uCollide = pixelCollision(playerRect, uPipeRect, pHitMask, uHitmask)
            lCollide = pixelCollision(playerRect, lPipeRect, pHitMask, lHitmask)

            if uCollide or lCollide:
                return True

    return False

def pixelCollision(rect1, rect2, hitmask1, hitmask2):
    """在像素级别检查两个物体是否发生碰撞"""
    rect = rect1.clip(rect2)

    if rect.width == 0 or rect.height == 0:
        return False

    # 确定矩形框，并针对矩形框中的每个像素进行循环，查看两个对象是否碰撞
    x1, y1 = rect.x - rect1.x, rect.y - rect1.y
    x2, y2 = rect.x - rect2.x, rect.y - rect2.y

    for x in range(rect.width):
        for y in range(rect.height):
            if hitmask1[x1+x][y1+y] and hitmask2[x2+x][y2+y]:
                return True
    return False


    

In [14]:

    

import matplotlib.pyplot as plt
from IPython.display import display, clear_output

# 新建一个游戏
game = GameState()

fig = plt.figure()
axe = fig.add_subplot(111)
dat = np.zeros((10, 10))
img = axe.imshow(dat)

# 进行100步循环，并将每一帧的画面打印出来
for i in range(100):
    clear_output(wait = True)
    image_data, reward, terminal = game.frame_step([0,1])
    
    image = np.transpose(image_data, (1, 0, 2))
    img.set_data(image)
    img.autoscale()
    display(fig)


    

In [15]:

    

#  导入必需的包
from __future__ import print_function

import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import cv2 #需要安装OpenCV的包
import sys
sys.path.append("game/")
import random
import numpy as np
from collections import deque


# 定义一系列常数，其中，epsilon为每周期随机输出一个动作的概率
GAME = 'bird' # 游戏名称
ACTIONS = 2 # 有效输出动作的个数
GAMMA = 0.99 # 强化学习中未来的衰减率
OBSERVE = 10000. # 训练之前的时间步，需要先观察10000帧
EXPLORE = 3000000. # 退火所需的时间步，所谓的退火就是指随机选择率epsilon逐渐变小
FINAL_EPSILON = 0.0001 # epsilon的最终值
INITIAL_EPSILON = 0.1 # epsilon的初始值
REPLAY_MEMORY = 50000 # 最多记忆多少帧训练数据
BATCH = 32 # 每一个批次的数据记录条数
FRAME_PER_ACTION = 1 # 每间隔多少时间完成一次有效动作的输出


    

In [16]:

    

# 创建一个多层CNN网络，该网络接收的输入为4帧画面，输出为每个可能动作对应的Q函数值
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 第一层卷积，从4通道到32通道，窗口大小8，跳跃间隔4，填空白2
        self.conv1 = nn.Conv2d(4, 32, 8, 4, padding = 2)
        # Pooling层，窗口2*2
        self.pool = nn.MaxPool2d(2, 2)
        # 第二层卷积，从32通道到64通道，窗口大小4，跳跃间隔2，填空白1
        self.conv2 = nn.Conv2d(32, 64, 4, 2, padding = 1)
        # 第二个Pooling层，窗口2＊2，空白1
        self.pool2 = nn.MaxPool2d(2, 2, padding = 1)
        # 第三层卷积层，输入输出通道都是64，填空白为1
        self.conv3 = nn.Conv2d(64, 64, 3, 1, padding = 1)
        
        # 最后有两层全链接层
        self.fc_sz = 1600
        self.fc1 = nn.Linear(self.fc_sz, 256)
        self.fc2 = nn.Linear(256, ACTIONS)

    def forward(self, x):
        # 输入为一个batch的数据，每一个为前后相连的4张图像，每个图像为80*80的大小
        # x的尺寸为：batch_size, 4, 80, 80
        x = self.conv1(x)
        # x的尺寸为：batch_size, 32, 20, 20
        x = F.relu(x)
        x = self.pool(x)
        # x的尺寸为：batch_size, 32, 10, 10
        x = F.relu(self.conv2(x))
        # x的尺寸为：batch_size, 64, 5, 5
        #x = self.pool2(x)
        x = F.relu(self.conv3(x))
        # x的尺寸为：batch_size, 64, 5, 5
        #x = self.pool2(x)
        # 将x设为1600维的向量, batch_size, 1600
        x = x.view(-1, self.fc_sz)
        x = F.relu(self.fc1(x))
        readout = self.fc2(x)
        return readout, x
    def init(self):
        # 初始化所有的网络权重
        self.conv1.weight.data =  torch.abs(0.01 * torch.randn(self.conv1.weight.size()))
        self.conv2.weight.data =  torch.abs(0.01 * torch.randn(self.conv2.weight.size()))
        self.conv3.weight.data =  torch.abs(0.01 * torch.randn(self.conv3.weight.size()))
        self.fc1.weight.data = torch.abs(0.01 * torch.randn(self.fc1.weight.size()))
        self.fc2.weight.data = torch.abs(0.01 * torch.randn(self.fc2.weight.size()))
        self.conv1.bias.data = torch.ones(self.conv1.bias.size()) * 0.01
        self.conv2.bias.data = torch.ones(self.conv2.bias.size()) * 0.01
        self.conv3.bias.data = torch.ones(self.conv3.bias.size()) * 0.01
        self.fc1.bias.data = torch.ones(self.fc1.bias.size()) * 0.01
        self.fc2.bias.data = torch.ones(self.fc2.bias.size()) * 0.01


    

In [7]:

    

# 开始在内存／GPU上定义一个网络
use_cuda = torch.cuda.is_available() #检测本台机器中是否有GPU

# 创建一个神经网络
net = Net()
# 初始化网络权重。之所以自定义初始化过程是为了增加神经网络权重的多样性
net.init()
# 如果有GPU，就把神经网络全部搬到GPU内存中做运算
net = net.cuda() if use_cuda else net

# 定义损失函数为MSE
criterion = nn.MSELoss().cuda() if use_cuda else nn.MSELoss()
# 定义优化器，并设置初始学习率维10^-6
optimizer = torch.optim.Adam(net.parameters(), lr=1e-6 )

# 开启一个游戏进程，开始与游戏引擎通话
game_state = GameState()

# 学习样本的存储区域deque是一个类似于list的存储容器
D = deque()

# 状态打印log记录位置
#a_file = open("logs_" + GAME + "/readout.txt", 'w')
#h_file = open("logs_" + GAME + "/hidden.txt", 'w')

# 将游戏设置为初始状态，并获得一个80*80的游戏湖面
do_nothing = np.zeros(ACTIONS)
do_nothing[0] = 1
x_t, r_0, terminal = game_state.frame_step(do_nothing)
x_t = cv2.cvtColor(cv2.resize(x_t, (80, 80)), cv2.COLOR_BGR2GRAY)
ret, x_t = cv2.threshold(x_t,1,255,cv2.THRESH_BINARY)

# 将初始的游戏画面叠加成4张作为神经网络的初始输入状态s_t
s_t = np.stack((x_t, x_t, x_t, x_t), axis=0)

# 设置初始的epsilon（采取随机行动的概率），并准备训练
epsilon = INITIAL_EPSILON
t = 0


    

In [ ]:

    

# 记录每轮平均得分的容器
scores = []
all_turn_scores = []
while "flappy bird" != "angry bird":
    # 开始游戏循环
    ######################################################
    ##########首先，按照贪婪策略选择一个行动 ##################
    s = Variable(torch.from_numpy(s_t).type(torch.FloatTensor))
    s = s.cuda() if use_cuda else s
    s = s.view(-1, s.size()[0], s.size()[1], s.size()[2])
    # 获取当前时刻的游戏画面，输入到神经网络中
    readout, h_fc1 = net(s)
    # 神经网络产生的输出为readout：选择每一个行动的预期Q值
    readout = readout.cpu() if use_cuda else readout
    # readout为一个二维向量，分别对应每一个动作的预期Q值
    readout_t = readout.data.numpy()[0]

    # 按照epsilon贪婪策略产生小鸟的行动，即以epsilon的概率随机输出行动或者以
    # 1-epsilon的概率按照预期输出最大的Q值给出行动
    a_t = np.zeros([ACTIONS])
    action_index = 0
    if t % FRAME_PER_ACTION == 0:
        # 如果当前帧可以行动，则
        if random.random() <= epsilon:
            # 产生随机行动
            #print("----------Random Action----------")
            action_index = random.randrange(ACTIONS)
        else:
            # 选择神经网络判断的预期Q最大的行动
            action_index = np.argmax(readout_t)
        a_t[action_index] = 1
    else:
        a_t[0] = 1 # do nothing

    # 模拟退火：让epsilon开始降低
    if epsilon > FINAL_EPSILON and t > OBSERVE:
        epsilon -= (INITIAL_EPSILON - FINAL_EPSILON) / EXPLORE

    ######################################################################### 
    ##########其次，将选择好的行动输入给游戏引擎，并得到下一帧的状态 ################### 
    x_t1_colored, r_t, terminal = game_state.frame_step(a_t)
    # 返回的x_t1_colored为游戏画面，r_t为本轮的得分，terminal为游戏在本轮是否已经结束
    
    # 记录一下每一步的成绩
    scores.append(r_t)
    if terminal:
        # 当游戏结束的时候，计算一下本轮的总成绩，并将总成绩存储到all_turn_scores中
        all_turn_scores.append(sum(scores))
        scores = []
    
    # 对游戏的原始画面做相应的处理，从而变成一张80*80的，朴素的（无背景画面）的图
    x_t1 = cv2.cvtColor(cv2.resize(x_t1_colored, (80, 80)), cv2.COLOR_BGR2GRAY)
    ret, x_t1 = cv2.threshold(x_t1, 1, 255, cv2.THRESH_BINARY)
    x_t1 = np.reshape(x_t1, (1, 80, 80))
    # 将当前帧的画面和前三帧的画面合并起来作为Agent获得的环境反馈结果
    s_t1 = np.append(x_t1, s_t[:3, :, :], axis=0)
    # 生成一个训练数据，分别将本帧的输入画面s_t,本帧的行动a_t，得到的环境回报r_t以及环境被转换的新状态s_t1存到D中
    D.append((s_t, a_t, r_t, s_t1, terminal))
    if len(D) > REPLAY_MEMORY:
        # 如果D中的元素已满，则扔掉最老的一条训练数据
        D.popleft()

    ######################################################################### 
    ##########最后，当运行周期超过一定次数后开始训练神经网络 ################### 
    if t > OBSERVE:
        # 从D中随机采样出一个batch的训练数据
        minibatch = random.sample(D, BATCH)
        optimizer.zero_grad()

        # 将这个batch中的s变量都分别存放到列表中
        s_j_batch = [d[0] for d in minibatch]
        a_batch = [d[1] for d in minibatch]
        r_batch = [d[2] for d in minibatch]
        s_j1_batch = [d[3] for d in minibatch]

        # 接下来，要根据s_j1_batch，神经网络给出预估的未来Q值
        
        s = Variable(torch.FloatTensor(np.array(s_j1_batch, dtype=float)))
        s = s.cuda() if use_cuda else s
        readout, h_fc1 = net(s)
        readout = readout.cpu() if use_cuda else readout
        readout_j1_batch = readout.data.numpy()
        # readout_j1_batch存储了一个minibatch中的所有未来一步的Q预估值
        # 根据Q的预估值，当前的反馈r，以及游戏是否结束，更新待训练的目标函数值
        y_batch = []
        for i in range(0, len(minibatch)):
            terminal = minibatch[i][4]
            # 当游戏结束的时候，则用环境的反馈作为目标，否则用下一状态的Q值＋本期的环境反馈
            if terminal:
                y_batch.append(r_batch[i])
            else:
                y_batch.append(r_batch[i] + GAMMA * np.max(readout_j1_batch[i]))

        # 开始梯度更新
        y = Variable(torch.FloatTensor(y_batch))
        a = Variable(torch.FloatTensor(a_batch))
        s = Variable(torch.FloatTensor(np.array(s_j_batch, dtype=float)))
        if use_cuda:
            y = y.cuda()
            a = a.cuda()
            s = s.cuda()
        # 计算s_j_batch的Q值
        readout, h_fc1 = net(s)
        readout_action = readout.mul(a).sum(1)
        # 根据s_j_batch下所选择的预估Q和目标y的Q值的差来作为损失函数训练网络
        loss = criterion(readout_action, y)
        loss.backward()
        optimizer.step()
        if t % 1000 == 0:
            print('损失函数：', loss)
       

    # 将状态更新一次，时间步＋1
    s_t = s_t1
    t += 1

    # 每隔 10000 次循环，存储一下网络
    if t % 10000 == 0:
        torch.save(net, 'saving_nets/' + GAME + '-dqn' + str(t) + '.txt')
    
    # 状态信息的转化，基本分为Observe，explore和train三个阶段
    # Observe没有训练，explore开始训练，并且开始模拟退火，train模拟退火结束
    state = ""
    if t <= OBSERVE:
        state = "observe"
    elif t > OBSERVE and t <= OBSERVE + EXPLORE:
        state = "explore"
    else:
        state = "train"
        
    # 打印当前运行的一些基本数据，分别输出到屏幕以及log文件中
    if t % 1000 == 0:
        sss = "时间步 {}/ 状态 {}/ Epsilon {:.2f}/ 行动 {}/ 奖励 {}/ Q_MAX {:e}/ 轮得分 {:.2f}".format(
            t, state, epsilon, action_index, r_t, np.max(readout_t), np.mean(all_turn_scores[-1000:]))
        print(sss)
        f = open('log_file.txt', 'a')
        f.write(sss + '\n')
        f.close()
    # write info to files


    

    




时间步 1000/ 状态 observe/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.789328e+04/ 轮得分 1.38
时间步 2000/ 状态 observe/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.960289e+04/ 轮得分 1.43
时间步 3000/ 状态 observe/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.579410e+04/ 轮得分 1.38
时间步 4000/ 状态 observe/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.554549e+04/ 轮得分 1.37
时间步 5000/ 状态 observe/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.300679e+04/ 轮得分 1.35
时间步 6000/ 状态 observe/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.880158e+04/ 轮得分 1.38
时间步 7000/ 状态 observe/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.622109e+04/ 轮得分 1.34
时间步 8000/ 状态 observe/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.716134e+04/ 轮得分 1.33
时间步 9000/ 状态 observe/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 6.387247e+04/ 轮得分 1.30






    




/home/jake/anaconda/envs/learning_pytorch/lib/python3.6/site-packages/torch/serialization.py:147: UserWarning: Couldn't retrieve source code for container of type Net. It won't be checked for correctness upon loading.
  "type " + obj.__name__ + ". It won't be checked "






    




时间步 10000/ 状态 observe/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.724834e+04/ 轮得分 1.29
时间步 11000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.786650e+04/ 轮得分 1.35
损失函数： Variable containing:
 1.0755e+08
[torch.FloatTensor of size 1]

时间步 12000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.243400e+04/ 轮得分 1.46
损失函数： Variable containing:
 6.7522e+07
[torch.FloatTensor of size 1]

时间步 13000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.779126e+04/ 轮得分 1.56
损失函数： Variable containing:
 3.6268e+07
[torch.FloatTensor of size 1]

时间步 14000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.144210e+04/ 轮得分 1.65
损失函数： Variable containing:
 1.9996e+07
[torch.FloatTensor of size 1]

时间步 15000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.603308e+04/ 轮得分 1.74
损失函数： Variable containing:
 1.3511e+07
[torch.FloatTensor of size 1]

时间步 16000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.198958e+04/ 轮得分 1.82
损失函数： Variable containing:
 1.3862e+06
[torch.FloatTensor of size 1]

时间步 17000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.833563e+04/ 轮得分 1.89
损失函数： Variable containing:
1.00000e+05 *
  7.1176
[torch.FloatTensor of size 1]

时间步 18000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.518621e+04/ 轮得分 1.96
损失函数： Variable containing:
1.00000e+05 *
  5.4290
[torch.FloatTensor of size 1]

时间步 19000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.225043e+04/ 轮得分 2.02
损失函数： Variable containing:
1.00000e+06 *
  2.9913
[torch.FloatTensor of size 1]

时间步 20000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 9.995000e+03/ 轮得分 2.08
损失函数： Variable containing:
1.00000e+06 *
  2.1189
[torch.FloatTensor of size 1]

时间步 21000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 8.255901e+03/ 轮得分 2.14
损失函数： Variable containing:
1.00000e+06 *
  6.6139
[torch.FloatTensor of size 1]

时间步 22000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 6.854616e+03/ 轮得分 2.19
损失函数： Variable containing:
 77207.2578
[torch.FloatTensor of size 1]

时间步 23000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 5.447451e+03/ 轮得分 2.24
损失函数： Variable containing:
 86194.8594
[torch.FloatTensor of size 1]

时间步 24000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.343163e+03/ 轮得分 2.29
损失函数： Variable containing:
1.00000e+05 *
  7.8751
[torch.FloatTensor of size 1]

时间步 25000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.590922e+03/ 轮得分 2.33
损失函数： Variable containing:
1.00000e+05 *
  5.0939
[torch.FloatTensor of size 1]

时间步 26000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.895208e+03/ 轮得分 2.37
损失函数： Variable containing:
 10275.3477
[torch.FloatTensor of size 1]

时间步 27000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.250842e+03/ 轮得分 2.41
损失函数： Variable containing:
1.00000e+05 *
  1.1388
[torch.FloatTensor of size 1]

时间步 28000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.765346e+03/ 轮得分 2.45
损失函数： Variable containing:
1.00000e+05 *
  2.4153
[torch.FloatTensor of size 1]

时间步 29000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.391781e+03/ 轮得分 2.49
损失函数： Variable containing:
 3148.0225
[torch.FloatTensor of size 1]

时间步 30000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.048499e+03/ 轮得分 2.52
损失函数： Variable containing:
 46311.5820
[torch.FloatTensor of size 1]

时间步 31000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 8.054719e+02/ 轮得分 2.55
损失函数： Variable containing:
 747.2329
[torch.FloatTensor of size 1]

时间步 32000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 6.096006e+02/ 轮得分 2.59
损失函数： Variable containing:
 657.3144
[torch.FloatTensor of size 1]

时间步 33000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.688770e+02/ 轮得分 2.62
损失函数： Variable containing:
 8019.3076
[torch.FloatTensor of size 1]

时间步 34000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.460710e+02/ 轮得分 2.64
损失函数： Variable containing:
 7004.6172
[torch.FloatTensor of size 1]

时间步 35000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.419233e+02/ 轮得分 2.67
损失函数： Variable containing:
 71.2092
[torch.FloatTensor of size 1]

时间步 36000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.821465e+02/ 轮得分 2.70
损失函数： Variable containing:
 47.2320
[torch.FloatTensor of size 1]

时间步 37000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.264676e+02/ 轮得分 2.70
损失函数： Variable containing:
 498.9266
[torch.FloatTensor of size 1]

时间步 38000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 8.441042e+01/ 轮得分 2.71
损失函数： Variable containing:
 494.3927
[torch.FloatTensor of size 1]

时间步 39000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 6.708031e+01/ 轮得分 2.75
损失函数： Variable containing:
 261.8817
[torch.FloatTensor of size 1]

时间步 40000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 5.352489e+01/ 轮得分 2.80
损失函数： Variable containing:
 202.3986
[torch.FloatTensor of size 1]

时间步 41000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.568374e+01/ 轮得分 2.85
损失函数： Variable containing:
 95.0952
[torch.FloatTensor of size 1]

时间步 42000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.395356e+01/ 轮得分 2.90
损失函数： Variable containing:
 5.7271
[torch.FloatTensor of size 1]

时间步 43000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.084338e+01/ 轮得分 2.95
损失函数： Variable containing:
 4.2941
[torch.FloatTensor of size 1]

时间步 44000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.098578e+01/ 轮得分 3.01
损失函数： Variable containing:
 7.2791
[torch.FloatTensor of size 1]

时间步 45000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.971716e+01/ 轮得分 3.06
损失函数： Variable containing:
 20.4865
[torch.FloatTensor of size 1]

时间步 46000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.976136e+01/ 轮得分 3.11
损失函数： Variable containing:
 53.0495
[torch.FloatTensor of size 1]

时间步 47000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.814162e+01/ 轮得分 3.16
损失函数： Variable containing:
 3.1703
[torch.FloatTensor of size 1]

时间步 48000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.610117e+01/ 轮得分 3.22
损失函数： Variable containing:
 52.9959
[torch.FloatTensor of size 1]

时间步 49000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.462875e+01/ 轮得分 3.26
损失函数： Variable containing:
 12.3789
[torch.FloatTensor of size 1]

时间步 50000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.891937e+01/ 轮得分 3.31
损失函数： Variable containing:
 47.3241
[torch.FloatTensor of size 1]

时间步 51000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.962435e+01/ 轮得分 3.37
损失函数： Variable containing:
 4.7586
[torch.FloatTensor of size 1]

时间步 52000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 5.353829e+01/ 轮得分 3.42
损失函数： Variable containing:
 16.6850
[torch.FloatTensor of size 1]

时间步 53000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 6.674519e+01/ 轮得分 3.47
损失函数： Variable containing:
 3.0565
[torch.FloatTensor of size 1]

时间步 54000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 6.820251e+01/ 轮得分 3.52
损失函数： Variable containing:
 15.8950
[torch.FloatTensor of size 1]

时间步 55000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 7.362189e+01/ 轮得分 3.58
损失函数： Variable containing:
 22.8050
[torch.FloatTensor of size 1]

时间步 56000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 8.366651e+01/ 轮得分 3.64
损失函数： Variable containing:
 348.9384
[torch.FloatTensor of size 1]

时间步 57000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 8.478074e+01/ 轮得分 3.70
损失函数： Variable containing:
 167.5469
[torch.FloatTensor of size 1]

时间步 58000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.023609e+02/ 轮得分 3.75
损失函数： Variable containing:
 240.6999
[torch.FloatTensor of size 1]

时间步 59000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.046865e+02/ 轮得分 3.80
损失函数： Variable containing:
 19.3865
[torch.FloatTensor of size 1]

时间步 60000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.092857e+02/ 轮得分 3.85
损失函数： Variable containing:
 249.7832
[torch.FloatTensor of size 1]

时间步 61000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 -1/ Q_MAX 8.944297e+01/ 轮得分 3.85
损失函数： Variable containing:
 28.0654
[torch.FloatTensor of size 1]

时间步 62000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.255294e+02/ 轮得分 3.84
损失函数： Variable containing:
 50.3773
[torch.FloatTensor of size 1]

时间步 63000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.107612e+02/ 轮得分 3.83
损失函数： Variable containing:
 141.6721
[torch.FloatTensor of size 1]

时间步 64000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 8.338038e+01/ 轮得分 3.83
损失函数： Variable containing:
 66.0139
[torch.FloatTensor of size 1]

时间步 65000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 7.284401e+01/ 轮得分 3.84
损失函数： Variable containing:
 29.7879
[torch.FloatTensor of size 1]

时间步 66000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 6.003176e+01/ 轮得分 3.84
损失函数： Variable containing:
 16.9496
[torch.FloatTensor of size 1]

时间步 67000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.286507e+01/ 轮得分 3.84
损失函数： Variable containing:
 21.4764
[torch.FloatTensor of size 1]

时间步 68000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.743182e+01/ 轮得分 3.84
损失函数： Variable containing:
 2.0106
[torch.FloatTensor of size 1]

时间步 69000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.269907e+00/ 轮得分 3.84
损失函数： Variable containing:
 2.1155
[torch.FloatTensor of size 1]

时间步 70000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.312591e+01/ 轮得分 3.85
损失函数： Variable containing:
 5.7124
[torch.FloatTensor of size 1]

时间步 71000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX -4.687382e+00/ 轮得分 3.85
损失函数： Variable containing:
 1.4033
[torch.FloatTensor of size 1]

时间步 72000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.221955e+01/ 轮得分 3.86
损失函数： Variable containing:
 1.1319
[torch.FloatTensor of size 1]

时间步 73000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.100258e+01/ 轮得分 3.86
损失函数： Variable containing:
 0.8453
[torch.FloatTensor of size 1]

时间步 74000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.053807e+00/ 轮得分 3.86
损失函数： Variable containing:
 0.7426
[torch.FloatTensor of size 1]

时间步 75000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.739706e+00/ 轮得分 3.86
损失函数： Variable containing:
 0.2020
[torch.FloatTensor of size 1]

时间步 76000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 6.390764e+00/ 轮得分 3.86
损失函数： Variable containing:
 0.1148
[torch.FloatTensor of size 1]

时间步 77000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.198420e+00/ 轮得分 3.87
损失函数： Variable containing:
 0.1705
[torch.FloatTensor of size 1]

时间步 78000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 5.760870e+00/ 轮得分 3.86
损失函数： Variable containing:
 0.9645
[torch.FloatTensor of size 1]

时间步 79000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.814322e+00/ 轮得分 3.85
损失函数： Variable containing:
 0.4021
[torch.FloatTensor of size 1]

时间步 80000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.189880e+00/ 轮得分 3.85
损失函数： Variable containing:
 0.2801
[torch.FloatTensor of size 1]

时间步 81000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.399968e+00/ 轮得分 3.86
损失函数： Variable containing:
1.00000e-02 *
  5.2248
[torch.FloatTensor of size 1]

时间步 82000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 5.144660e+00/ 轮得分 3.86
损失函数： Variable containing:
 0.1148
[torch.FloatTensor of size 1]

时间步 83000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.949995e+00/ 轮得分 3.87
损失函数： Variable containing:
1.00000e-02 *
  2.5818
[torch.FloatTensor of size 1]

时间步 84000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.363310e+00/ 轮得分 3.88
损失函数： Variable containing:
1.00000e-02 *
  2.5495
[torch.FloatTensor of size 1]

时间步 85000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 1/ Q_MAX 7.276160e-01/ 轮得分 3.89
损失函数： Variable containing:
1.00000e-02 *
  4.1538
[torch.FloatTensor of size 1]

时间步 86000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.814284e+00/ 轮得分 3.92
损失函数： Variable containing:
1.00000e-02 *
  5.3967
[torch.FloatTensor of size 1]

时间步 87000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.604836e+00/ 轮得分 3.95
损失函数： Variable containing:
1.00000e-02 *
  2.6371
[torch.FloatTensor of size 1]

时间步 88000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX -1.035060e+00/ 轮得分 3.98
损失函数： Variable containing:
1.00000e-02 *
  2.4050
[torch.FloatTensor of size 1]

时间步 89000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.793057e+00/ 轮得分 4.01
损失函数： Variable containing:
1.00000e-02 *
  3.2335
[torch.FloatTensor of size 1]

时间步 90000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.529938e+00/ 轮得分 4.03
损失函数： Variable containing:
1.00000e-02 *
  4.2902
[torch.FloatTensor of size 1]

时间步 91000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 6.761954e-01/ 轮得分 4.06
损失函数： Variable containing:
1.00000e-02 *
  1.5530
[torch.FloatTensor of size 1]

时间步 92000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.656382e+00/ 轮得分 4.08
损失函数： Variable containing:
1.00000e-02 *
  6.3006
[torch.FloatTensor of size 1]

时间步 93000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.745706e-01/ 轮得分 4.09
损失函数： Variable containing:
1.00000e-02 *
  1.0889
[torch.FloatTensor of size 1]

时间步 94000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.506513e+00/ 轮得分 4.11
损失函数： Variable containing:
1.00000e-03 *
  6.2967
[torch.FloatTensor of size 1]

时间步 95000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.688650e+00/ 轮得分 4.12
损失函数： Variable containing:
1.00000e-03 *
  7.4175
[torch.FloatTensor of size 1]

时间步 96000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.699875e+00/ 轮得分 4.13
损失函数： Variable containing:
1.00000e-03 *
  7.6484
[torch.FloatTensor of size 1]

时间步 97000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.663979e+00/ 轮得分 4.14
损失函数： Variable containing:
1.00000e-03 *
  6.5728
[torch.FloatTensor of size 1]

时间步 98000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.096987e+00/ 轮得分 4.15
损失函数： Variable containing:
1.00000e-02 *
  1.3432
[torch.FloatTensor of size 1]

时间步 99000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.527166e+00/ 轮得分 4.16
损失函数： Variable containing:
1.00000e-02 *
  1.4896
[torch.FloatTensor of size 1]

时间步 100000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX -9.469342e-02/ 轮得分 4.18
损失函数： Variable containing:
1.00000e-02 *
  2.4667
[torch.FloatTensor of size 1]

时间步 101000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.791050e+00/ 轮得分 4.19
损失函数： Variable containing:
1.00000e-03 *
  5.7743
[torch.FloatTensor of size 1]

时间步 102000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX -5.529668e-01/ 轮得分 4.20
损失函数： Variable containing:
1.00000e-03 *
  2.1421
[torch.FloatTensor of size 1]

时间步 103000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.838141e+00/ 轮得分 4.21
损失函数： Variable containing:
1.00000e-02 *
  1.1016
[torch.FloatTensor of size 1]

时间步 104000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.039119e+00/ 轮得分 4.22
损失函数： Variable containing:
1.00000e-03 *
  4.5993
[torch.FloatTensor of size 1]

时间步 105000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.899951e+00/ 轮得分 4.23
损失函数： Variable containing:
 0.1032
[torch.FloatTensor of size 1]

时间步 106000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.402649e-01/ 轮得分 4.24
损失函数： Variable containing:
1.00000e-02 *
  3.5755
[torch.FloatTensor of size 1]

时间步 107000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX -2.879517e-01/ 轮得分 4.25
损失函数： Variable containing:
1.00000e-02 *
  1.0033
[torch.FloatTensor of size 1]

时间步 108000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX -1.507035e-01/ 轮得分 4.26
损失函数： Variable containing:
1.00000e-03 *
  6.2774
[torch.FloatTensor of size 1]

时间步 109000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.459848e+00/ 轮得分 4.26
损失函数： Variable containing:
1.00000e-02 *
  1.5312
[torch.FloatTensor of size 1]

时间步 110000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.202499e+00/ 轮得分 4.27
损失函数： Variable containing:
 0.1790
[torch.FloatTensor of size 1]

时间步 111000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 6.710559e-01/ 轮得分 4.27
损失函数： Variable containing:
1.00000e-02 *
  5.0085
[torch.FloatTensor of size 1]

时间步 112000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 8.362563e-01/ 轮得分 4.28
损失函数： Variable containing:
1.00000e-02 *
  1.3787
[torch.FloatTensor of size 1]

时间步 113000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX -6.823626e-01/ 轮得分 4.30
损失函数： Variable containing:
1.00000e-02 *
  2.9275
[torch.FloatTensor of size 1]

时间步 114000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 9.727315e-01/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-03 *
  3.0155
[torch.FloatTensor of size 1]

时间步 115000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.874149e-01/ 轮得分 4.33
损失函数： Variable containing:
1.00000e-03 *
  9.7487
[torch.FloatTensor of size 1]

时间步 116000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.660152e+00/ 轮得分 4.35
损失函数： Variable containing:
1.00000e-03 *
  6.9248
[torch.FloatTensor of size 1]

时间步 117000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.841635e+00/ 轮得分 4.36
损失函数： Variable containing:
1.00000e-02 *
  3.6248
[torch.FloatTensor of size 1]

时间步 118000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.970870e+00/ 轮得分 4.36
损失函数： Variable containing:
1.00000e-03 *
  4.0209
[torch.FloatTensor of size 1]

时间步 119000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.609194e+00/ 轮得分 4.37
损失函数： Variable containing:
1.00000e-02 *
  3.2891
[torch.FloatTensor of size 1]

时间步 120000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 6.224102e-01/ 轮得分 4.37
损失函数： Variable containing:
 0.1128
[torch.FloatTensor of size 1]

时间步 121000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 7.627485e-01/ 轮得分 4.38
损失函数： Variable containing:
1.00000e-03 *
  2.6741
[torch.FloatTensor of size 1]

时间步 122000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.028872e+00/ 轮得分 4.39
损失函数： Variable containing:
1.00000e-03 *
  2.0903
[torch.FloatTensor of size 1]

时间步 123000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.102388e+00/ 轮得分 4.39
损失函数： Variable containing:
1.00000e-02 *
  2.0795
[torch.FloatTensor of size 1]

时间步 124000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 5.943851e-01/ 轮得分 4.39
损失函数： Variable containing:
1.00000e-03 *
  5.2017
[torch.FloatTensor of size 1]

时间步 125000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX -2.865220e-02/ 轮得分 4.38
损失函数： Variable containing:
1.00000e-02 *
  3.2318
[torch.FloatTensor of size 1]

时间步 126000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.694938e+00/ 轮得分 4.39
损失函数： Variable containing:
1.00000e-03 *
  9.6686
[torch.FloatTensor of size 1]

时间步 127000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.512997e+00/ 轮得分 4.40
损失函数： Variable containing:
1.00000e-02 *
  2.0560
[torch.FloatTensor of size 1]

时间步 128000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.686864e+00/ 轮得分 4.40
损失函数： Variable containing:
1.00000e-02 *
  6.0722
[torch.FloatTensor of size 1]

时间步 129000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.340488e+00/ 轮得分 4.41
损失函数： Variable containing:
 0.2058
[torch.FloatTensor of size 1]

时间步 130000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.302524e+00/ 轮得分 4.42
损失函数： Variable containing:
1.00000e-03 *
  5.0910
[torch.FloatTensor of size 1]

时间步 131000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.246070e+00/ 轮得分 4.43
损失函数： Variable containing:
1.00000e-02 *
  2.2069
[torch.FloatTensor of size 1]

时间步 132000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.984652e+00/ 轮得分 4.44
损失函数： Variable containing:
1.00000e-03 *
  7.4787
[torch.FloatTensor of size 1]

时间步 133000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.506449e+00/ 轮得分 4.46
损失函数： Variable containing:
1.00000e-03 *
  7.0326
[torch.FloatTensor of size 1]

时间步 134000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX -1.353080e-01/ 轮得分 4.48
损失函数： Variable containing:
1.00000e-02 *
  7.3336
[torch.FloatTensor of size 1]

时间步 135000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.203640e+00/ 轮得分 4.49
损失函数： Variable containing:
1.00000e-03 *
  5.9630
[torch.FloatTensor of size 1]

时间步 136000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.495420e-01/ 轮得分 4.48
损失函数： Variable containing:
1.00000e-02 *
  5.7573
[torch.FloatTensor of size 1]

时间步 137000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.666026e+00/ 轮得分 4.49
损失函数： Variable containing:
1.00000e-02 *
  7.6442
[torch.FloatTensor of size 1]

时间步 138000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.932020e+00/ 轮得分 4.49
损失函数： Variable containing:
1.00000e-02 *
  1.9977
[torch.FloatTensor of size 1]

时间步 139000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.486425e+00/ 轮得分 4.48
损失函数： Variable containing:
1.00000e-02 *
  1.1729
[torch.FloatTensor of size 1]

时间步 140000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.126147e+00/ 轮得分 4.47
损失函数： Variable containing:
1.00000e-02 *
  2.3859
[torch.FloatTensor of size 1]

时间步 141000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.532912e+00/ 轮得分 4.47
损失函数： Variable containing:
 0.7774
[torch.FloatTensor of size 1]

时间步 142000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX -3.039415e-01/ 轮得分 4.47
损失函数： Variable containing:
1.00000e-03 *
  6.7305
[torch.FloatTensor of size 1]

时间步 143000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.256190e+00/ 轮得分 4.45
损失函数： Variable containing:
1.00000e-02 *
  2.4966
[torch.FloatTensor of size 1]

时间步 144000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.429469e+00/ 轮得分 4.44
损失函数： Variable containing:
1.00000e-03 *
  6.7553
[torch.FloatTensor of size 1]

时间步 145000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.814259e-01/ 轮得分 4.43
损失函数： Variable containing:
1.00000e-03 *
  6.3115
[torch.FloatTensor of size 1]

时间步 146000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.780546e+00/ 轮得分 4.42
损失函数： Variable containing:
1.00000e-02 *
  6.3230
[torch.FloatTensor of size 1]

时间步 147000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.267040e+00/ 轮得分 4.43
损失函数： Variable containing:
1.00000e-02 *
  1.0259
[torch.FloatTensor of size 1]

时间步 148000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.189147e+00/ 轮得分 4.43
损失函数： Variable containing:
 0.4879
[torch.FloatTensor of size 1]

时间步 149000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.623715e+00/ 轮得分 4.41
损失函数： Variable containing:
1.00000e-02 *
  5.4002
[torch.FloatTensor of size 1]

时间步 150000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 9.679124e-01/ 轮得分 4.41
损失函数： Variable containing:
1.00000e-02 *
  5.8512
[torch.FloatTensor of size 1]

时间步 151000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.222498e+00/ 轮得分 4.40
损失函数： Variable containing:
1.00000e-03 *
  8.9909
[torch.FloatTensor of size 1]

时间步 152000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 4.125794e+00/ 轮得分 4.41
损失函数： Variable containing:
1.00000e-02 *
  9.4690
[torch.FloatTensor of size 1]

时间步 153000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.204271e+00/ 轮得分 4.39
损失函数： Variable containing:
1.00000e-03 *
  5.8734
[torch.FloatTensor of size 1]

时间步 154000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.956479e+00/ 轮得分 4.38
损失函数： Variable containing:
 0.1933
[torch.FloatTensor of size 1]

时间步 155000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.781631e+00/ 轮得分 4.39
损失函数： Variable containing:
1.00000e-03 *
  4.0909
[torch.FloatTensor of size 1]

时间步 156000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.455359e+00/ 轮得分 4.38
损失函数： Variable containing:
1.00000e-03 *
  5.3545
[torch.FloatTensor of size 1]

时间步 157000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 3.312284e+00/ 轮得分 4.38
损失函数： Variable containing:
1.00000e-03 *
  2.6288
[torch.FloatTensor of size 1]

时间步 158000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 2.129047e+00/ 轮得分 4.38
损失函数： Variable containing:
1.00000e-03 *
  3.6188
[torch.FloatTensor of size 1]

时间步 159000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.681695e+00/ 轮得分 4.36
损失函数： Variable containing:
1.00000e-02 *
  8.3118
[torch.FloatTensor of size 1]

时间步 160000/ 状态 explore/ Epsilon 0.10/ 行动 0/ 奖励 0.1/ Q_MAX 1.315078e+00/ 轮得分 4.36
损失函数： Variable containing:
1.00000e-02 *
  6.4334
[torch.FloatTensor of size 1]

时间步 161000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX -1.798764e-01/ 轮得分 4.37
损失函数： Variable containing:
1.00000e-03 *
  6.4195
[torch.FloatTensor of size 1]

时间步 162000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.240698e+00/ 轮得分 4.38
损失函数： Variable containing:
 0.1593
[torch.FloatTensor of size 1]

时间步 163000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 7.966970e-01/ 轮得分 4.36
损失函数： Variable containing:
1.00000e-03 *
  5.0495
[torch.FloatTensor of size 1]

时间步 164000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.686190e+00/ 轮得分 4.36
损失函数： Variable containing:
1.00000e-03 *
  4.9332
[torch.FloatTensor of size 1]

时间步 165000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.751555e+00/ 轮得分 4.36
损失函数： Variable containing:
1.00000e-03 *
  5.2188
[torch.FloatTensor of size 1]

时间步 166000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.441380e+00/ 轮得分 4.36
损失函数： Variable containing:
1.00000e-02 *
  5.7108
[torch.FloatTensor of size 1]

时间步 167000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.056310e+00/ 轮得分 4.36
损失函数： Variable containing:
1.00000e-02 *
  2.5508
[torch.FloatTensor of size 1]

时间步 168000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.665968e+00/ 轮得分 4.37
损失函数： Variable containing:
 0.2426
[torch.FloatTensor of size 1]

时间步 169000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.182119e+00/ 轮得分 4.35
损失函数： Variable containing:
1.00000e-03 *
  3.6885
[torch.FloatTensor of size 1]

时间步 170000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.567266e+00/ 轮得分 4.35
损失函数： Variable containing:
1.00000e-02 *
  3.2598
[torch.FloatTensor of size 1]

时间步 171000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.283438e+00/ 轮得分 4.36
损失函数： Variable containing:
1.00000e-02 *
  2.2776
[torch.FloatTensor of size 1]

时间步 172000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.451678e+00/ 轮得分 4.35
损失函数： Variable containing:
1.00000e-02 *
  1.4749
[torch.FloatTensor of size 1]

时间步 173000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.256110e+00/ 轮得分 4.34
损失函数： Variable containing:
1.00000e-02 *
  1.0106
[torch.FloatTensor of size 1]

时间步 174000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.975239e+00/ 轮得分 4.34
损失函数： Variable containing:
1.00000e-02 *
  1.0172
[torch.FloatTensor of size 1]

时间步 175000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.746051e+00/ 轮得分 4.34
损失函数： Variable containing:
1.00000e-02 *
  2.8971
[torch.FloatTensor of size 1]

时间步 176000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.142635e-02/ 轮得分 4.34
损失函数： Variable containing:
1.00000e-02 *
  4.1478
[torch.FloatTensor of size 1]

时间步 177000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.974587e+00/ 轮得分 4.35
损失函数： Variable containing:
1.00000e-02 *
  3.9876
[torch.FloatTensor of size 1]

时间步 178000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 8.009560e-01/ 轮得分 4.36
损失函数： Variable containing:
 0.1952
[torch.FloatTensor of size 1]

时间步 179000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 -1/ Q_MAX -1.870465e-01/ 轮得分 4.35
损失函数： Variable containing:
1.00000e-02 *
  4.3978
[torch.FloatTensor of size 1]

时间步 180000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.971655e+00/ 轮得分 4.34
损失函数： Variable containing:
1.00000e-02 *
  3.7617
[torch.FloatTensor of size 1]

时间步 181000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.352381e+00/ 轮得分 4.34
损失函数： Variable containing:
1.00000e-02 *
  2.9596
[torch.FloatTensor of size 1]

时间步 182000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.084183e+00/ 轮得分 4.33
损失函数： Variable containing:
1.00000e-03 *
  7.1761
[torch.FloatTensor of size 1]

时间步 183000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.408091e+00/ 轮得分 4.33
损失函数： Variable containing:
1.00000e-02 *
  1.6722
[torch.FloatTensor of size 1]

时间步 184000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.448225e+00/ 轮得分 4.33
损失函数： Variable containing:
1.00000e-02 *
  4.0182
[torch.FloatTensor of size 1]

时间步 185000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 8.766902e-01/ 轮得分 4.34
损失函数： Variable containing:
 0.1100
[torch.FloatTensor of size 1]

时间步 186000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.295255e+00/ 轮得分 4.32
损失函数： Variable containing:
1.00000e-02 *
  1.0178
[torch.FloatTensor of size 1]

时间步 187000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.473433e+00/ 轮得分 4.32
损失函数： Variable containing:
1.00000e-02 *
  9.4767
[torch.FloatTensor of size 1]

时间步 188000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.411961e+00/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-02 *
  2.6388
[torch.FloatTensor of size 1]

时间步 189000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.076005e+00/ 轮得分 4.32
损失函数： Variable containing:
1.00000e-03 *
  1.9895
[torch.FloatTensor of size 1]

时间步 190000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.795142e+00/ 轮得分 4.33
损失函数： Variable containing:
1.00000e-03 *
  9.9868
[torch.FloatTensor of size 1]

时间步 191000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.583624e+00/ 轮得分 4.32
损失函数： Variable containing:
1.00000e-02 *
  1.1856
[torch.FloatTensor of size 1]

时间步 192000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.573678e+00/ 轮得分 4.32
损失函数： Variable containing:
1.00000e-03 *
  7.8388
[torch.FloatTensor of size 1]

时间步 193000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.498545e+00/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-02 *
  5.7610
[torch.FloatTensor of size 1]

时间步 194000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.318529e+00/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-03 *
  3.8906
[torch.FloatTensor of size 1]

时间步 195000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.729977e+00/ 轮得分 4.29
损失函数： Variable containing:
1.00000e-03 *
  5.3901
[torch.FloatTensor of size 1]

时间步 196000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 6.798547e-01/ 轮得分 4.29
损失函数： Variable containing:
 0.1049
[torch.FloatTensor of size 1]

时间步 197000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.855759e+00/ 轮得分 4.29
损失函数： Variable containing:
1.00000e-02 *
  8.3063
[torch.FloatTensor of size 1]

时间步 198000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 8.278618e-01/ 轮得分 4.28
损失函数： Variable containing:
1.00000e-03 *
  8.4422
[torch.FloatTensor of size 1]

时间步 199000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.321923e+00/ 轮得分 4.28
损失函数： Variable containing:
1.00000e-03 *
  5.6840
[torch.FloatTensor of size 1]

时间步 200000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.643428e+00/ 轮得分 4.27
损失函数： Variable containing:
1.00000e-03 *
  4.4291
[torch.FloatTensor of size 1]

时间步 201000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.640336e+00/ 轮得分 4.28
损失函数： Variable containing:
1.00000e-02 *
  8.3660
[torch.FloatTensor of size 1]

时间步 202000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.961269e+00/ 轮得分 4.28
损失函数： Variable containing:
1.00000e-02 *
  4.5812
[torch.FloatTensor of size 1]

时间步 203000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.530495e+00/ 轮得分 4.28
损失函数： Variable containing:
1.00000e-02 *
  3.4534
[torch.FloatTensor of size 1]

时间步 204000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.990028e+00/ 轮得分 4.29
损失函数： Variable containing:
1.00000e-02 *
  1.0611
[torch.FloatTensor of size 1]

时间步 205000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.034248e+00/ 轮得分 4.28
损失函数： Variable containing:
1.00000e-02 *
  3.3028
[torch.FloatTensor of size 1]

时间步 206000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.386049e+00/ 轮得分 4.30
损失函数： Variable containing:
1.00000e-02 *
  4.0852
[torch.FloatTensor of size 1]

时间步 207000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.353482e+00/ 轮得分 4.30
损失函数： Variable containing:
1.00000e-03 *
  5.5172
[torch.FloatTensor of size 1]

时间步 208000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.873267e+00/ 轮得分 4.29
损失函数： Variable containing:
1.00000e-02 *
  3.3692
[torch.FloatTensor of size 1]

时间步 209000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.209807e+00/ 轮得分 4.30
损失函数： Variable containing:
1.00000e-03 *
  5.3808
[torch.FloatTensor of size 1]

时间步 210000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.165006e+00/ 轮得分 4.30
损失函数： Variable containing:
1.00000e-03 *
  1.9762
[torch.FloatTensor of size 1]

时间步 211000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.070430e+00/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-02 *
  2.5775
[torch.FloatTensor of size 1]

时间步 212000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.201899e+00/ 轮得分 4.32
损失函数： Variable containing:
1.00000e-02 *
  7.7763
[torch.FloatTensor of size 1]

时间步 213000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.509526e+00/ 轮得分 4.32
损失函数： Variable containing:
1.00000e-03 *
  4.1854
[torch.FloatTensor of size 1]

时间步 214000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 7.894616e-01/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-03 *
  9.6327
[torch.FloatTensor of size 1]

时间步 215000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.516360e+00/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-03 *
  7.0912
[torch.FloatTensor of size 1]

时间步 216000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.844727e+00/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-02 *
  3.6351
[torch.FloatTensor of size 1]

时间步 217000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.407630e+00/ 轮得分 4.32
损失函数： Variable containing:
1.00000e-03 *
  2.5615
[torch.FloatTensor of size 1]

时间步 218000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX -2.406876e-01/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-03 *
  5.4841
[torch.FloatTensor of size 1]

时间步 219000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.098187e+00/ 轮得分 4.32
损失函数： Variable containing:
1.00000e-03 *
  5.6988
[torch.FloatTensor of size 1]

时间步 220000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.561702e+00/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-03 *
  8.4875
[torch.FloatTensor of size 1]

时间步 221000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.804514e+00/ 轮得分 4.30
损失函数： Variable containing:
1.00000e-02 *
  1.0757
[torch.FloatTensor of size 1]

时间步 222000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX -5.387659e-01/ 轮得分 4.30
损失函数： Variable containing:
1.00000e-03 *
  3.6916
[torch.FloatTensor of size 1]

时间步 223000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.920215e-01/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-02 *
  1.9186
[torch.FloatTensor of size 1]

时间步 224000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.198164e+00/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-03 *
  4.1270
[torch.FloatTensor of size 1]

时间步 225000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.481937e+00/ 轮得分 4.32
损失函数： Variable containing:
1.00000e-03 *
  7.4547
[torch.FloatTensor of size 1]

时间步 226000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.793325e+00/ 轮得分 4.33
损失函数： Variable containing:
1.00000e-02 *
  4.1864
[torch.FloatTensor of size 1]

时间步 227000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.672730e+00/ 轮得分 4.33
损失函数： Variable containing:
1.00000e-03 *
  5.8917
[torch.FloatTensor of size 1]

时间步 228000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.252547e+00/ 轮得分 4.32
损失函数： Variable containing:
1.00000e-02 *
  2.3602
[torch.FloatTensor of size 1]

时间步 229000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.734449e-01/ 轮得分 4.34
损失函数： Variable containing:
1.00000e-02 *
  3.4173
[torch.FloatTensor of size 1]

时间步 230000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.854578e+00/ 轮得分 4.34
损失函数： Variable containing:
1.00000e-02 *
  1.2961
[torch.FloatTensor of size 1]

时间步 231000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.303569e+00/ 轮得分 4.33
损失函数： Variable containing:
1.00000e-02 *
  2.3815
[torch.FloatTensor of size 1]

时间步 232000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.060877e+00/ 轮得分 4.34
损失函数： Variable containing:
1.00000e-03 *
  8.4852
[torch.FloatTensor of size 1]

时间步 233000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 -1/ Q_MAX -8.878362e-01/ 轮得分 4.35
损失函数： Variable containing:
1.00000e-02 *
  2.1982
[torch.FloatTensor of size 1]

时间步 234000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.200967e+00/ 轮得分 4.36
损失函数： Variable containing:
1.00000e-02 *
  2.9971
[torch.FloatTensor of size 1]

时间步 235000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.180233e+00/ 轮得分 4.37
损失函数： Variable containing:
1.00000e-02 *
  1.8848
[torch.FloatTensor of size 1]

时间步 236000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.097120e+00/ 轮得分 4.38
损失函数： Variable containing:
1.00000e-02 *
  3.7016
[torch.FloatTensor of size 1]

时间步 237000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.745209e+00/ 轮得分 4.38
损失函数： Variable containing:
1.00000e-02 *
  1.8130
[torch.FloatTensor of size 1]

时间步 238000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 9.131290e-01/ 轮得分 4.38
损失函数： Variable containing:
1.00000e-03 *
  6.2305
[torch.FloatTensor of size 1]

时间步 239000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.515205e+00/ 轮得分 4.39
损失函数： Variable containing:
1.00000e-03 *
  5.1234
[torch.FloatTensor of size 1]

时间步 240000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 9.415168e-01/ 轮得分 4.38
损失函数： Variable containing:
1.00000e-02 *
  3.0665
[torch.FloatTensor of size 1]

时间步 241000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 9.557881e-01/ 轮得分 4.40
损失函数： Variable containing:
1.00000e-02 *
  1.5361
[torch.FloatTensor of size 1]

时间步 242000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.454288e+00/ 轮得分 4.40
损失函数： Variable containing:
1.00000e-03 *
  8.2167
[torch.FloatTensor of size 1]

时间步 243000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.182062e+00/ 轮得分 4.40
损失函数： Variable containing:
1.00000e-02 *
  1.1685
[torch.FloatTensor of size 1]

时间步 244000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.540051e+00/ 轮得分 4.40
损失函数： Variable containing:
 0.1714
[torch.FloatTensor of size 1]

时间步 245000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.219791e+00/ 轮得分 4.40
损失函数： Variable containing:
1.00000e-02 *
  1.3922
[torch.FloatTensor of size 1]

时间步 246000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.348090e+00/ 轮得分 4.39
损失函数： Variable containing:
1.00000e-03 *
  5.1163
[torch.FloatTensor of size 1]

时间步 247000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.922713e+00/ 轮得分 4.40
损失函数： Variable containing:
1.00000e-02 *
  1.1971
[torch.FloatTensor of size 1]

时间步 248000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.960016e+00/ 轮得分 4.40
损失函数： Variable containing:
1.00000e-03 *
  4.8522
[torch.FloatTensor of size 1]

时间步 249000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.857918e+00/ 轮得分 4.41
损失函数： Variable containing:
1.00000e-02 *
  1.2068
[torch.FloatTensor of size 1]

时间步 250000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.088400e+00/ 轮得分 4.43
损失函数： Variable containing:
1.00000e-03 *
  4.4292
[torch.FloatTensor of size 1]

时间步 251000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.277697e+00/ 轮得分 4.43
损失函数： Variable containing:
1.00000e-02 *
  3.4007
[torch.FloatTensor of size 1]

时间步 252000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.421256e+00/ 轮得分 4.42
损失函数： Variable containing:
1.00000e-02 *
  3.0452
[torch.FloatTensor of size 1]

时间步 253000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.264945e+00/ 轮得分 4.43
损失函数： Variable containing:
1.00000e-03 *
  7.5638
[torch.FloatTensor of size 1]

时间步 254000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.700505e+00/ 轮得分 4.46
损失函数： Variable containing:
1.00000e-02 *
  2.2704
[torch.FloatTensor of size 1]

时间步 255000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.143465e+00/ 轮得分 4.47
损失函数： Variable containing:
1.00000e-03 *
  4.8101
[torch.FloatTensor of size 1]

时间步 256000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.110857e+00/ 轮得分 4.48
损失函数： Variable containing:
1.00000e-02 *
  1.7556
[torch.FloatTensor of size 1]

时间步 257000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.269984e+00/ 轮得分 4.49
损失函数： Variable containing:
1.00000e-03 *
  3.9011
[torch.FloatTensor of size 1]

时间步 258000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 9.742790e-01/ 轮得分 4.51
损失函数： Variable containing:
1.00000e-02 *
  5.5622
[torch.FloatTensor of size 1]

时间步 259000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.729200e+00/ 轮得分 4.53
损失函数： Variable containing:
1.00000e-02 *
  9.6988
[torch.FloatTensor of size 1]

时间步 260000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.030334e+00/ 轮得分 4.54
损失函数： Variable containing:
1.00000e-02 *
  1.1675
[torch.FloatTensor of size 1]

时间步 261000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.868226e+00/ 轮得分 4.55
损失函数： Variable containing:
1.00000e-02 *
  1.8443
[torch.FloatTensor of size 1]

时间步 262000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.365647e-01/ 轮得分 4.54
损失函数： Variable containing:
1.00000e-02 *
  1.7249
[torch.FloatTensor of size 1]

时间步 263000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.462058e+00/ 轮得分 4.55
损失函数： Variable containing:
1.00000e-02 *
  2.3048
[torch.FloatTensor of size 1]

时间步 264000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.863134e+00/ 轮得分 4.56
损失函数： Variable containing:
1.00000e-03 *
  7.4642
[torch.FloatTensor of size 1]

时间步 265000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.450577e+00/ 轮得分 4.57
损失函数： Variable containing:
1.00000e-02 *
  3.7150
[torch.FloatTensor of size 1]

时间步 266000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.715205e+00/ 轮得分 4.55
损失函数： Variable containing:
1.00000e-03 *
  4.6964
[torch.FloatTensor of size 1]

时间步 267000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.304871e+00/ 轮得分 4.55
损失函数： Variable containing:
1.00000e-02 *
  2.6674
[torch.FloatTensor of size 1]

时间步 268000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.894710e+00/ 轮得分 4.55
损失函数： Variable containing:
1.00000e-02 *
  4.2015
[torch.FloatTensor of size 1]

时间步 269000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.020446e+00/ 轮得分 4.55
损失函数： Variable containing:
1.00000e-02 *
  1.9902
[torch.FloatTensor of size 1]

时间步 270000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.119064e+00/ 轮得分 4.55
损失函数： Variable containing:
1.00000e-02 *
  3.8829
[torch.FloatTensor of size 1]

时间步 271000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.879200e+00/ 轮得分 4.56
损失函数： Variable containing:
1.00000e-02 *
  6.3012
[torch.FloatTensor of size 1]

时间步 272000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.344627e+00/ 轮得分 4.57
损失函数： Variable containing:
1.00000e-03 *
  4.1786
[torch.FloatTensor of size 1]

时间步 273000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.828216e+00/ 轮得分 4.58
损失函数： Variable containing:
1.00000e-03 *
  7.2313
[torch.FloatTensor of size 1]

时间步 274000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.771783e+00/ 轮得分 4.59
损失函数： Variable containing:
1.00000e-02 *
  4.2580
[torch.FloatTensor of size 1]

时间步 275000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.837083e+00/ 轮得分 4.60
损失函数： Variable containing:
1.00000e-02 *
  4.8489
[torch.FloatTensor of size 1]

时间步 276000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX -4.286924e-01/ 轮得分 4.61
损失函数： Variable containing:
1.00000e-02 *
  1.9201
[torch.FloatTensor of size 1]

时间步 277000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.248976e+00/ 轮得分 4.63
损失函数： Variable containing:
1.00000e-02 *
  3.4871
[torch.FloatTensor of size 1]

时间步 278000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.039049e+00/ 轮得分 4.63
损失函数： Variable containing:
1.00000e-03 *
  8.1660
[torch.FloatTensor of size 1]

时间步 279000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.764374e+00/ 轮得分 4.64
损失函数： Variable containing:
 0.1107
[torch.FloatTensor of size 1]

时间步 280000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.421919e+00/ 轮得分 4.64
损失函数： Variable containing:
1.00000e-02 *
  3.3899
[torch.FloatTensor of size 1]

时间步 281000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.741218e+00/ 轮得分 4.66
损失函数： Variable containing:
1.00000e-03 *
  5.7564
[torch.FloatTensor of size 1]

时间步 282000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.942236e+00/ 轮得分 4.65
损失函数： Variable containing:
1.00000e-02 *
  3.9568
[torch.FloatTensor of size 1]

时间步 283000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.002876e+00/ 轮得分 4.65
损失函数： Variable containing:
1.00000e-03 *
  8.5642
[torch.FloatTensor of size 1]

时间步 284000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.515109e+00/ 轮得分 4.66
损失函数： Variable containing:
1.00000e-02 *
  8.4564
[torch.FloatTensor of size 1]

时间步 285000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.200373e+00/ 轮得分 4.64
损失函数： Variable containing:
1.00000e-02 *
  4.6638
[torch.FloatTensor of size 1]

时间步 286000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.621712e+00/ 轮得分 4.65
损失函数： Variable containing:
1.00000e-03 *
  6.1519
[torch.FloatTensor of size 1]

时间步 287000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.267298e+00/ 轮得分 4.65
损失函数： Variable containing:
1.00000e-02 *
  1.7373
[torch.FloatTensor of size 1]

时间步 288000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.479605e+00/ 轮得分 4.67
损失函数： Variable containing:
 0.2162
[torch.FloatTensor of size 1]

时间步 289000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.995621e+00/ 轮得分 4.67
损失函数： Variable containing:
 0.1208
[torch.FloatTensor of size 1]

时间步 290000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.032042e+00/ 轮得分 4.68
损失函数： Variable containing:
1.00000e-02 *
  1.1307
[torch.FloatTensor of size 1]

时间步 291000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.544744e+00/ 轮得分 4.68
损失函数： Variable containing:
1.00000e-02 *
  2.9644
[torch.FloatTensor of size 1]

时间步 292000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.083480e+00/ 轮得分 4.69
损失函数： Variable containing:
1.00000e-02 *
  1.6832
[torch.FloatTensor of size 1]

时间步 293000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.180243e+00/ 轮得分 4.71
损失函数： Variable containing:
1.00000e-02 *
  1.6572
[torch.FloatTensor of size 1]

时间步 294000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.982644e+00/ 轮得分 4.70
损失函数： Variable containing:
 0.1332
[torch.FloatTensor of size 1]

时间步 295000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.146049e+00/ 轮得分 4.71
损失函数： Variable containing:
1.00000e-02 *
  1.3313
[torch.FloatTensor of size 1]

时间步 296000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.720871e+00/ 轮得分 4.72
损失函数： Variable containing:
1.00000e-02 *
  5.1633
[torch.FloatTensor of size 1]

时间步 297000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.552896e+00/ 轮得分 4.71
损失函数： Variable containing:
 0.1084
[torch.FloatTensor of size 1]

时间步 298000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.271554e+00/ 轮得分 4.73
损失函数： Variable containing:
1.00000e-02 *
  3.0912
[torch.FloatTensor of size 1]

时间步 299000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.412555e+00/ 轮得分 4.74
损失函数： Variable containing:
1.00000e-02 *
  2.6290
[torch.FloatTensor of size 1]

时间步 300000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.758686e+00/ 轮得分 4.75
损失函数： Variable containing:
1.00000e-02 *
  3.5982
[torch.FloatTensor of size 1]

时间步 301000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.311168e-02/ 轮得分 4.75
损失函数： Variable containing:
1.00000e-02 *
  3.4474
[torch.FloatTensor of size 1]

时间步 302000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.174709e+00/ 轮得分 4.77
损失函数： Variable containing:
1.00000e-02 *
  4.4171
[torch.FloatTensor of size 1]

时间步 303000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.388140e+00/ 轮得分 4.79
损失函数： Variable containing:
1.00000e-02 *
  4.6910
[torch.FloatTensor of size 1]

时间步 304000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.693608e+00/ 轮得分 4.79
损失函数： Variable containing:
1.00000e-02 *
  2.7113
[torch.FloatTensor of size 1]

时间步 305000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.054624e+00/ 轮得分 4.81
损失函数： Variable containing:
1.00000e-02 *
  1.8575
[torch.FloatTensor of size 1]

时间步 306000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 1/ Q_MAX 2.645115e+00/ 轮得分 4.81
损失函数： Variable containing:
1.00000e-02 *
  1.2691
[torch.FloatTensor of size 1]

时间步 307000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.110515e+00/ 轮得分 4.81
损失函数： Variable containing:
1.00000e-02 *
  3.4133
[torch.FloatTensor of size 1]

时间步 308000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.369485e+00/ 轮得分 4.84
损失函数： Variable containing:
1.00000e-02 *
  1.0004
[torch.FloatTensor of size 1]

时间步 309000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.583212e+00/ 轮得分 4.84
损失函数： Variable containing:
1.00000e-02 *
  2.1995
[torch.FloatTensor of size 1]

时间步 310000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.921599e+00/ 轮得分 4.85
损失函数： Variable containing:
1.00000e-02 *
  2.5125
[torch.FloatTensor of size 1]

时间步 311000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.616669e+00/ 轮得分 4.86
损失函数： Variable containing:
1.00000e-02 *
  2.9629
[torch.FloatTensor of size 1]

时间步 312000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.835088e+00/ 轮得分 4.85
损失函数： Variable containing:
1.00000e-02 *
  5.0631
[torch.FloatTensor of size 1]

时间步 313000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 6.080884e-01/ 轮得分 4.85
损失函数： Variable containing:
1.00000e-02 *
  9.6185
[torch.FloatTensor of size 1]

时间步 314000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.680009e+00/ 轮得分 4.84
损失函数： Variable containing:
1.00000e-02 *
  5.4337
[torch.FloatTensor of size 1]

时间步 315000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.120635e+00/ 轮得分 4.81
损失函数： Variable containing:
1.00000e-02 *
  3.0805
[torch.FloatTensor of size 1]

时间步 316000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.635536e+00/ 轮得分 4.80
损失函数： Variable containing:
1.00000e-02 *
  4.1823
[torch.FloatTensor of size 1]

时间步 317000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.004099e+00/ 轮得分 4.81
损失函数： Variable containing:
1.00000e-02 *
  3.7254
[torch.FloatTensor of size 1]

时间步 318000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.110021e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  6.7405
[torch.FloatTensor of size 1]

时间步 319000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.645313e+00/ 轮得分 4.80
损失函数： Variable containing:
1.00000e-02 *
  3.7056
[torch.FloatTensor of size 1]

时间步 320000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.763641e+00/ 轮得分 4.78
损失函数： Variable containing:
 0.1696
[torch.FloatTensor of size 1]

时间步 321000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.214249e+00/ 轮得分 4.78
损失函数： Variable containing:
 0.1419
[torch.FloatTensor of size 1]

时间步 322000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.991456e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  2.7252
[torch.FloatTensor of size 1]

时间步 323000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.017483e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  3.2682
[torch.FloatTensor of size 1]

时间步 324000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 6.664575e-01/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  9.9711
[torch.FloatTensor of size 1]

时间步 325000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.137948e+00/ 轮得分 4.78
损失函数： Variable containing:
 0.1811
[torch.FloatTensor of size 1]

时间步 326000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.355749e+00/ 轮得分 4.77
损失函数： Variable containing:
1.00000e-02 *
  3.4008
[torch.FloatTensor of size 1]

时间步 327000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.649241e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  3.2243
[torch.FloatTensor of size 1]

时间步 328000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.422445e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  2.5953
[torch.FloatTensor of size 1]

时间步 329000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX -2.500353e-01/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  5.8512
[torch.FloatTensor of size 1]

时间步 330000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.875708e+00/ 轮得分 4.77
损失函数： Variable containing:
1.00000e-02 *
  7.7566
[torch.FloatTensor of size 1]

时间步 331000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.016418e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  8.1390
[torch.FloatTensor of size 1]

时间步 332000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 8.107510e-01/ 轮得分 4.77
损失函数： Variable containing:
1.00000e-02 *
  2.3013
[torch.FloatTensor of size 1]

时间步 333000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.762254e+00/ 轮得分 4.75
损失函数： Variable containing:
1.00000e-02 *
  4.0001
[torch.FloatTensor of size 1]

时间步 334000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.250811e+00/ 轮得分 4.76
损失函数： Variable containing:
 0.1113
[torch.FloatTensor of size 1]

时间步 335000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.020406e+00/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  2.5597
[torch.FloatTensor of size 1]

时间步 336000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.646223e-01/ 轮得分 4.75
损失函数： Variable containing:
1.00000e-02 *
  2.8866
[torch.FloatTensor of size 1]

时间步 337000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.713110e+00/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  4.7501
[torch.FloatTensor of size 1]

时间步 338000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 -1/ Q_MAX 1.091027e+00/ 轮得分 4.77
损失函数： Variable containing:
1.00000e-02 *
  6.0582
[torch.FloatTensor of size 1]

时间步 339000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.780879e+00/ 轮得分 4.78
损失函数： Variable containing:
 0.2224
[torch.FloatTensor of size 1]

时间步 340000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX -9.611492e-02/ 轮得分 4.81
损失函数： Variable containing:
 0.2072
[torch.FloatTensor of size 1]

时间步 341000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.007819e+00/ 轮得分 4.82
损失函数： Variable containing:
1.00000e-02 *
  1.7944
[torch.FloatTensor of size 1]

时间步 342000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.655771e+00/ 轮得分 4.85
损失函数： Variable containing:
1.00000e-02 *
  7.2185
[torch.FloatTensor of size 1]

时间步 343000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.186599e+00/ 轮得分 4.86
损失函数： Variable containing:
1.00000e-02 *
  5.7406
[torch.FloatTensor of size 1]

时间步 344000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.933872e+00/ 轮得分 4.87
损失函数： Variable containing:
1.00000e-02 *
  3.9342
[torch.FloatTensor of size 1]

时间步 345000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.976781e+00/ 轮得分 4.86
损失函数： Variable containing:
1.00000e-02 *
  6.2887
[torch.FloatTensor of size 1]

时间步 346000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.977029e-02/ 轮得分 4.86
损失函数： Variable containing:
1.00000e-02 *
  2.3937
[torch.FloatTensor of size 1]

时间步 347000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.409430e+00/ 轮得分 4.86
损失函数： Variable containing:
 0.1058
[torch.FloatTensor of size 1]

时间步 348000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.679142e+00/ 轮得分 4.86
损失函数： Variable containing:
1.00000e-02 *
  4.3140
[torch.FloatTensor of size 1]

时间步 349000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.014437e+00/ 轮得分 4.87
损失函数： Variable containing:
1.00000e-02 *
  2.8585
[torch.FloatTensor of size 1]

时间步 350000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.711883e+00/ 轮得分 4.86
损失函数： Variable containing:
1.00000e-02 *
  4.7724
[torch.FloatTensor of size 1]

时间步 351000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.116838e+00/ 轮得分 4.85
损失函数： Variable containing:
1.00000e-02 *
  5.5933
[torch.FloatTensor of size 1]

时间步 352000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 -1/ Q_MAX -8.090329e-02/ 轮得分 4.84
损失函数： Variable containing:
 0.5685
[torch.FloatTensor of size 1]

时间步 353000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.206585e+00/ 轮得分 4.84
损失函数： Variable containing:
1.00000e-02 *
  8.5350
[torch.FloatTensor of size 1]

时间步 354000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.385787e+00/ 轮得分 4.84
损失函数： Variable containing:
1.00000e-02 *
  1.7876
[torch.FloatTensor of size 1]

时间步 355000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.129139e+00/ 轮得分 4.85
损失函数： Variable containing:
 0.1040
[torch.FloatTensor of size 1]

时间步 356000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.990563e+00/ 轮得分 4.83
损失函数： Variable containing:
1.00000e-02 *
  3.7699
[torch.FloatTensor of size 1]

时间步 357000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.097126e-01/ 轮得分 4.82
损失函数： Variable containing:
 0.1420
[torch.FloatTensor of size 1]

时间步 358000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.862365e-01/ 轮得分 4.83
损失函数： Variable containing:
1.00000e-02 *
  9.4270
[torch.FloatTensor of size 1]

时间步 359000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 8.525978e-01/ 轮得分 4.85
损失函数： Variable containing:
 0.2063
[torch.FloatTensor of size 1]

时间步 360000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.335755e+00/ 轮得分 4.84
损失函数： Variable containing:
1.00000e-02 *
  2.3000
[torch.FloatTensor of size 1]

时间步 361000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.751003e+00/ 轮得分 4.85
损失函数： Variable containing:
1.00000e-02 *
  4.3446
[torch.FloatTensor of size 1]

时间步 362000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.705282e+00/ 轮得分 4.84
损失函数： Variable containing:
 0.1353
[torch.FloatTensor of size 1]

时间步 363000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.621181e+00/ 轮得分 4.82
损失函数： Variable containing:
 0.1791
[torch.FloatTensor of size 1]

时间步 364000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.387986e+00/ 轮得分 4.81
损失函数： Variable containing:
1.00000e-02 *
  5.8415
[torch.FloatTensor of size 1]

时间步 365000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.018159e+00/ 轮得分 4.81
损失函数： Variable containing:
1.00000e-02 *
  4.0691
[torch.FloatTensor of size 1]

时间步 366000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 7.106053e-01/ 轮得分 4.83
损失函数： Variable containing:
 0.1230
[torch.FloatTensor of size 1]

时间步 367000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.184031e+00/ 轮得分 4.83
损失函数： Variable containing:
1.00000e-02 *
  7.5881
[torch.FloatTensor of size 1]

时间步 368000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.324515e+00/ 轮得分 4.82
损失函数： Variable containing:
 0.1769
[torch.FloatTensor of size 1]

时间步 369000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.246951e+00/ 轮得分 4.80
损失函数： Variable containing:
1.00000e-02 *
  6.3376
[torch.FloatTensor of size 1]

时间步 370000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.517644e+00/ 轮得分 4.80
损失函数： Variable containing:
1.00000e-02 *
  3.0142
[torch.FloatTensor of size 1]

时间步 371000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.735716e+00/ 轮得分 4.80
损失函数： Variable containing:
 0.7663
[torch.FloatTensor of size 1]

时间步 372000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.296570e+00/ 轮得分 4.82
损失函数： Variable containing:
1.00000e-02 *
  4.7940
[torch.FloatTensor of size 1]

时间步 373000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.011285e+00/ 轮得分 4.83
损失函数： Variable containing:
1.00000e-02 *
  3.9547
[torch.FloatTensor of size 1]

时间步 374000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 -1/ Q_MAX 4.707730e+00/ 轮得分 4.82
损失函数： Variable containing:
1.00000e-02 *
  7.2204
[torch.FloatTensor of size 1]

时间步 375000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.926228e+00/ 轮得分 4.82
损失函数： Variable containing:
1.00000e-02 *
  7.2148
[torch.FloatTensor of size 1]

时间步 376000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.160700e+00/ 轮得分 4.82
损失函数： Variable containing:
 0.1085
[torch.FloatTensor of size 1]

时间步 377000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.443056e+00/ 轮得分 4.81
损失函数： Variable containing:
1.00000e-02 *
  4.2688
[torch.FloatTensor of size 1]

时间步 378000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 6.195250e+00/ 轮得分 4.83
损失函数： Variable containing:
1.00000e-02 *
  2.4946
[torch.FloatTensor of size 1]

时间步 379000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.550964e+00/ 轮得分 4.83
损失函数： Variable containing:
1.00000e-02 *
  6.7088
[torch.FloatTensor of size 1]

时间步 380000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 -1/ Q_MAX 3.117166e-01/ 轮得分 4.85
损失函数： Variable containing:
1.00000e-02 *
  5.5717
[torch.FloatTensor of size 1]

时间步 381000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.720491e+00/ 轮得分 4.86
损失函数： Variable containing:
 0.1337
[torch.FloatTensor of size 1]

时间步 382000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 6.393108e+00/ 轮得分 4.87
损失函数： Variable containing:
1.00000e-02 *
  5.1208
[torch.FloatTensor of size 1]

时间步 383000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.822738e+00/ 轮得分 4.87
损失函数： Variable containing:
1.00000e-02 *
  5.6235
[torch.FloatTensor of size 1]

时间步 384000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.045598e+00/ 轮得分 4.88
损失函数： Variable containing:
1.00000e-02 *
  3.0044
[torch.FloatTensor of size 1]

时间步 385000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.009601e+00/ 轮得分 4.88
损失函数： Variable containing:
1.00000e-02 *
  3.1416
[torch.FloatTensor of size 1]

时间步 386000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.630787e+00/ 轮得分 4.89
损失函数： Variable containing:
1.00000e-02 *
  5.8354
[torch.FloatTensor of size 1]

时间步 387000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.957630e+00/ 轮得分 4.90
损失函数： Variable containing:
 0.1718
[torch.FloatTensor of size 1]

时间步 388000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.828753e+00/ 轮得分 4.89
损失函数： Variable containing:
 0.1319
[torch.FloatTensor of size 1]

时间步 389000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.715717e+00/ 轮得分 4.89
损失函数： Variable containing:
 0.1785
[torch.FloatTensor of size 1]

时间步 390000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.513362e+00/ 轮得分 4.89
损失函数： Variable containing:
1.00000e-02 *
  4.8660
[torch.FloatTensor of size 1]

时间步 391000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.030642e+00/ 轮得分 4.90
损失函数： Variable containing:
1.00000e-02 *
  5.3809
[torch.FloatTensor of size 1]

时间步 392000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.161024e+00/ 轮得分 4.88
损失函数： Variable containing:
1.00000e-02 *
  5.1555
[torch.FloatTensor of size 1]

时间步 393000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.597226e+00/ 轮得分 4.88
损失函数： Variable containing:
1.00000e-02 *
  4.3880
[torch.FloatTensor of size 1]

时间步 394000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.595791e+00/ 轮得分 4.86
损失函数： Variable containing:
1.00000e-02 *
  3.5114
[torch.FloatTensor of size 1]

时间步 395000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.846575e+00/ 轮得分 4.85
损失函数： Variable containing:
1.00000e-02 *
  6.8669
[torch.FloatTensor of size 1]

时间步 396000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.468159e+00/ 轮得分 4.85
损失函数： Variable containing:
1.00000e-02 *
  7.2598
[torch.FloatTensor of size 1]

时间步 397000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.586229e+00/ 轮得分 4.81
损失函数： Variable containing:
 0.2773
[torch.FloatTensor of size 1]

时间步 398000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.588115e+00/ 轮得分 4.80
损失函数： Variable containing:
 0.1485
[torch.FloatTensor of size 1]

时间步 399000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX -1.260961e+00/ 轮得分 4.77
损失函数： Variable containing:
1.00000e-02 *
  3.4352
[torch.FloatTensor of size 1]

时间步 400000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.474610e+00/ 轮得分 4.79
损失函数： Variable containing:
 0.1001
[torch.FloatTensor of size 1]

时间步 401000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.566952e+00/ 轮得分 4.79
损失函数： Variable containing:
1.00000e-02 *
  9.7049
[torch.FloatTensor of size 1]

时间步 402000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.384618e+00/ 轮得分 4.81
损失函数： Variable containing:
1.00000e-02 *
  3.2015
[torch.FloatTensor of size 1]

时间步 403000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.014723e+00/ 轮得分 4.81
损失函数： Variable containing:
1.00000e-02 *
  1.6370
[torch.FloatTensor of size 1]

时间步 404000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.040455e+00/ 轮得分 4.79
损失函数： Variable containing:
1.00000e-02 *
  6.0246
[torch.FloatTensor of size 1]

时间步 405000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.658350e+00/ 轮得分 4.79
损失函数： Variable containing:
1.00000e-02 *
  6.5350
[torch.FloatTensor of size 1]

时间步 406000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 -1/ Q_MAX -4.585293e-01/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  5.9538
[torch.FloatTensor of size 1]

时间步 407000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 6.589863e+00/ 轮得分 4.75
损失函数： Variable containing:
1.00000e-02 *
  5.7895
[torch.FloatTensor of size 1]

时间步 408000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.564787e+00/ 轮得分 4.76
损失函数： Variable containing:
 0.1183
[torch.FloatTensor of size 1]

时间步 409000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.819573e+00/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  5.2147
[torch.FloatTensor of size 1]

时间步 410000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.099583e+00/ 轮得分 4.75
损失函数： Variable containing:
1.00000e-02 *
  7.3737
[torch.FloatTensor of size 1]

时间步 411000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.533921e+00/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  6.3352
[torch.FloatTensor of size 1]

时间步 412000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.416625e+00/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  7.8814
[torch.FloatTensor of size 1]

时间步 413000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.636318e+00/ 轮得分 4.75
损失函数： Variable containing:
1.00000e-02 *
  3.0111
[torch.FloatTensor of size 1]

时间步 414000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.554356e+00/ 轮得分 4.75
损失函数： Variable containing:
1.00000e-02 *
  2.5571
[torch.FloatTensor of size 1]

时间步 415000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.465817e+00/ 轮得分 4.73
损失函数： Variable containing:
1.00000e-02 *
  9.0630
[torch.FloatTensor of size 1]

时间步 416000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.944914e+00/ 轮得分 4.70
损失函数： Variable containing:
1.00000e-02 *
  1.6053
[torch.FloatTensor of size 1]

时间步 417000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.234840e+00/ 轮得分 4.74
损失函数： Variable containing:
1.00000e-02 *
  1.9463
[torch.FloatTensor of size 1]

时间步 418000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX -1.016083e+00/ 轮得分 4.73
损失函数： Variable containing:
1.00000e-02 *
  4.4741
[torch.FloatTensor of size 1]

时间步 419000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.242329e+00/ 轮得分 4.73
损失函数： Variable containing:
1.00000e-02 *
  5.7402
[torch.FloatTensor of size 1]

时间步 420000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.584625e+00/ 轮得分 4.74
损失函数： Variable containing:
1.00000e-02 *
  8.5441
[torch.FloatTensor of size 1]

时间步 421000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX -2.650415e-01/ 轮得分 4.74
损失函数： Variable containing:
1.00000e-02 *
  9.6024
[torch.FloatTensor of size 1]

时间步 422000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.350146e+00/ 轮得分 4.74
损失函数： Variable containing:
1.00000e-02 *
  4.2221
[torch.FloatTensor of size 1]

时间步 423000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.566646e+00/ 轮得分 4.72
损失函数： Variable containing:
1.00000e-02 *
  5.6892
[torch.FloatTensor of size 1]

时间步 424000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.926906e+00/ 轮得分 4.70
损失函数： Variable containing:
1.00000e-02 *
  3.9780
[torch.FloatTensor of size 1]

时间步 425000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.346811e+00/ 轮得分 4.72
损失函数： Variable containing:
1.00000e-02 *
  2.6145
[torch.FloatTensor of size 1]

时间步 426000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.424296e+00/ 轮得分 4.73
损失函数： Variable containing:
1.00000e-02 *
  8.3964
[torch.FloatTensor of size 1]

时间步 427000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.106454e+00/ 轮得分 4.71
损失函数： Variable containing:
1.00000e-02 *
  8.2349
[torch.FloatTensor of size 1]

时间步 428000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.975177e+00/ 轮得分 4.70
损失函数： Variable containing:
1.00000e-02 *
  5.7062
[torch.FloatTensor of size 1]

时间步 429000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.353487e+00/ 轮得分 4.70
损失函数： Variable containing:
1.00000e-02 *
  9.5072
[torch.FloatTensor of size 1]

时间步 430000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.940926e+00/ 轮得分 4.71
损失函数： Variable containing:
 0.6890
[torch.FloatTensor of size 1]

时间步 431000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.625515e+00/ 轮得分 4.75
损失函数： Variable containing:
1.00000e-02 *
  6.1996
[torch.FloatTensor of size 1]

时间步 432000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.816441e+00/ 轮得分 4.73
损失函数： Variable containing:
1.00000e-02 *
  6.7208
[torch.FloatTensor of size 1]

时间步 433000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.119665e+00/ 轮得分 4.72
损失函数： Variable containing:
1.00000e-02 *
  8.0521
[torch.FloatTensor of size 1]

时间步 434000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.792458e+00/ 轮得分 4.74
损失函数： Variable containing:
1.00000e-02 *
  5.6521
[torch.FloatTensor of size 1]

时间步 435000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.757099e+00/ 轮得分 4.75
损失函数： Variable containing:
1.00000e-02 *
  5.9508
[torch.FloatTensor of size 1]

时间步 436000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.973361e+00/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  4.9745
[torch.FloatTensor of size 1]

时间步 437000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.532677e+00/ 轮得分 4.74
损失函数： Variable containing:
1.00000e-02 *
  4.9284
[torch.FloatTensor of size 1]

时间步 438000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.598365e+00/ 轮得分 4.74
损失函数： Variable containing:
1.00000e-02 *
  5.2364
[torch.FloatTensor of size 1]

时间步 439000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 -1/ Q_MAX 3.751616e-01/ 轮得分 4.74
损失函数： Variable containing:
1.00000e-02 *
  4.1346
[torch.FloatTensor of size 1]

时间步 440000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.770442e+00/ 轮得分 4.75
损失函数： Variable containing:
1.00000e-02 *
  4.0282
[torch.FloatTensor of size 1]

时间步 441000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.470104e+00/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  2.6146
[torch.FloatTensor of size 1]

时间步 442000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.638797e+00/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  2.9230
[torch.FloatTensor of size 1]

时间步 443000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.421135e+00/ 轮得分 4.75
损失函数： Variable containing:
1.00000e-02 *
  6.1166
[torch.FloatTensor of size 1]

时间步 444000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.870091e+00/ 轮得分 4.73
损失函数： Variable containing:
1.00000e-02 *
  4.3646
[torch.FloatTensor of size 1]

时间步 445000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.675200e+00/ 轮得分 4.72
损失函数： Variable containing:
1.00000e-02 *
  4.0075
[torch.FloatTensor of size 1]

时间步 446000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.931475e+00/ 轮得分 4.73
损失函数： Variable containing:
 0.4522
[torch.FloatTensor of size 1]

时间步 447000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.316119e+00/ 轮得分 4.74
损失函数： Variable containing:
1.00000e-02 *
  6.4332
[torch.FloatTensor of size 1]

时间步 448000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.435565e+00/ 轮得分 4.75
损失函数： Variable containing:
 0.1773
[torch.FloatTensor of size 1]

时间步 449000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.809814e+00/ 轮得分 4.77
损失函数： Variable containing:
1.00000e-02 *
  3.6686
[torch.FloatTensor of size 1]

时间步 450000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.072508e+00/ 轮得分 4.80
损失函数： Variable containing:
1.00000e-02 *
  9.0396
[torch.FloatTensor of size 1]

时间步 451000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.717468e+00/ 轮得分 4.79
损失函数： Variable containing:
1.00000e-02 *
  6.6792
[torch.FloatTensor of size 1]

时间步 452000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 1.920022e+00/ 轮得分 4.80
损失函数： Variable containing:
1.00000e-02 *
  7.3577
[torch.FloatTensor of size 1]

时间步 453000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.598427e+00/ 轮得分 4.79
损失函数： Variable containing:
1.00000e-02 *
  5.1949
[torch.FloatTensor of size 1]

时间步 454000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.955926e+00/ 轮得分 4.79
损失函数： Variable containing:
 0.1652
[torch.FloatTensor of size 1]

时间步 455000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 4.430365e+00/ 轮得分 4.79
损失函数： Variable containing:
1.00000e-02 *
  5.2647
[torch.FloatTensor of size 1]

时间步 456000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 3.636609e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  5.1033
[torch.FloatTensor of size 1]

时间步 457000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 6.263972e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  8.0817
[torch.FloatTensor of size 1]

时间步 458000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 5.761135e+00/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  6.8153
[torch.FloatTensor of size 1]

时间步 459000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 6.368053e+00/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  6.8684
[torch.FloatTensor of size 1]

时间步 460000/ 状态 explore/ Epsilon 0.09/ 行动 0/ 奖励 0.1/ Q_MAX 2.173804e+00/ 轮得分 4.76
损失函数： Variable containing:
 0.1720
[torch.FloatTensor of size 1]

时间步 461000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 1/ Q_MAX 5.650675e+00/ 轮得分 4.76
损失函数： Variable containing:
 1.5487
[torch.FloatTensor of size 1]

时间步 462000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 1.703669e+00/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  4.0720
[torch.FloatTensor of size 1]

时间步 463000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.769477e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  5.7782
[torch.FloatTensor of size 1]

时间步 464000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.849461e+00/ 轮得分 4.77
损失函数： Variable containing:
 0.4232
[torch.FloatTensor of size 1]

时间步 465000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.094275e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  8.6832
[torch.FloatTensor of size 1]

时间步 466000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.561437e+00/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  4.1608
[torch.FloatTensor of size 1]

时间步 467000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.555692e+00/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  9.7985
[torch.FloatTensor of size 1]

时间步 468000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 2.904265e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  7.8476
[torch.FloatTensor of size 1]

时间步 469000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.101370e+00/ 轮得分 4.77
损失函数： Variable containing:
 0.2746
[torch.FloatTensor of size 1]

时间步 470000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.027728e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  6.5577
[torch.FloatTensor of size 1]

时间步 471000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 1/ Q_MAX 5.652607e+00/ 轮得分 4.79
损失函数： Variable containing:
 0.1656
[torch.FloatTensor of size 1]

时间步 472000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.486592e+00/ 轮得分 4.79
损失函数： Variable containing:
1.00000e-02 *
  5.7453
[torch.FloatTensor of size 1]

时间步 473000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.915123e+00/ 轮得分 4.80
损失函数： Variable containing:
1.00000e-02 *
  6.1787
[torch.FloatTensor of size 1]

时间步 474000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 2.962107e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  6.4247
[torch.FloatTensor of size 1]

时间步 475000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.082797e+00/ 轮得分 4.80
损失函数： Variable containing:
 0.3618
[torch.FloatTensor of size 1]

时间步 476000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.928249e+00/ 轮得分 4.80
损失函数： Variable containing:
1.00000e-02 *
  7.1836
[torch.FloatTensor of size 1]

时间步 477000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.806832e+00/ 轮得分 4.79
损失函数： Variable containing:
1.00000e-02 *
  6.4953
[torch.FloatTensor of size 1]

时间步 478000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.071238e+00/ 轮得分 4.79
损失函数： Variable containing:
1.00000e-02 *
  6.2646
[torch.FloatTensor of size 1]

时间步 479000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.742798e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  5.3186
[torch.FloatTensor of size 1]

时间步 480000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 1.224088e+00/ 轮得分 4.77
损失函数： Variable containing:
 0.1092
[torch.FloatTensor of size 1]

时间步 481000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.460814e+00/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  3.7209
[torch.FloatTensor of size 1]

时间步 482000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.344426e+00/ 轮得分 4.76
损失函数： Variable containing:
 0.1228
[torch.FloatTensor of size 1]

时间步 483000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.999577e+00/ 轮得分 4.77
损失函数： Variable containing:
 1.0647
[torch.FloatTensor of size 1]

时间步 484000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.494431e+00/ 轮得分 4.77
损失函数： Variable containing:
1.00000e-02 *
  5.8250
[torch.FloatTensor of size 1]

时间步 485000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.877029e+00/ 轮得分 4.75
损失函数： Variable containing:
 0.7181
[torch.FloatTensor of size 1]

时间步 486000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.347825e+00/ 轮得分 4.74
损失函数： Variable containing:
1.00000e-02 *
  5.4048
[torch.FloatTensor of size 1]

时间步 487000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.732724e+00/ 轮得分 4.71
损失函数： Variable containing:
 0.4057
[torch.FloatTensor of size 1]

时间步 488000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.898251e+00/ 轮得分 4.72
损失函数： Variable containing:
1.00000e-02 *
  6.3952
[torch.FloatTensor of size 1]

时间步 489000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.431264e+00/ 轮得分 4.71
损失函数： Variable containing:
 0.1771
[torch.FloatTensor of size 1]

时间步 490000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.848411e+00/ 轮得分 4.68
损失函数： Variable containing:
 0.1169
[torch.FloatTensor of size 1]

时间步 491000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.816627e+00/ 轮得分 4.65
损失函数： Variable containing:
 0.1676
[torch.FloatTensor of size 1]

时间步 492000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 1.680751e+00/ 轮得分 4.63
损失函数： Variable containing:
 0.2259
[torch.FloatTensor of size 1]

时间步 493000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.924777e+00/ 轮得分 4.62
损失函数： Variable containing:
1.00000e-02 *
  6.9091
[torch.FloatTensor of size 1]

时间步 494000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.316366e+00/ 轮得分 4.63
损失函数： Variable containing:
 0.4348
[torch.FloatTensor of size 1]

时间步 495000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.478532e+00/ 轮得分 4.61
损失函数： Variable containing:
 0.2505
[torch.FloatTensor of size 1]

时间步 496000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.405294e+00/ 轮得分 4.58
损失函数： Variable containing:
 0.2335
[torch.FloatTensor of size 1]

时间步 497000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.671231e+00/ 轮得分 4.57
损失函数： Variable containing:
 0.3891
[torch.FloatTensor of size 1]

时间步 498000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.009400e+00/ 轮得分 4.59
损失函数： Variable containing:
 0.1528
[torch.FloatTensor of size 1]

时间步 499000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.905421e+00/ 轮得分 4.57
损失函数： Variable containing:
 0.4432
[torch.FloatTensor of size 1]

时间步 500000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.685874e+00/ 轮得分 4.56
损失函数： Variable containing:
 0.4296
[torch.FloatTensor of size 1]

时间步 501000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.576466e+00/ 轮得分 4.55
损失函数： Variable containing:
 0.1534
[torch.FloatTensor of size 1]

时间步 502000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.157187e+00/ 轮得分 4.54
损失函数： Variable containing:
1.00000e-02 *
  9.8160
[torch.FloatTensor of size 1]

时间步 503000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.658876e+00/ 轮得分 4.54
损失函数： Variable containing:
 0.1302
[torch.FloatTensor of size 1]

时间步 504000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.513765e+00/ 轮得分 4.50
损失函数： Variable containing:
1.00000e-02 *
  8.1527
[torch.FloatTensor of size 1]

时间步 505000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.140902e+00/ 轮得分 4.50
损失函数： Variable containing:
 0.1150
[torch.FloatTensor of size 1]

时间步 506000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.265990e+00/ 轮得分 4.52
损失函数： Variable containing:
 0.1139
[torch.FloatTensor of size 1]

时间步 507000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.804654e-01/ 轮得分 4.53
损失函数： Variable containing:
 0.1231
[torch.FloatTensor of size 1]

时间步 508000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.599632e+00/ 轮得分 4.51
损失函数： Variable containing:
 0.1922
[torch.FloatTensor of size 1]

时间步 509000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.888539e+00/ 轮得分 4.49
损失函数： Variable containing:
 0.3957
[torch.FloatTensor of size 1]

时间步 510000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.247372e+00/ 轮得分 4.53
损失函数： Variable containing:
 0.4938
[torch.FloatTensor of size 1]

时间步 511000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.908566e+00/ 轮得分 4.53
损失函数： Variable containing:
1.00000e-02 *
  4.5085
[torch.FloatTensor of size 1]

时间步 512000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.953472e+00/ 轮得分 4.51
损失函数： Variable containing:
 0.1306
[torch.FloatTensor of size 1]

时间步 513000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 2.308192e+00/ 轮得分 4.52
损失函数： Variable containing:
 0.1466
[torch.FloatTensor of size 1]

时间步 514000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX -5.692038e-01/ 轮得分 4.49
损失函数： Variable containing:
 0.1042
[torch.FloatTensor of size 1]

时间步 515000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.877236e+00/ 轮得分 4.46
损失函数： Variable containing:
 0.1932
[torch.FloatTensor of size 1]

时间步 516000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.344380e+00/ 轮得分 4.47
损失函数： Variable containing:
 0.2239
[torch.FloatTensor of size 1]

时间步 517000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 1/ Q_MAX 1.036328e+00/ 轮得分 4.45
损失函数： Variable containing:
1.00000e-02 *
  4.3695
[torch.FloatTensor of size 1]

时间步 518000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.206339e+00/ 轮得分 4.42
损失函数： Variable containing:
 0.2425
[torch.FloatTensor of size 1]

时间步 519000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 9.189320e+00/ 轮得分 4.40
损失函数： Variable containing:
 0.1026
[torch.FloatTensor of size 1]

时间步 520000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.286446e+00/ 轮得分 4.37
损失函数： Variable containing:
 0.2698
[torch.FloatTensor of size 1]

时间步 521000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.290512e+00/ 轮得分 4.38
损失函数： Variable containing:
 0.1452
[torch.FloatTensor of size 1]

时间步 522000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.669345e+00/ 轮得分 4.37
损失函数： Variable containing:
1.00000e-02 *
  8.4838
[torch.FloatTensor of size 1]

时间步 523000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.870522e+00/ 轮得分 4.34
损失函数： Variable containing:
 0.1308
[torch.FloatTensor of size 1]

时间步 524000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.323731e+00/ 轮得分 4.33
损失函数： Variable containing:
 0.1645
[torch.FloatTensor of size 1]

时间步 525000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.048570e+00/ 轮得分 4.29
损失函数： Variable containing:
 0.1282
[torch.FloatTensor of size 1]

时间步 526000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.674719e+00/ 轮得分 4.24
损失函数： Variable containing:
1.00000e-02 *
  4.4970
[torch.FloatTensor of size 1]

时间步 527000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.456895e+00/ 轮得分 4.22
损失函数： Variable containing:
 0.1853
[torch.FloatTensor of size 1]

时间步 528000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 2.330010e+00/ 轮得分 4.19
损失函数： Variable containing:
 0.1182
[torch.FloatTensor of size 1]

时间步 529000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 1.000830e+01/ 轮得分 4.17
损失函数： Variable containing:
 1.3665
[torch.FloatTensor of size 1]

时间步 530000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 9.182565e+00/ 轮得分 4.12
损失函数： Variable containing:
1.00000e-02 *
  8.0628
[torch.FloatTensor of size 1]

时间步 531000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.425512e+00/ 轮得分 4.13
损失函数： Variable containing:
1.00000e-02 *
  7.9548
[torch.FloatTensor of size 1]

时间步 532000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.047157e+00/ 轮得分 4.11
损失函数： Variable containing:
 0.2027
[torch.FloatTensor of size 1]

时间步 533000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.787586e+00/ 轮得分 4.08
损失函数： Variable containing:
 0.1419
[torch.FloatTensor of size 1]

时间步 534000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 1.013631e+01/ 轮得分 4.07
损失函数： Variable containing:
 0.1366
[torch.FloatTensor of size 1]

时间步 535000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 1.066691e+01/ 轮得分 4.05
损失函数： Variable containing:
 0.1263
[torch.FloatTensor of size 1]

时间步 536000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 1.035022e+01/ 轮得分 4.01
损失函数： Variable containing:
 0.2073
[torch.FloatTensor of size 1]

时间步 537000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX -7.297578e-01/ 轮得分 3.95
损失函数： Variable containing:
 0.1369
[torch.FloatTensor of size 1]

时间步 538000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.425323e+00/ 轮得分 3.96
损失函数： Variable containing:
1.00000e-02 *
  9.3798
[torch.FloatTensor of size 1]

时间步 539000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 9.165685e+00/ 轮得分 3.94
损失函数： Variable containing:
1.00000e-02 *
  5.6941
[torch.FloatTensor of size 1]

时间步 540000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.268689e+00/ 轮得分 3.92
损失函数： Variable containing:
1.00000e-02 *
  4.7062
[torch.FloatTensor of size 1]

时间步 541000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 9.817330e+00/ 轮得分 3.90
损失函数： Variable containing:
 0.2163
[torch.FloatTensor of size 1]

时间步 542000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.913501e+00/ 轮得分 3.86
损失函数： Variable containing:
 0.1716
[torch.FloatTensor of size 1]

时间步 543000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.234545e+00/ 轮得分 3.85
损失函数： Variable containing:
1.00000e-02 *
  9.3532
[torch.FloatTensor of size 1]

时间步 544000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.462458e+00/ 轮得分 3.85
损失函数： Variable containing:
1.00000e-02 *
  7.8151
[torch.FloatTensor of size 1]

时间步 545000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.827049e+00/ 轮得分 3.86
损失函数： Variable containing:
 0.1264
[torch.FloatTensor of size 1]

时间步 546000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 9.643572e+00/ 轮得分 3.83
损失函数： Variable containing:
1.00000e-02 *
  5.6379
[torch.FloatTensor of size 1]

时间步 547000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 9.407983e+00/ 轮得分 3.80
损失函数： Variable containing:
 0.1207
[torch.FloatTensor of size 1]

时间步 548000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 9.516454e+00/ 轮得分 3.78
损失函数： Variable containing:
 0.4012
[torch.FloatTensor of size 1]

时间步 549000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.948076e+00/ 轮得分 3.75
损失函数： Variable containing:
 0.6455
[torch.FloatTensor of size 1]

时间步 550000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 9.579117e+00/ 轮得分 3.73
损失函数： Variable containing:
1.00000e-02 *
  7.2150
[torch.FloatTensor of size 1]

时间步 551000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 9.170980e+00/ 轮得分 3.69
损失函数： Variable containing:
1.00000e-02 *
  7.5708
[torch.FloatTensor of size 1]

时间步 552000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 9.871285e+00/ 轮得分 3.65
损失函数： Variable containing:
1.00000e-02 *
  3.9296
[torch.FloatTensor of size 1]

时间步 553000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 9.701045e+00/ 轮得分 3.61
损失函数： Variable containing:
1.00000e-02 *
  4.0452
[torch.FloatTensor of size 1]

时间步 554000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.241511e+00/ 轮得分 3.59
损失函数： Variable containing:
 0.1598
[torch.FloatTensor of size 1]

时间步 555000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.987335e+00/ 轮得分 3.57
损失函数： Variable containing:
1.00000e-02 *
  3.6382
[torch.FloatTensor of size 1]

时间步 556000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.806949e+00/ 轮得分 3.57
损失函数： Variable containing:
1.00000e-02 *
  9.8164
[torch.FloatTensor of size 1]

时间步 557000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.569355e+00/ 轮得分 3.54
损失函数： Variable containing:
1.00000e-02 *
  5.1574
[torch.FloatTensor of size 1]

时间步 558000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 2.784428e+00/ 轮得分 3.54
损失函数： Variable containing:
1.00000e-02 *
  5.7659
[torch.FloatTensor of size 1]

时间步 559000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.074914e+00/ 轮得分 3.53
损失函数： Variable containing:
1.00000e-02 *
  7.0591
[torch.FloatTensor of size 1]

时间步 560000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.839176e+00/ 轮得分 3.53
损失函数： Variable containing:
 0.1019
[torch.FloatTensor of size 1]

时间步 561000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.647146e+00/ 轮得分 3.52
损失函数： Variable containing:
1.00000e-02 *
  8.0402
[torch.FloatTensor of size 1]

时间步 562000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.360712e+00/ 轮得分 3.51
损失函数： Variable containing:
1.00000e-02 *
  3.2570
[torch.FloatTensor of size 1]

时间步 563000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.096866e+00/ 轮得分 3.52
损失函数： Variable containing:
1.00000e-02 *
  9.2401
[torch.FloatTensor of size 1]

时间步 564000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.148500e+00/ 轮得分 3.53
损失函数： Variable containing:
1.00000e-02 *
  3.1264
[torch.FloatTensor of size 1]

时间步 565000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.683270e+00/ 轮得分 3.50
损失函数： Variable containing:
 0.1020
[torch.FloatTensor of size 1]

时间步 566000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.845987e+00/ 轮得分 3.50
损失函数： Variable containing:
1.00000e-02 *
  2.0241
[torch.FloatTensor of size 1]

时间步 567000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.750630e+00/ 轮得分 3.48
损失函数： Variable containing:
1.00000e-02 *
  3.5010
[torch.FloatTensor of size 1]

时间步 568000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.277184e+00/ 轮得分 3.45
损失函数： Variable containing:
1.00000e-02 *
  6.6935
[torch.FloatTensor of size 1]

时间步 569000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 1.130793e+00/ 轮得分 3.43
损失函数： Variable containing:
1.00000e-02 *
  3.3882
[torch.FloatTensor of size 1]

时间步 570000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.294701e+00/ 轮得分 3.43
损失函数： Variable containing:
1.00000e-02 *
  2.4248
[torch.FloatTensor of size 1]

时间步 571000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.973022e+00/ 轮得分 3.43
损失函数： Variable containing:
1.00000e-02 *
  1.5821
[torch.FloatTensor of size 1]

时间步 572000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.190942e+00/ 轮得分 3.41
损失函数： Variable containing:
 0.1873
[torch.FloatTensor of size 1]

时间步 573000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.666987e+00/ 轮得分 3.41
损失函数： Variable containing:
 0.3130
[torch.FloatTensor of size 1]

时间步 574000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 9.167240e-01/ 轮得分 3.42
损失函数： Variable containing:
1.00000e-02 *
  3.2819
[torch.FloatTensor of size 1]

时间步 575000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.380058e+00/ 轮得分 3.41
损失函数： Variable containing:
1.00000e-02 *
  2.2288
[torch.FloatTensor of size 1]

时间步 576000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.862577e+00/ 轮得分 3.41
损失函数： Variable containing:
1.00000e-02 *
  9.3526
[torch.FloatTensor of size 1]

时间步 577000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.414704e+00/ 轮得分 3.39
损失函数： Variable containing:
1.00000e-02 *
  5.2027
[torch.FloatTensor of size 1]

时间步 578000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.636993e+00/ 轮得分 3.40
损失函数： Variable containing:
1.00000e-03 *
  7.9799
[torch.FloatTensor of size 1]

时间步 579000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.390056e+00/ 轮得分 3.39
损失函数： Variable containing:
1.00000e-02 *
  6.9696
[torch.FloatTensor of size 1]

时间步 580000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.787777e+00/ 轮得分 3.40
损失函数： Variable containing:
1.00000e-02 *
  4.0340
[torch.FloatTensor of size 1]

时间步 581000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.136467e+00/ 轮得分 3.40
损失函数： Variable containing:
1.00000e-02 *
  2.1321
[torch.FloatTensor of size 1]

时间步 582000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.996251e+00/ 轮得分 3.41
损失函数： Variable containing:
1.00000e-02 *
  1.9062
[torch.FloatTensor of size 1]

时间步 583000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 2.444374e+00/ 轮得分 3.43
损失函数： Variable containing:
1.00000e-02 *
  4.9511
[torch.FloatTensor of size 1]

时间步 584000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.842490e+00/ 轮得分 3.45
损失函数： Variable containing:
1.00000e-02 *
  4.2775
[torch.FloatTensor of size 1]

时间步 585000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.100554e+00/ 轮得分 3.46
损失函数： Variable containing:
1.00000e-02 *
  9.0078
[torch.FloatTensor of size 1]

时间步 586000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.097551e+00/ 轮得分 3.48
损失函数： Variable containing:
1.00000e-02 *
  3.3785
[torch.FloatTensor of size 1]

时间步 587000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.889677e+00/ 轮得分 3.49
损失函数： Variable containing:
1.00000e-02 *
  1.8425
[torch.FloatTensor of size 1]

时间步 588000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.924929e+00/ 轮得分 3.49
损失函数： Variable containing:
1.00000e-02 *
  3.6602
[torch.FloatTensor of size 1]

时间步 589000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.649343e+00/ 轮得分 3.49
损失函数： Variable containing:
1.00000e-02 *
  4.6582
[torch.FloatTensor of size 1]

时间步 590000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.916698e+00/ 轮得分 3.50
损失函数： Variable containing:
1.00000e-02 *
  1.7650
[torch.FloatTensor of size 1]

时间步 591000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.736674e+00/ 轮得分 3.52
损失函数： Variable containing:
1.00000e-02 *
  2.4063
[torch.FloatTensor of size 1]

时间步 592000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.377064e+00/ 轮得分 3.52
损失函数： Variable containing:
 0.1280
[torch.FloatTensor of size 1]

时间步 593000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.613412e+00/ 轮得分 3.51
损失函数： Variable containing:
1.00000e-02 *
  2.3740
[torch.FloatTensor of size 1]

时间步 594000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.870162e+00/ 轮得分 3.52
损失函数： Variable containing:
1.00000e-02 *
  5.8740
[torch.FloatTensor of size 1]

时间步 595000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 1.072086e-01/ 轮得分 3.52
损失函数： Variable containing:
1.00000e-02 *
  6.7441
[torch.FloatTensor of size 1]

时间步 596000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.226488e+00/ 轮得分 3.56
损失函数： Variable containing:
1.00000e-02 *
  2.0372
[torch.FloatTensor of size 1]

时间步 597000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 -1/ Q_MAX -1.642502e-01/ 轮得分 3.58
损失函数： Variable containing:
1.00000e-02 *
  2.0391
[torch.FloatTensor of size 1]

时间步 598000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.266744e+00/ 轮得分 3.56
损失函数： Variable containing:
1.00000e-02 *
  7.5152
[torch.FloatTensor of size 1]

时间步 599000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.507044e+00/ 轮得分 3.59
损失函数： Variable containing:
1.00000e-02 *
  5.8874
[torch.FloatTensor of size 1]

时间步 600000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.924660e+00/ 轮得分 3.58
损失函数： Variable containing:
1.00000e-02 *
  2.9432
[torch.FloatTensor of size 1]

时间步 601000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.180860e+00/ 轮得分 3.57
损失函数： Variable containing:
1.00000e-02 *
  7.3205
[torch.FloatTensor of size 1]

时间步 602000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.066906e+00/ 轮得分 3.57
损失函数： Variable containing:
1.00000e-02 *
  8.6313
[torch.FloatTensor of size 1]

时间步 603000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.880224e+00/ 轮得分 3.57
损失函数： Variable containing:
 0.1101
[torch.FloatTensor of size 1]

时间步 604000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.788334e+00/ 轮得分 3.58
损失函数： Variable containing:
 0.1370
[torch.FloatTensor of size 1]

时间步 605000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.665245e+00/ 轮得分 3.58
损失函数： Variable containing:
1.00000e-02 *
  1.6755
[torch.FloatTensor of size 1]

时间步 606000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.991008e+00/ 轮得分 3.58
损失函数： Variable containing:
1.00000e-02 *
  2.6938
[torch.FloatTensor of size 1]

时间步 607000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.460341e+00/ 轮得分 3.59
损失函数： Variable containing:
1.00000e-02 *
  4.1172
[torch.FloatTensor of size 1]

时间步 608000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.424664e+00/ 轮得分 3.60
损失函数： Variable containing:
1.00000e-02 *
  7.1748
[torch.FloatTensor of size 1]

时间步 609000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.775663e+00/ 轮得分 3.60
损失函数： Variable containing:
1.00000e-02 *
  3.8222
[torch.FloatTensor of size 1]

时间步 610000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX -6.947343e-01/ 轮得分 3.61
损失函数： Variable containing:
 0.1172
[torch.FloatTensor of size 1]

时间步 611000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 2.323335e+00/ 轮得分 3.63
损失函数： Variable containing:
1.00000e-02 *
  3.6816
[torch.FloatTensor of size 1]

时间步 612000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.014544e+00/ 轮得分 3.64
损失函数： Variable containing:
1.00000e-02 *
  2.6022
[torch.FloatTensor of size 1]

时间步 613000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.012498e+00/ 轮得分 3.64
损失函数： Variable containing:
1.00000e-02 *
  3.3763
[torch.FloatTensor of size 1]

时间步 614000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.658651e+00/ 轮得分 3.68
损失函数： Variable containing:
1.00000e-02 *
  2.1743
[torch.FloatTensor of size 1]

时间步 615000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.001602e+00/ 轮得分 3.68
损失函数： Variable containing:
1.00000e-02 *
  1.8762
[torch.FloatTensor of size 1]

时间步 616000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.521268e+00/ 轮得分 3.70
损失函数： Variable containing:
1.00000e-02 *
  2.9983
[torch.FloatTensor of size 1]

时间步 617000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.114262e+00/ 轮得分 3.72
损失函数： Variable containing:
1.00000e-02 *
  4.8823
[torch.FloatTensor of size 1]

时间步 618000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.390132e+00/ 轮得分 3.72
损失函数： Variable containing:
1.00000e-02 *
  3.9905
[torch.FloatTensor of size 1]

时间步 619000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.421728e+00/ 轮得分 3.76
损失函数： Variable containing:
1.00000e-02 *
  2.9477
[torch.FloatTensor of size 1]

时间步 620000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 1.992456e+00/ 轮得分 3.77
损失函数： Variable containing:
 0.1850
[torch.FloatTensor of size 1]

时间步 621000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.824628e+00/ 轮得分 3.80
损失函数： Variable containing:
1.00000e-02 *
  6.2116
[torch.FloatTensor of size 1]

时间步 622000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.005888e+00/ 轮得分 3.81
损失函数： Variable containing:
1.00000e-02 *
  3.7459
[torch.FloatTensor of size 1]

时间步 623000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.963865e+00/ 轮得分 3.80
损失函数： Variable containing:
1.00000e-02 *
  4.3894
[torch.FloatTensor of size 1]

时间步 624000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.009742e+00/ 轮得分 3.81
损失函数： Variable containing:
1.00000e-02 *
  2.4294
[torch.FloatTensor of size 1]

时间步 625000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.688143e+00/ 轮得分 3.84
损失函数： Variable containing:
1.00000e-02 *
  3.4202
[torch.FloatTensor of size 1]

时间步 626000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.144826e+00/ 轮得分 3.86
损失函数： Variable containing:
 0.1121
[torch.FloatTensor of size 1]

时间步 627000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.990902e+00/ 轮得分 3.89
损失函数： Variable containing:
 0.5902
[torch.FloatTensor of size 1]

时间步 628000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.993942e+00/ 轮得分 3.92
损失函数： Variable containing:
 0.2120
[torch.FloatTensor of size 1]

时间步 629000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.368276e+00/ 轮得分 3.91
损失函数： Variable containing:
1.00000e-02 *
  6.7971
[torch.FloatTensor of size 1]

时间步 630000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.268814e+00/ 轮得分 3.93
损失函数： Variable containing:
1.00000e-02 *
  9.1595
[torch.FloatTensor of size 1]

时间步 631000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.097971e+00/ 轮得分 3.92
损失函数： Variable containing:
1.00000e-02 *
  8.4589
[torch.FloatTensor of size 1]

时间步 632000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.570199e+00/ 轮得分 3.90
损失函数： Variable containing:
1.00000e-02 *
  2.8620
[torch.FloatTensor of size 1]

时间步 633000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.819525e+00/ 轮得分 3.90
损失函数： Variable containing:
1.00000e-02 *
  1.7283
[torch.FloatTensor of size 1]

时间步 634000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.285655e+00/ 轮得分 3.91
损失函数： Variable containing:
1.00000e-02 *
  3.7847
[torch.FloatTensor of size 1]

时间步 635000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.369313e+00/ 轮得分 3.94
损失函数： Variable containing:
1.00000e-02 *
  2.9786
[torch.FloatTensor of size 1]

时间步 636000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.812763e+00/ 轮得分 3.96
损失函数： Variable containing:
1.00000e-02 *
  9.0300
[torch.FloatTensor of size 1]

时间步 637000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.043895e+00/ 轮得分 4.01
损失函数： Variable containing:
1.00000e-02 *
  8.4233
[torch.FloatTensor of size 1]

时间步 638000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.104314e+00/ 轮得分 4.02
损失函数： Variable containing:
1.00000e-02 *
  9.2173
[torch.FloatTensor of size 1]

时间步 639000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.587784e+00/ 轮得分 4.02
损失函数： Variable containing:
1.00000e-02 *
  5.7097
[torch.FloatTensor of size 1]

时间步 640000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 2.778253e+00/ 轮得分 4.02
损失函数： Variable containing:
 0.1075
[torch.FloatTensor of size 1]

时间步 641000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.351988e+00/ 轮得分 4.08
损失函数： Variable containing:
 0.1864
[torch.FloatTensor of size 1]

时间步 642000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.617554e+00/ 轮得分 4.10
损失函数： Variable containing:
1.00000e-02 *
  2.6721
[torch.FloatTensor of size 1]

时间步 643000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.806123e+00/ 轮得分 4.12
损失函数： Variable containing:
 0.1508
[torch.FloatTensor of size 1]

时间步 644000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.456598e+00/ 轮得分 4.13
损失函数： Variable containing:
 0.1035
[torch.FloatTensor of size 1]

时间步 645000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.168351e+00/ 轮得分 4.15
损失函数： Variable containing:
 0.1040
[torch.FloatTensor of size 1]

时间步 646000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.844677e+00/ 轮得分 4.17
损失函数： Variable containing:
 0.1595
[torch.FloatTensor of size 1]

时间步 647000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.870460e+00/ 轮得分 4.18
损失函数： Variable containing:
 0.2523
[torch.FloatTensor of size 1]

时间步 648000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.194910e+00/ 轮得分 4.19
损失函数： Variable containing:
1.00000e-02 *
  3.6042
[torch.FloatTensor of size 1]

时间步 649000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.478555e+00/ 轮得分 4.18
损失函数： Variable containing:
1.00000e-02 *
  2.0351
[torch.FloatTensor of size 1]

时间步 650000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.421003e+00/ 轮得分 4.19
损失函数： Variable containing:
1.00000e-02 *
  9.5882
[torch.FloatTensor of size 1]

时间步 651000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.219811e+00/ 轮得分 4.24
损失函数： Variable containing:
1.00000e-02 *
  9.7680
[torch.FloatTensor of size 1]

时间步 652000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.347187e+00/ 轮得分 4.27
损失函数： Variable containing:
 0.1380
[torch.FloatTensor of size 1]

时间步 653000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 -1/ Q_MAX 4.802251e-01/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-02 *
  1.5122
[torch.FloatTensor of size 1]

时间步 654000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.917054e+00/ 轮得分 4.33
损失函数： Variable containing:
1.00000e-02 *
  3.0562
[torch.FloatTensor of size 1]

时间步 655000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.784899e+00/ 轮得分 4.32
损失函数： Variable containing:
1.00000e-02 *
  4.8204
[torch.FloatTensor of size 1]

时间步 656000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.483684e+00/ 轮得分 4.35
损失函数： Variable containing:
1.00000e-02 *
  6.0909
[torch.FloatTensor of size 1]

时间步 657000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.468825e+00/ 轮得分 4.35
损失函数： Variable containing:
1.00000e-02 *
  7.6349
[torch.FloatTensor of size 1]

时间步 658000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.629525e+00/ 轮得分 4.35
损失函数： Variable containing:
1.00000e-02 *
  6.0021
[torch.FloatTensor of size 1]

时间步 659000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.414773e+00/ 轮得分 4.36
损失函数： Variable containing:
 0.1017
[torch.FloatTensor of size 1]

时间步 660000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.541504e+00/ 轮得分 4.35
损失函数： Variable containing:
1.00000e-02 *
  8.1435
[torch.FloatTensor of size 1]

时间步 661000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.145018e+00/ 轮得分 4.37
损失函数： Variable containing:
1.00000e-02 *
  7.2995
[torch.FloatTensor of size 1]

时间步 662000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.138884e+00/ 轮得分 4.37
损失函数： Variable containing:
 0.7228
[torch.FloatTensor of size 1]

时间步 663000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.652884e+00/ 轮得分 4.38
损失函数： Variable containing:
1.00000e-02 *
  7.7234
[torch.FloatTensor of size 1]

时间步 664000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.333730e+00/ 轮得分 4.39
损失函数： Variable containing:
 0.2658
[torch.FloatTensor of size 1]

时间步 665000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 1.987038e+00/ 轮得分 4.41
损失函数： Variable containing:
1.00000e-02 *
  7.2992
[torch.FloatTensor of size 1]

时间步 666000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.103281e+00/ 轮得分 4.38
损失函数： Variable containing:
1.00000e-02 *
  5.8871
[torch.FloatTensor of size 1]

时间步 667000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.436697e+00/ 轮得分 4.41
损失函数： Variable containing:
1.00000e-02 *
  3.5771
[torch.FloatTensor of size 1]

时间步 668000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.245127e+00/ 轮得分 4.42
损失函数： Variable containing:
1.00000e-02 *
  8.1190
[torch.FloatTensor of size 1]

时间步 669000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.139745e+00/ 轮得分 4.41
损失函数： Variable containing:
1.00000e-02 *
  4.3860
[torch.FloatTensor of size 1]

时间步 670000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.191355e+00/ 轮得分 4.40
损失函数： Variable containing:
 0.3493
[torch.FloatTensor of size 1]

时间步 671000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.308913e+00/ 轮得分 4.40
损失函数： Variable containing:
1.00000e-02 *
  8.4012
[torch.FloatTensor of size 1]

时间步 672000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.159694e+00/ 轮得分 4.39
损失函数： Variable containing:
1.00000e-02 *
  3.2079
[torch.FloatTensor of size 1]

时间步 673000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.876071e+00/ 轮得分 4.42
损失函数： Variable containing:
 0.2866
[torch.FloatTensor of size 1]

时间步 674000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 2.003785e+00/ 轮得分 4.41
损失函数： Variable containing:
1.00000e-02 *
  4.8112
[torch.FloatTensor of size 1]

时间步 675000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.656945e+00/ 轮得分 4.43
损失函数： Variable containing:
 0.1760
[torch.FloatTensor of size 1]

时间步 676000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.188522e+00/ 轮得分 4.45
损失函数： Variable containing:
 0.1349
[torch.FloatTensor of size 1]

时间步 677000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.663997e+00/ 轮得分 4.43
损失函数： Variable containing:
1.00000e-02 *
  5.0453
[torch.FloatTensor of size 1]

时间步 678000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.328012e+00/ 轮得分 4.44
损失函数： Variable containing:
1.00000e-02 *
  8.6266
[torch.FloatTensor of size 1]

时间步 679000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.313798e+00/ 轮得分 4.42
损失函数： Variable containing:
1.00000e-02 *
  4.1891
[torch.FloatTensor of size 1]

时间步 680000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.840471e+00/ 轮得分 4.42
损失函数： Variable containing:
 0.1040
[torch.FloatTensor of size 1]

时间步 681000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.982079e+00/ 轮得分 4.49
损失函数： Variable containing:
 0.5401
[torch.FloatTensor of size 1]

时间步 682000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.168094e+00/ 轮得分 4.51
损失函数： Variable containing:
1.00000e-02 *
  3.8777
[torch.FloatTensor of size 1]

时间步 683000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.557064e+00/ 轮得分 4.53
损失函数： Variable containing:
1.00000e-02 *
  4.4103
[torch.FloatTensor of size 1]

时间步 684000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.325695e+00/ 轮得分 4.54
损失函数： Variable containing:
1.00000e-02 *
  3.9358
[torch.FloatTensor of size 1]

时间步 685000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.346534e+00/ 轮得分 4.57
损失函数： Variable containing:
1.00000e-02 *
  6.0847
[torch.FloatTensor of size 1]

时间步 686000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.396455e+00/ 轮得分 4.58
损失函数： Variable containing:
1.00000e-02 *
  3.8550
[torch.FloatTensor of size 1]

时间步 687000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.543160e+00/ 轮得分 4.59
损失函数： Variable containing:
 0.2533
[torch.FloatTensor of size 1]

时间步 688000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.317168e+00/ 轮得分 4.58
损失函数： Variable containing:
1.00000e-02 *
  3.7007
[torch.FloatTensor of size 1]

时间步 689000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.366392e+00/ 轮得分 4.52
损失函数： Variable containing:
1.00000e-02 *
  8.3263
[torch.FloatTensor of size 1]

时间步 690000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.838066e+00/ 轮得分 4.51
损失函数： Variable containing:
 0.1483
[torch.FloatTensor of size 1]

时间步 691000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.636801e+00/ 轮得分 4.53
损失函数： Variable containing:
 0.3572
[torch.FloatTensor of size 1]

时间步 692000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.462094e+00/ 轮得分 4.53
损失函数： Variable containing:
1.00000e-02 *
  2.4665
[torch.FloatTensor of size 1]

时间步 693000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.342949e+00/ 轮得分 4.51
损失函数： Variable containing:
1.00000e-02 *
  6.6205
[torch.FloatTensor of size 1]

时间步 694000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.966805e+00/ 轮得分 4.50
损失函数： Variable containing:
1.00000e-02 *
  7.0685
[torch.FloatTensor of size 1]

时间步 695000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.069536e+00/ 轮得分 4.50
损失函数： Variable containing:
 0.1308
[torch.FloatTensor of size 1]

时间步 696000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.649932e+00/ 轮得分 4.51
损失函数： Variable containing:
1.00000e-02 *
  7.1444
[torch.FloatTensor of size 1]

时间步 697000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 9.291472e+00/ 轮得分 4.54
损失函数： Variable containing:
 0.2550
[torch.FloatTensor of size 1]

时间步 698000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.652285e+00/ 轮得分 4.53
损失函数： Variable containing:
1.00000e-02 *
  4.6329
[torch.FloatTensor of size 1]

时间步 699000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.509912e+00/ 轮得分 4.51
损失函数： Variable containing:
1.00000e-02 *
  8.1688
[torch.FloatTensor of size 1]

时间步 700000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.880991e+00/ 轮得分 4.51
损失函数： Variable containing:
 0.2966
[torch.FloatTensor of size 1]

时间步 701000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.335852e+00/ 轮得分 4.53
损失函数： Variable containing:
1.00000e-02 *
  6.5759
[torch.FloatTensor of size 1]

时间步 702000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.494904e+00/ 轮得分 4.56
损失函数： Variable containing:
1.00000e-02 *
  6.0395
[torch.FloatTensor of size 1]

时间步 703000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.195168e+00/ 轮得分 4.56
损失函数： Variable containing:
1.00000e-02 *
  3.5399
[torch.FloatTensor of size 1]

时间步 704000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.908366e+00/ 轮得分 4.53
损失函数： Variable containing:
 0.1058
[torch.FloatTensor of size 1]

时间步 705000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.357394e+00/ 轮得分 4.53
损失函数： Variable containing:
 0.1370
[torch.FloatTensor of size 1]

时间步 706000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.870574e+00/ 轮得分 4.51
损失函数： Variable containing:
1.00000e-02 *
  4.9443
[torch.FloatTensor of size 1]

时间步 707000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.326526e+00/ 轮得分 4.51
损失函数： Variable containing:
1.00000e-02 *
  3.3188
[torch.FloatTensor of size 1]

时间步 708000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.616529e+00/ 轮得分 4.51
损失函数： Variable containing:
1.00000e-02 *
  4.7016
[torch.FloatTensor of size 1]

时间步 709000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.402902e+00/ 轮得分 4.54
损失函数： Variable containing:
 0.3123
[torch.FloatTensor of size 1]

时间步 710000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.624420e+00/ 轮得分 4.55
损失函数： Variable containing:
1.00000e-02 *
  8.7366
[torch.FloatTensor of size 1]

时间步 711000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.073571e+00/ 轮得分 4.55
损失函数： Variable containing:
1.00000e-02 *
  8.9025
[torch.FloatTensor of size 1]

时间步 712000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.490974e+00/ 轮得分 4.55
损失函数： Variable containing:
1.00000e-02 *
  8.2900
[torch.FloatTensor of size 1]

时间步 713000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.785096e+00/ 轮得分 4.57
损失函数： Variable containing:
1.00000e-02 *
  5.0640
[torch.FloatTensor of size 1]

时间步 714000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.684696e+00/ 轮得分 4.57
损失函数： Variable containing:
1.00000e-02 *
  7.1234
[torch.FloatTensor of size 1]

时间步 715000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.185677e+00/ 轮得分 4.60
损失函数： Variable containing:
1.00000e-02 *
  5.6456
[torch.FloatTensor of size 1]

时间步 716000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.851161e+00/ 轮得分 4.61
损失函数： Variable containing:
1.00000e-02 *
  7.3818
[torch.FloatTensor of size 1]

时间步 717000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.455946e+00/ 轮得分 4.63
损失函数： Variable containing:
 0.1084
[torch.FloatTensor of size 1]

时间步 718000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.442046e+00/ 轮得分 4.64
损失函数： Variable containing:
1.00000e-02 *
  9.9443
[torch.FloatTensor of size 1]

时间步 719000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.846304e+00/ 轮得分 4.63
损失函数： Variable containing:
1.00000e-02 *
  9.2851
[torch.FloatTensor of size 1]

时间步 720000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.938630e+00/ 轮得分 4.64
损失函数： Variable containing:
1.00000e-02 *
  5.3229
[torch.FloatTensor of size 1]

时间步 721000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.611383e+00/ 轮得分 4.65
损失函数： Variable containing:
1.00000e-02 *
  6.0674
[torch.FloatTensor of size 1]

时间步 722000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.007263e+00/ 轮得分 4.67
损失函数： Variable containing:
 0.2109
[torch.FloatTensor of size 1]

时间步 723000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 3.941078e+00/ 轮得分 4.69
损失函数： Variable containing:
1.00000e-02 *
  3.1579
[torch.FloatTensor of size 1]

时间步 724000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.326959e+00/ 轮得分 4.71
损失函数： Variable containing:
 0.1533
[torch.FloatTensor of size 1]

时间步 725000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.404627e+00/ 轮得分 4.72
损失函数： Variable containing:
1.00000e-02 *
  5.1673
[torch.FloatTensor of size 1]

时间步 726000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.317223e+00/ 轮得分 4.78
损失函数： Variable containing:
 0.1160
[torch.FloatTensor of size 1]

时间步 727000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.526779e+00/ 轮得分 4.84
损失函数： Variable containing:
 0.1469
[torch.FloatTensor of size 1]

时间步 728000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.802222e+00/ 轮得分 4.84
损失函数： Variable containing:
 0.1103
[torch.FloatTensor of size 1]

时间步 729000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 2.995920e+00/ 轮得分 4.86
损失函数： Variable containing:
 0.1039
[torch.FloatTensor of size 1]

时间步 730000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.668383e+00/ 轮得分 4.86
损失函数： Variable containing:
 0.2921
[torch.FloatTensor of size 1]

时间步 731000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.423178e+00/ 轮得分 4.91
损失函数： Variable containing:
1.00000e-02 *
  6.9382
[torch.FloatTensor of size 1]

时间步 732000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.976577e+00/ 轮得分 4.92
损失函数： Variable containing:
 0.1302
[torch.FloatTensor of size 1]

时间步 733000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.235021e+00/ 轮得分 4.95
损失函数： Variable containing:
1.00000e-02 *
  5.6923
[torch.FloatTensor of size 1]

时间步 734000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.156199e+00/ 轮得分 4.94
损失函数： Variable containing:
 0.1488
[torch.FloatTensor of size 1]

时间步 735000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.517673e+00/ 轮得分 4.95
损失函数： Variable containing:
1.00000e-02 *
  9.9093
[torch.FloatTensor of size 1]

时间步 736000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.778960e+00/ 轮得分 4.93
损失函数： Variable containing:
 0.1737
[torch.FloatTensor of size 1]

时间步 737000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.121263e+00/ 轮得分 4.91
损失函数： Variable containing:
 0.1093
[torch.FloatTensor of size 1]

时间步 738000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.898055e+00/ 轮得分 4.90
损失函数： Variable containing:
 0.1162
[torch.FloatTensor of size 1]

时间步 739000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 4.281465e+00/ 轮得分 4.91
损失函数： Variable containing:
 0.1543
[torch.FloatTensor of size 1]

时间步 740000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.378765e+00/ 轮得分 4.92
损失函数： Variable containing:
1.00000e-02 *
  5.3995
[torch.FloatTensor of size 1]

时间步 741000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.836736e+00/ 轮得分 4.93
损失函数： Variable containing:
 0.1215
[torch.FloatTensor of size 1]

时间步 742000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.711775e+00/ 轮得分 4.92
损失函数： Variable containing:
 0.1726
[torch.FloatTensor of size 1]

时间步 743000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.479308e+00/ 轮得分 4.92
损失函数： Variable containing:
 0.1030
[torch.FloatTensor of size 1]

时间步 744000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.208384e+00/ 轮得分 4.92
损失函数： Variable containing:
1.00000e-02 *
  9.4080
[torch.FloatTensor of size 1]

时间步 745000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 6.623540e+00/ 轮得分 4.94
损失函数： Variable containing:
1.00000e-02 *
  9.6490
[torch.FloatTensor of size 1]

时间步 746000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.919075e+00/ 轮得分 4.98
损失函数： Variable containing:
 0.1041
[torch.FloatTensor of size 1]

时间步 747000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.161046e+00/ 轮得分 4.98
损失函数： Variable containing:
1.00000e-02 *
  4.2420
[torch.FloatTensor of size 1]

时间步 748000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.337006e+00/ 轮得分 4.97
损失函数： Variable containing:
1.00000e-02 *
  8.4202
[torch.FloatTensor of size 1]

时间步 749000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.089469e+00/ 轮得分 4.97
损失函数： Variable containing:
1.00000e-02 *
  4.8712
[torch.FloatTensor of size 1]

时间步 750000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.637947e+00/ 轮得分 5.00
损失函数： Variable containing:
 0.2256
[torch.FloatTensor of size 1]

时间步 751000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.488914e+00/ 轮得分 5.01
损失函数： Variable containing:
 0.1013
[torch.FloatTensor of size 1]

时间步 752000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.047885e+00/ 轮得分 5.00
损失函数： Variable containing:
1.00000e-02 *
  3.3467
[torch.FloatTensor of size 1]

时间步 753000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.842008e+00/ 轮得分 4.97
损失函数： Variable containing:
1.00000e-02 *
  7.3984
[torch.FloatTensor of size 1]

时间步 754000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 7.115561e+00/ 轮得分 4.96
损失函数： Variable containing:
1.00000e-02 *
  7.7584
[torch.FloatTensor of size 1]

时间步 755000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.985937e+00/ 轮得分 5.02
损失函数： Variable containing:
1.00000e-02 *
  6.9160
[torch.FloatTensor of size 1]

时间步 756000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 9.740478e+00/ 轮得分 5.04
损失函数： Variable containing:
 0.5457
[torch.FloatTensor of size 1]

时间步 757000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 5.576454e+00/ 轮得分 5.04
损失函数： Variable containing:
1.00000e-02 *
  8.8269
[torch.FloatTensor of size 1]

时间步 758000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.304893e+00/ 轮得分 5.05
损失函数： Variable containing:
 0.1492
[torch.FloatTensor of size 1]

时间步 759000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 8.078030e+00/ 轮得分 5.04
损失函数： Variable containing:
1.00000e-02 *
  9.4559
[torch.FloatTensor of size 1]

时间步 760000/ 状态 explore/ Epsilon 0.08/ 行动 0/ 奖励 0.1/ Q_MAX 1.408140e+00/ 轮得分 5.05
损失函数： Variable containing:
 0.3317
[torch.FloatTensor of size 1]

时间步 761000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.613992e+00/ 轮得分 5.04
损失函数： Variable containing:
 0.1459
[torch.FloatTensor of size 1]

时间步 762000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.470189e+00/ 轮得分 5.04
损失函数： Variable containing:
1.00000e-02 *
  9.4677
[torch.FloatTensor of size 1]

时间步 763000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 4.951382e-01/ 轮得分 5.01
损失函数： Variable containing:
 0.1078
[torch.FloatTensor of size 1]

时间步 764000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.085454e+00/ 轮得分 5.01
损失函数： Variable containing:
1.00000e-02 *
  9.8084
[torch.FloatTensor of size 1]

时间步 765000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.001978e+01/ 轮得分 4.97
损失函数： Variable containing:
1.00000e-02 *
  5.0650
[torch.FloatTensor of size 1]

时间步 766000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 5.637676e+00/ 轮得分 4.95
损失函数： Variable containing:
 0.1524
[torch.FloatTensor of size 1]

时间步 767000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 4.068853e+00/ 轮得分 4.94
损失函数： Variable containing:
 0.5119
[torch.FloatTensor of size 1]

时间步 768000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.073318e+01/ 轮得分 4.97
损失函数： Variable containing:
 0.1684
[torch.FloatTensor of size 1]

时间步 769000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 6.629106e+00/ 轮得分 4.96
损失函数： Variable containing:
 0.1860
[torch.FloatTensor of size 1]

时间步 770000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.450769e-01/ 轮得分 4.95
损失函数： Variable containing:
 0.3553
[torch.FloatTensor of size 1]

时间步 771000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.644117e+00/ 轮得分 4.91
损失函数： Variable containing:
1.00000e-02 *
  9.3048
[torch.FloatTensor of size 1]

时间步 772000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 2.927793e+00/ 轮得分 4.92
损失函数： Variable containing:
 0.3028
[torch.FloatTensor of size 1]

时间步 773000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 5.171505e+00/ 轮得分 4.90
损失函数： Variable containing:
 0.2634
[torch.FloatTensor of size 1]

时间步 774000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.899482e+00/ 轮得分 4.89
损失函数： Variable containing:
 0.1019
[torch.FloatTensor of size 1]

时间步 775000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.004045e+01/ 轮得分 4.87
损失函数： Variable containing:
1.00000e-02 *
  5.8861
[torch.FloatTensor of size 1]

时间步 776000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 6.609706e+00/ 轮得分 4.91
损失函数： Variable containing:
 0.1641
[torch.FloatTensor of size 1]

时间步 777000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.794863e+00/ 轮得分 4.94
损失函数： Variable containing:
1.00000e-02 *
  7.1786
[torch.FloatTensor of size 1]

时间步 778000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.895391e+00/ 轮得分 4.90
损失函数： Variable containing:
1.00000e-02 *
  3.9808
[torch.FloatTensor of size 1]

时间步 779000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.003364e+01/ 轮得分 4.89
损失函数： Variable containing:
 0.3049
[torch.FloatTensor of size 1]

时间步 780000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 6.989982e+00/ 轮得分 4.88
损失函数： Variable containing:
 1.3554
[torch.FloatTensor of size 1]

时间步 781000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.587468e+00/ 轮得分 4.85
损失函数： Variable containing:
 1.0966
[torch.FloatTensor of size 1]

时间步 782000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.624921e+00/ 轮得分 4.79
损失函数： Variable containing:
 0.2076
[torch.FloatTensor of size 1]

时间步 783000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 6.102924e+00/ 轮得分 4.78
损失函数： Variable containing:
1.00000e-02 *
  5.8323
[torch.FloatTensor of size 1]

时间步 784000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.919415e+00/ 轮得分 4.75
损失函数： Variable containing:
 0.1082
[torch.FloatTensor of size 1]

时间步 785000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 -1/ Q_MAX 1.088471e+01/ 轮得分 4.70
损失函数： Variable containing:
1.00000e-02 *
  5.7465
[torch.FloatTensor of size 1]

时间步 786000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.082530e+01/ 轮得分 4.65
损失函数： Variable containing:
 0.1704
[torch.FloatTensor of size 1]

时间步 787000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 5.657656e+00/ 轮得分 4.69
损失函数： Variable containing:
 0.2670
[torch.FloatTensor of size 1]

时间步 788000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.650827e+00/ 轮得分 4.71
损失函数： Variable containing:
 0.2565
[torch.FloatTensor of size 1]

时间步 789000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.903725e+00/ 轮得分 4.68
损失函数： Variable containing:
1.00000e-02 *
  9.9106
[torch.FloatTensor of size 1]

时间步 790000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.703662e+00/ 轮得分 4.71
损失函数： Variable containing:
 0.1255
[torch.FloatTensor of size 1]

时间步 791000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.421048e+00/ 轮得分 4.67
损失函数： Variable containing:
1.00000e-02 *
  9.0504
[torch.FloatTensor of size 1]

时间步 792000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.400106e+00/ 轮得分 4.67
损失函数： Variable containing:
1.00000e-02 *
  3.1437
[torch.FloatTensor of size 1]

时间步 793000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.487808e+00/ 轮得分 4.67
损失函数： Variable containing:
1.00000e-02 *
  9.7005
[torch.FloatTensor of size 1]

时间步 794000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.085611e+00/ 轮得分 4.67
损失函数： Variable containing:
1.00000e-02 *
  2.3444
[torch.FloatTensor of size 1]

时间步 795000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.191952e+00/ 轮得分 4.69
损失函数： Variable containing:
 0.2084
[torch.FloatTensor of size 1]

时间步 796000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.834474e+00/ 轮得分 4.68
损失函数： Variable containing:
1.00000e-02 *
  9.5583
[torch.FloatTensor of size 1]

时间步 797000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.042005e+01/ 轮得分 4.68
损失函数： Variable containing:
1.00000e-02 *
  2.9953
[torch.FloatTensor of size 1]

时间步 798000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.262509e+00/ 轮得分 4.68
损失函数： Variable containing:
 0.1756
[torch.FloatTensor of size 1]

时间步 799000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.643373e+00/ 轮得分 4.64
损失函数： Variable containing:
 0.1818
[torch.FloatTensor of size 1]

时间步 800000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.848341e+00/ 轮得分 4.60
损失函数： Variable containing:
 0.1068
[torch.FloatTensor of size 1]

时间步 801000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.047868e+01/ 轮得分 4.61
损失函数： Variable containing:
 0.2598
[torch.FloatTensor of size 1]

时间步 802000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.005512e+01/ 轮得分 4.64
损失函数： Variable containing:
1.00000e-02 *
  6.8418
[torch.FloatTensor of size 1]

时间步 803000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 6.475902e+00/ 轮得分 4.64
损失函数： Variable containing:
 0.5293
[torch.FloatTensor of size 1]

时间步 804000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.588854e+00/ 轮得分 4.64
损失函数： Variable containing:
 0.1414
[torch.FloatTensor of size 1]

时间步 805000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.184536e+00/ 轮得分 4.65
损失函数： Variable containing:
 0.2100
[torch.FloatTensor of size 1]

时间步 806000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 5.782012e+00/ 轮得分 4.66
损失函数： Variable containing:
 0.2424
[torch.FloatTensor of size 1]

时间步 807000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.885406e+00/ 轮得分 4.68
损失函数： Variable containing:
1.00000e-02 *
  5.7056
[torch.FloatTensor of size 1]

时间步 808000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.666492e+00/ 轮得分 4.60
损失函数： Variable containing:
1.00000e-02 *
  8.9019
[torch.FloatTensor of size 1]

时间步 809000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.389928e+00/ 轮得分 4.63
损失函数： Variable containing:
 0.1736
[torch.FloatTensor of size 1]

时间步 810000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.002621e+01/ 轮得分 4.66
损失函数： Variable containing:
1.00000e-02 *
  3.4643
[torch.FloatTensor of size 1]

时间步 811000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.617343e+00/ 轮得分 4.66
损失函数： Variable containing:
 0.2896
[torch.FloatTensor of size 1]

时间步 812000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 6.163778e+00/ 轮得分 4.65
损失函数： Variable containing:
 0.4014
[torch.FloatTensor of size 1]

时间步 813000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 5.876341e+00/ 轮得分 4.69
损失函数： Variable containing:
1.00000e-02 *
  6.8832
[torch.FloatTensor of size 1]

时间步 814000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.945156e+00/ 轮得分 4.70
损失函数： Variable containing:
 0.2693
[torch.FloatTensor of size 1]

时间步 815000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.932110e+00/ 轮得分 4.69
损失函数： Variable containing:
 0.1395
[torch.FloatTensor of size 1]

时间步 816000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.011439e+01/ 轮得分 4.72
损失函数： Variable containing:
 0.2211
[torch.FloatTensor of size 1]

时间步 817000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 1/ Q_MAX 8.323631e+00/ 轮得分 4.70
损失函数： Variable containing:
1.00000e-02 *
  5.1144
[torch.FloatTensor of size 1]

时间步 818000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.702004e+00/ 轮得分 4.70
损失函数： Variable containing:
 0.2877
[torch.FloatTensor of size 1]

时间步 819000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.935163e+00/ 轮得分 4.70
损失函数： Variable containing:
 0.1484
[torch.FloatTensor of size 1]

时间步 820000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.093647e+00/ 轮得分 4.72
损失函数： Variable containing:
1.00000e-02 *
  5.6686
[torch.FloatTensor of size 1]

时间步 821000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.341781e+00/ 轮得分 4.71
损失函数： Variable containing:
 0.1670
[torch.FloatTensor of size 1]

时间步 822000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.525272e+00/ 轮得分 4.72
损失函数： Variable containing:
 0.1954
[torch.FloatTensor of size 1]

时间步 823000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.074293e+01/ 轮得分 4.71
损失函数： Variable containing:
 0.1051
[torch.FloatTensor of size 1]

时间步 824000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 5.682154e+00/ 轮得分 4.73
损失函数： Variable containing:
 0.1166
[torch.FloatTensor of size 1]

时间步 825000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 5.201239e+00/ 轮得分 4.73
损失函数： Variable containing:
 0.8003
[torch.FloatTensor of size 1]

时间步 826000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.919317e+00/ 轮得分 4.75
损失函数： Variable containing:
 0.2428
[torch.FloatTensor of size 1]

时间步 827000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.048053e+00/ 轮得分 4.74
损失函数： Variable containing:
 0.2896
[torch.FloatTensor of size 1]

时间步 828000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.209698e+00/ 轮得分 4.77
损失函数： Variable containing:
1.00000e-02 *
  8.7512
[torch.FloatTensor of size 1]

时间步 829000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.355278e+00/ 轮得分 4.80
损失函数： Variable containing:
 0.1412
[torch.FloatTensor of size 1]

时间步 830000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.513616e+00/ 轮得分 4.82
损失函数： Variable containing:
 0.3299
[torch.FloatTensor of size 1]

时间步 831000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.134548e+01/ 轮得分 4.80
损失函数： Variable containing:
 0.2761
[torch.FloatTensor of size 1]

时间步 832000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.270872e+00/ 轮得分 4.80
损失函数： Variable containing:
 0.2836
[torch.FloatTensor of size 1]

时间步 833000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.128106e+01/ 轮得分 4.83
损失函数： Variable containing:
 0.2886
[torch.FloatTensor of size 1]

时间步 834000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 -1/ Q_MAX 1.563215e+00/ 轮得分 4.84
损失函数： Variable containing:
 0.2196
[torch.FloatTensor of size 1]

时间步 835000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.198102e+01/ 轮得分 4.88
损失函数： Variable containing:
 0.1266
[torch.FloatTensor of size 1]

时间步 836000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.108082e+01/ 轮得分 4.85
损失函数： Variable containing:
1.00000e-02 *
  6.5835
[torch.FloatTensor of size 1]

时间步 837000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.394132e+00/ 轮得分 4.86
损失函数： Variable containing:
 0.4171
[torch.FloatTensor of size 1]

时间步 838000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.199724e+01/ 轮得分 4.90
损失函数： Variable containing:
 0.2243
[torch.FloatTensor of size 1]

时间步 839000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.574192e+00/ 轮得分 4.89
损失函数： Variable containing:
 0.1099
[torch.FloatTensor of size 1]

时间步 840000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.251958e+01/ 轮得分 4.88
损失函数： Variable containing:
1.00000e-02 *
  5.0526
[torch.FloatTensor of size 1]

时间步 841000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.190070e+00/ 轮得分 4.91
损失函数： Variable containing:
 0.1747
[torch.FloatTensor of size 1]

时间步 842000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.150289e+01/ 轮得分 4.89
损失函数： Variable containing:
 0.1592
[torch.FloatTensor of size 1]

时间步 843000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.261600e+01/ 轮得分 4.89
损失函数： Variable containing:
 0.7033
[torch.FloatTensor of size 1]

时间步 844000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.922487e+00/ 轮得分 4.91
损失函数： Variable containing:
 0.1944
[torch.FloatTensor of size 1]

时间步 845000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.553853e+00/ 轮得分 4.95
损失函数： Variable containing:
 0.2179
[torch.FloatTensor of size 1]

时间步 846000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.207206e+01/ 轮得分 4.99
损失函数： Variable containing:
 0.1937
[torch.FloatTensor of size 1]

时间步 847000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.610616e+00/ 轮得分 4.99
损失函数： Variable containing:
 0.1385
[torch.FloatTensor of size 1]

时间步 848000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 -1/ Q_MAX 1.151743e+01/ 轮得分 4.96
损失函数： Variable containing:
 0.5582
[torch.FloatTensor of size 1]

时间步 849000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.175741e+01/ 轮得分 4.95
损失函数： Variable containing:
 0.1662
[torch.FloatTensor of size 1]

时间步 850000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.283271e+01/ 轮得分 4.92
损失函数： Variable containing:
 0.8895
[torch.FloatTensor of size 1]

时间步 851000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.851604e+00/ 轮得分 4.93
损失函数： Variable containing:
 0.1004
[torch.FloatTensor of size 1]

时间步 852000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 6.707787e+00/ 轮得分 4.97
损失函数： Variable containing:
1.00000e-02 *
  8.5796
[torch.FloatTensor of size 1]

时间步 853000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.726897e+00/ 轮得分 4.97
损失函数： Variable containing:
1.00000e-02 *
  5.9174
[torch.FloatTensor of size 1]

时间步 854000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.076023e+01/ 轮得分 4.98
损失函数： Variable containing:
1.00000e-02 *
  4.0239
[torch.FloatTensor of size 1]

时间步 855000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.174711e+01/ 轮得分 5.01
损失函数： Variable containing:
 0.1536
[torch.FloatTensor of size 1]

时间步 856000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.193016e+00/ 轮得分 5.04
损失函数： Variable containing:
 0.1497
[torch.FloatTensor of size 1]

时间步 857000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.850941e+00/ 轮得分 5.07
损失函数： Variable containing:
 0.3168
[torch.FloatTensor of size 1]

时间步 858000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.587150e+00/ 轮得分 5.03
损失函数： Variable containing:
 0.1142
[torch.FloatTensor of size 1]

时间步 859000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.187809e+01/ 轮得分 5.03
损失函数： Variable containing:
 0.2661
[torch.FloatTensor of size 1]

时间步 860000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.064276e+01/ 轮得分 5.02
损失函数： Variable containing:
 0.1508
[torch.FloatTensor of size 1]

时间步 861000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.197501e+01/ 轮得分 4.99
损失函数： Variable containing:
 0.2048
[torch.FloatTensor of size 1]

时间步 862000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.981626e+00/ 轮得分 4.99
损失函数： Variable containing:
 0.1604
[torch.FloatTensor of size 1]

时间步 863000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.592104e+00/ 轮得分 5.00
损失函数： Variable containing:
 0.1225
[torch.FloatTensor of size 1]

时间步 864000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.415452e+01/ 轮得分 5.04
损失函数： Variable containing:
 0.1137
[torch.FloatTensor of size 1]

时间步 865000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.278087e+01/ 轮得分 5.02
损失函数： Variable containing:
1.00000e-02 *
  6.4671
[torch.FloatTensor of size 1]

时间步 866000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 6.945290e+00/ 轮得分 4.99
损失函数： Variable containing:
1.00000e-02 *
  9.3363
[torch.FloatTensor of size 1]

时间步 867000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.254064e+01/ 轮得分 4.98
损失函数： Variable containing:
 0.2248
[torch.FloatTensor of size 1]

时间步 868000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.105467e+01/ 轮得分 4.94
损失函数： Variable containing:
 0.8397
[torch.FloatTensor of size 1]

时间步 869000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.395898e+01/ 轮得分 4.95
损失函数： Variable containing:
 0.1265
[torch.FloatTensor of size 1]

时间步 870000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.268955e+00/ 轮得分 4.95
损失函数： Variable containing:
 0.1032
[torch.FloatTensor of size 1]

时间步 871000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.888346e+00/ 轮得分 4.94
损失函数： Variable containing:
 0.3637
[torch.FloatTensor of size 1]

时间步 872000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.297927e+01/ 轮得分 4.96
损失函数： Variable containing:
 0.1173
[torch.FloatTensor of size 1]

时间步 873000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.086715e+01/ 轮得分 4.97
损失函数： Variable containing:
 0.1111
[torch.FloatTensor of size 1]

时间步 874000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.009759e+01/ 轮得分 4.99
损失函数： Variable containing:
 0.1286
[torch.FloatTensor of size 1]

时间步 875000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.069911e+01/ 轮得分 4.98
损失函数： Variable containing:
 0.2365
[torch.FloatTensor of size 1]

时间步 876000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.268688e+01/ 轮得分 5.01
损失函数： Variable containing:
 0.2379
[torch.FloatTensor of size 1]

时间步 877000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.924002e+00/ 轮得分 5.06
损失函数： Variable containing:
1.00000e-02 *
  6.8584
[torch.FloatTensor of size 1]

时间步 878000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.022979e+01/ 轮得分 5.01
损失函数： Variable containing:
 0.1903
[torch.FloatTensor of size 1]

时间步 879000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.328265e+01/ 轮得分 5.01
损失函数： Variable containing:
 0.6113
[torch.FloatTensor of size 1]

时间步 880000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.488914e+00/ 轮得分 4.98
损失函数： Variable containing:
 0.2638
[torch.FloatTensor of size 1]

时间步 881000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.678046e+00/ 轮得分 4.98
损失函数： Variable containing:
 0.1082
[torch.FloatTensor of size 1]

时间步 882000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.032664e+01/ 轮得分 5.01
损失函数： Variable containing:
 0.2444
[torch.FloatTensor of size 1]

时间步 883000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.037910e+00/ 轮得分 5.00
损失函数： Variable containing:
 0.3588
[torch.FloatTensor of size 1]

时间步 884000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 4.748546e+00/ 轮得分 5.04
损失函数： Variable containing:
1.00000e-02 *
  6.5980
[torch.FloatTensor of size 1]

时间步 885000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.143884e+01/ 轮得分 4.98
损失函数： Variable containing:
 0.2793
[torch.FloatTensor of size 1]

时间步 886000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.261671e+01/ 轮得分 4.95
损失函数： Variable containing:
 0.1268
[torch.FloatTensor of size 1]

时间步 887000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.139855e+01/ 轮得分 4.91
损失函数： Variable containing:
 0.1418
[torch.FloatTensor of size 1]

时间步 888000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.925035e+00/ 轮得分 4.88
损失函数： Variable containing:
 1.2923
[torch.FloatTensor of size 1]

时间步 889000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.021933e+01/ 轮得分 4.84
损失函数： Variable containing:
 0.1741
[torch.FloatTensor of size 1]

时间步 890000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.001766e+01/ 轮得分 4.82
损失函数： Variable containing:
 0.8253
[torch.FloatTensor of size 1]

时间步 891000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.465663e+00/ 轮得分 4.86
损失函数： Variable containing:
1.00000e-02 *
  8.1753
[torch.FloatTensor of size 1]

时间步 892000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 4.703556e+00/ 轮得分 4.85
损失函数： Variable containing:
 0.3381
[torch.FloatTensor of size 1]

时间步 893000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.182618e+01/ 轮得分 4.84
损失函数： Variable containing:
 0.4834
[torch.FloatTensor of size 1]

时间步 894000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.026322e+00/ 轮得分 4.80
损失函数： Variable containing:
1.00000e-02 *
  7.5102
[torch.FloatTensor of size 1]

时间步 895000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 6.208574e+00/ 轮得分 4.75
损失函数： Variable containing:
1.00000e-02 *
  8.3304
[torch.FloatTensor of size 1]

时间步 896000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.019792e+01/ 轮得分 4.74
损失函数： Variable containing:
1.00000e-02 *
  5.2852
[torch.FloatTensor of size 1]

时间步 897000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.839162e+00/ 轮得分 4.70
损失函数： Variable containing:
 0.2047
[torch.FloatTensor of size 1]

时间步 898000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 -1/ Q_MAX 2.547814e+00/ 轮得分 4.69
损失函数： Variable containing:
 1.1232
[torch.FloatTensor of size 1]

时间步 899000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.055230e+00/ 轮得分 4.66
损失函数： Variable containing:
 0.2484
[torch.FloatTensor of size 1]

时间步 900000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.274692e+01/ 轮得分 4.65
损失函数： Variable containing:
1.00000e-02 *
  9.5943
[torch.FloatTensor of size 1]

时间步 901000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.214446e+01/ 轮得分 4.66
损失函数： Variable containing:
 0.7140
[torch.FloatTensor of size 1]

时间步 902000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 -1/ Q_MAX 4.492412e+00/ 轮得分 4.67
损失函数： Variable containing:
 0.1469
[torch.FloatTensor of size 1]

时间步 903000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 6.069330e+00/ 轮得分 4.69
损失函数： Variable containing:
 0.1082
[torch.FloatTensor of size 1]

时间步 904000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.240364e+00/ 轮得分 4.66
损失函数： Variable containing:
 0.3695
[torch.FloatTensor of size 1]

时间步 905000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.234305e+00/ 轮得分 4.66
损失函数： Variable containing:
 0.1708
[torch.FloatTensor of size 1]

时间步 906000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 6.837947e+00/ 轮得分 4.64
损失函数： Variable containing:
 0.3183
[torch.FloatTensor of size 1]

时间步 907000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.090198e+01/ 轮得分 4.61
损失函数： Variable containing:
 0.2723
[torch.FloatTensor of size 1]

时间步 908000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.037689e+01/ 轮得分 4.57
损失函数： Variable containing:
1.00000e-02 *
  3.8681
[torch.FloatTensor of size 1]

时间步 909000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.208414e+01/ 轮得分 4.57
损失函数： Variable containing:
 0.2285
[torch.FloatTensor of size 1]

时间步 910000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.744252e+00/ 轮得分 4.57
损失函数： Variable containing:
 0.3360
[torch.FloatTensor of size 1]

时间步 911000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 2.380037e+00/ 轮得分 4.56
损失函数： Variable containing:
 0.4812
[torch.FloatTensor of size 1]

时间步 912000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 -1/ Q_MAX 5.715233e+00/ 轮得分 4.54
损失函数： Variable containing:
1.00000e-02 *
  3.9318
[torch.FloatTensor of size 1]

时间步 913000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.456672e+00/ 轮得分 4.55
损失函数： Variable containing:
 0.1613
[torch.FloatTensor of size 1]

时间步 914000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.227044e+01/ 轮得分 4.54
损失函数： Variable containing:
 0.1294
[torch.FloatTensor of size 1]

时间步 915000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.120419e+01/ 轮得分 4.56
损失函数： Variable containing:
 0.2310
[torch.FloatTensor of size 1]

时间步 916000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.469115e+00/ 轮得分 4.53
损失函数： Variable containing:
1.00000e-02 *
  3.7551
[torch.FloatTensor of size 1]

时间步 917000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.213500e+01/ 轮得分 4.50
损失函数： Variable containing:
 0.8224
[torch.FloatTensor of size 1]

时间步 918000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.073463e+01/ 轮得分 4.50
损失函数： Variable containing:
1.00000e-02 *
  9.4153
[torch.FloatTensor of size 1]

时间步 919000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.198431e+01/ 轮得分 4.53
损失函数： Variable containing:
 0.2504
[torch.FloatTensor of size 1]

时间步 920000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.224161e+00/ 轮得分 4.49
损失函数： Variable containing:
 0.1600
[torch.FloatTensor of size 1]

时间步 921000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.231730e+01/ 轮得分 4.49
损失函数： Variable containing:
1.00000e-02 *
  5.8877
[torch.FloatTensor of size 1]

时间步 922000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.585874e+00/ 轮得分 4.50
损失函数： Variable containing:
 0.1226
[torch.FloatTensor of size 1]

时间步 923000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.212162e+01/ 轮得分 4.51
损失函数： Variable containing:
 0.1449
[torch.FloatTensor of size 1]

时间步 924000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.127583e+01/ 轮得分 4.49
损失函数： Variable containing:
 0.1960
[torch.FloatTensor of size 1]

时间步 925000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.434568e+00/ 轮得分 4.49
损失函数： Variable containing:
 0.2184
[torch.FloatTensor of size 1]

时间步 926000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 7.866240e+00/ 轮得分 4.48
损失函数： Variable containing:
 0.2173
[torch.FloatTensor of size 1]

时间步 927000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.701335e+00/ 轮得分 4.56
损失函数： Variable containing:
 0.1949
[torch.FloatTensor of size 1]

时间步 928000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.000227e+01/ 轮得分 4.57
损失函数： Variable containing:
 0.2512
[torch.FloatTensor of size 1]

时间步 929000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.419100e+00/ 轮得分 4.52
损失函数： Variable containing:
 0.1224
[torch.FloatTensor of size 1]

时间步 930000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.172994e+01/ 轮得分 4.50
损失函数： Variable containing:
1.00000e-02 *
  9.8978
[torch.FloatTensor of size 1]

时间步 931000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.211735e+01/ 轮得分 4.50
损失函数： Variable containing:
 0.1476
[torch.FloatTensor of size 1]

时间步 932000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.342036e+01/ 轮得分 4.48
损失函数： Variable containing:
 0.3341
[torch.FloatTensor of size 1]

时间步 933000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.353485e+00/ 轮得分 4.50
损失函数： Variable containing:
1.00000e-02 *
  4.2613
[torch.FloatTensor of size 1]

时间步 934000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.086278e+01/ 轮得分 4.50
损失函数： Variable containing:
 0.1539
[torch.FloatTensor of size 1]

时间步 935000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.529339e+00/ 轮得分 4.47
损失函数： Variable containing:
 0.1380
[torch.FloatTensor of size 1]

时间步 936000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.303698e+01/ 轮得分 4.45
损失函数： Variable containing:
 0.1237
[torch.FloatTensor of size 1]

时间步 937000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 6.282944e+00/ 轮得分 4.46
损失函数： Variable containing:
 0.8604
[torch.FloatTensor of size 1]

时间步 938000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.187513e+01/ 轮得分 4.49
损失函数： Variable containing:
 0.1118
[torch.FloatTensor of size 1]

时间步 939000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.454515e+01/ 轮得分 4.49
损失函数： Variable containing:
1.00000e-02 *
  7.2651
[torch.FloatTensor of size 1]

时间步 940000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.283923e+01/ 轮得分 4.48
损失函数： Variable containing:
 0.1938
[torch.FloatTensor of size 1]

时间步 941000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.884412e+00/ 轮得分 4.51
损失函数： Variable containing:
 0.6352
[torch.FloatTensor of size 1]

时间步 942000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.053459e+01/ 轮得分 4.49
损失函数： Variable containing:
 0.4520
[torch.FloatTensor of size 1]

时间步 943000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.040216e+01/ 轮得分 4.51
损失函数： Variable containing:
 0.2079
[torch.FloatTensor of size 1]

时间步 944000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.015096e+01/ 轮得分 4.51
损失函数： Variable containing:
 0.1145
[torch.FloatTensor of size 1]

时间步 945000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.208495e+01/ 轮得分 4.54
损失函数： Variable containing:
1.00000e-02 *
  3.2882
[torch.FloatTensor of size 1]

时间步 946000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.823459e+00/ 轮得分 4.57
损失函数： Variable containing:
1.00000e-02 *
  7.9846
[torch.FloatTensor of size 1]

时间步 947000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.287708e+01/ 轮得分 4.61
损失函数： Variable containing:
 0.2096
[torch.FloatTensor of size 1]

时间步 948000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.030356e+01/ 轮得分 4.59
损失函数： Variable containing:
 0.2101
[torch.FloatTensor of size 1]

时间步 949000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 1/ Q_MAX 8.465747e+00/ 轮得分 4.60
损失函数： Variable containing:
 0.1311
[torch.FloatTensor of size 1]

时间步 950000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.095188e+01/ 轮得分 4.60
损失函数： Variable containing:
 0.2265
[torch.FloatTensor of size 1]

时间步 951000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.308207e+01/ 轮得分 4.62
损失函数： Variable containing:
 0.1001
[torch.FloatTensor of size 1]

时间步 952000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.269945e+01/ 轮得分 4.60
损失函数： Variable containing:
 0.2038
[torch.FloatTensor of size 1]

时间步 953000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.333663e+01/ 轮得分 4.66
损失函数： Variable containing:
 0.2927
[torch.FloatTensor of size 1]

时间步 954000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.242392e+00/ 轮得分 4.62
损失函数： Variable containing:
 0.6348
[torch.FloatTensor of size 1]

时间步 955000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.150421e+01/ 轮得分 4.62
损失函数： Variable containing:
1.00000e-02 *
  6.6510
[torch.FloatTensor of size 1]

时间步 956000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.241160e+00/ 轮得分 4.64
损失函数： Variable containing:
1.00000e-02 *
  5.5364
[torch.FloatTensor of size 1]

时间步 957000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.186366e+01/ 轮得分 4.64
损失函数： Variable containing:
 0.2305
[torch.FloatTensor of size 1]

时间步 958000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.010372e+01/ 轮得分 4.65
损失函数： Variable containing:
 0.1476
[torch.FloatTensor of size 1]

时间步 959000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 5.826263e+00/ 轮得分 4.67
损失函数： Variable containing:
 0.2070
[torch.FloatTensor of size 1]

时间步 960000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.934421e+00/ 轮得分 4.67
损失函数： Variable containing:
 0.1462
[torch.FloatTensor of size 1]

时间步 961000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.116785e+01/ 轮得分 4.69
损失函数： Variable containing:
 0.3450
[torch.FloatTensor of size 1]

时间步 962000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.931078e+00/ 轮得分 4.67
损失函数： Variable containing:
 0.1509
[torch.FloatTensor of size 1]

时间步 963000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.655201e+00/ 轮得分 4.64
损失函数： Variable containing:
 0.1172
[torch.FloatTensor of size 1]

时间步 964000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.084246e+01/ 轮得分 4.68
损失函数： Variable containing:
 0.2924
[torch.FloatTensor of size 1]

时间步 965000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.260400e+01/ 轮得分 4.68
损失函数： Variable containing:
1.00000e-02 *
  6.7557
[torch.FloatTensor of size 1]

时间步 966000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.185289e+01/ 轮得分 4.69
损失函数： Variable containing:
1.00000e-02 *
  7.0485
[torch.FloatTensor of size 1]

时间步 967000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.200773e+01/ 轮得分 4.68
损失函数： Variable containing:
 0.4069
[torch.FloatTensor of size 1]

时间步 968000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.836591e+00/ 轮得分 4.65
损失函数： Variable containing:
 0.2809
[torch.FloatTensor of size 1]

时间步 969000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.456404e+00/ 轮得分 4.63
损失函数： Variable containing:
 0.1271
[torch.FloatTensor of size 1]

时间步 970000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.890373e+00/ 轮得分 4.65
损失函数： Variable containing:
 0.1684
[torch.FloatTensor of size 1]

时间步 971000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.298734e+01/ 轮得分 4.63
损失函数： Variable containing:
1.00000e-02 *
  8.5339
[torch.FloatTensor of size 1]

时间步 972000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.023530e+01/ 轮得分 4.62
损失函数： Variable containing:
1.00000e-02 *
  8.2563
[torch.FloatTensor of size 1]

时间步 973000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.185674e+01/ 轮得分 4.64
损失函数： Variable containing:
 0.1258
[torch.FloatTensor of size 1]

时间步 974000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.063752e+01/ 轮得分 4.60
损失函数： Variable containing:
1.00000e-02 *
  4.5982
[torch.FloatTensor of size 1]

时间步 975000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.067732e+00/ 轮得分 4.60
损失函数： Variable containing:
 0.1525
[torch.FloatTensor of size 1]

时间步 976000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.436179e+00/ 轮得分 4.61
损失函数： Variable containing:
 0.4167
[torch.FloatTensor of size 1]

时间步 977000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.075051e+01/ 轮得分 4.63
损失函数： Variable containing:
1.00000e-02 *
  5.7907
[torch.FloatTensor of size 1]

时间步 978000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.193311e+01/ 轮得分 4.63
损失函数： Variable containing:
 0.5233
[torch.FloatTensor of size 1]

时间步 979000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.711119e+00/ 轮得分 4.62
损失函数： Variable containing:
 0.2796
[torch.FloatTensor of size 1]

时间步 980000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.019379e+01/ 轮得分 4.62
损失函数： Variable containing:
1.00000e-02 *
  5.2123
[torch.FloatTensor of size 1]

时间步 981000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.687336e+00/ 轮得分 4.63
损失函数： Variable containing:
 0.1866
[torch.FloatTensor of size 1]

时间步 982000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.260755e+01/ 轮得分 4.65
损失函数： Variable containing:
 0.1163
[torch.FloatTensor of size 1]

时间步 983000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.153943e+01/ 轮得分 4.67
损失函数： Variable containing:
 0.2359
[torch.FloatTensor of size 1]

时间步 984000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.221593e+01/ 轮得分 4.70
损失函数： Variable containing:
 0.1848
[torch.FloatTensor of size 1]

时间步 985000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.206964e+01/ 轮得分 4.71
损失函数： Variable containing:
1.00000e-02 *
  8.0253
[torch.FloatTensor of size 1]

时间步 986000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.186439e+01/ 轮得分 4.66
损失函数： Variable containing:
1.00000e-02 *
  3.5172
[torch.FloatTensor of size 1]

时间步 987000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.154750e+01/ 轮得分 4.65
损失函数： Variable containing:
 0.4412
[torch.FloatTensor of size 1]

时间步 988000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.169186e+01/ 轮得分 4.65
损失函数： Variable containing:
 0.4205
[torch.FloatTensor of size 1]

时间步 989000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 1/ Q_MAX 1.275657e+01/ 轮得分 4.69
损失函数： Variable containing:
 0.1232
[torch.FloatTensor of size 1]

时间步 990000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.204475e+01/ 轮得分 4.71
损失函数： Variable containing:
 1.1801
[torch.FloatTensor of size 1]

时间步 991000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.810994e+00/ 轮得分 4.68
损失函数： Variable containing:
 0.3774
[torch.FloatTensor of size 1]

时间步 992000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.077902e+01/ 轮得分 4.73
损失函数： Variable containing:
1.00000e-02 *
  9.6229
[torch.FloatTensor of size 1]

时间步 993000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.274460e+01/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  7.3477
[torch.FloatTensor of size 1]

时间步 994000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.114958e+01/ 轮得分 4.75
损失函数： Variable containing:
 0.1838
[torch.FloatTensor of size 1]

时间步 995000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.066533e+01/ 轮得分 4.74
损失函数： Variable containing:
 0.4499
[torch.FloatTensor of size 1]

时间步 996000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.054885e+01/ 轮得分 4.72
损失函数： Variable containing:
 0.1228
[torch.FloatTensor of size 1]

时间步 997000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.244477e+01/ 轮得分 4.71
损失函数： Variable containing:
 0.3193
[torch.FloatTensor of size 1]

时间步 998000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.359004e+01/ 轮得分 4.76
损失函数： Variable containing:
 0.1470
[torch.FloatTensor of size 1]

时间步 999000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.756617e+00/ 轮得分 4.71
损失函数： Variable containing:
1.00000e-02 *
  5.0720
[torch.FloatTensor of size 1]

时间步 1000000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.418420e+01/ 轮得分 4.71
损失函数： Variable containing:
 0.2441
[torch.FloatTensor of size 1]

时间步 1001000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.260941e+01/ 轮得分 4.70
损失函数： Variable containing:
 0.1846
[torch.FloatTensor of size 1]

时间步 1002000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.346205e+01/ 轮得分 4.70
损失函数： Variable containing:
 0.9089
[torch.FloatTensor of size 1]

时间步 1003000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.289966e+01/ 轮得分 4.70
损失函数： Variable containing:
 0.1209
[torch.FloatTensor of size 1]

时间步 1004000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.176974e+01/ 轮得分 4.71
损失函数： Variable containing:
 0.1650
[torch.FloatTensor of size 1]

时间步 1005000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.198049e+01/ 轮得分 4.71
损失函数： Variable containing:
 1.1687
[torch.FloatTensor of size 1]

时间步 1006000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.219101e+01/ 轮得分 4.68
损失函数： Variable containing:
 0.1697
[torch.FloatTensor of size 1]

时间步 1007000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.342558e+01/ 轮得分 4.67
损失函数： Variable containing:
 0.7395
[torch.FloatTensor of size 1]

时间步 1008000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.242226e+01/ 轮得分 4.69
损失函数： Variable containing:
 0.6884
[torch.FloatTensor of size 1]

时间步 1009000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.256754e+01/ 轮得分 4.65
损失函数： Variable containing:
1.00000e-02 *
  5.5963
[torch.FloatTensor of size 1]

时间步 1010000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.349247e+01/ 轮得分 4.67
损失函数： Variable containing:
1.00000e-02 *
  8.0655
[torch.FloatTensor of size 1]

时间步 1011000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.254935e+01/ 轮得分 4.65
损失函数： Variable containing:
 0.1428
[torch.FloatTensor of size 1]

时间步 1012000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.364365e+01/ 轮得分 4.65
损失函数： Variable containing:
 0.1555
[torch.FloatTensor of size 1]

时间步 1013000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.297452e+01/ 轮得分 4.63
损失函数： Variable containing:
1.00000e-02 *
  8.1107
[torch.FloatTensor of size 1]

时间步 1014000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.333790e+01/ 轮得分 4.66
损失函数： Variable containing:
 0.2559
[torch.FloatTensor of size 1]

时间步 1015000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 -1/ Q_MAX 3.974961e-01/ 轮得分 4.67
损失函数： Variable containing:
 0.2848
[torch.FloatTensor of size 1]

时间步 1016000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.273372e+01/ 轮得分 4.70
损失函数： Variable containing:
 0.2305
[torch.FloatTensor of size 1]

时间步 1017000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.109874e+01/ 轮得分 4.66
损失函数： Variable containing:
 0.1560
[torch.FloatTensor of size 1]

时间步 1018000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 5.890232e+00/ 轮得分 4.70
损失函数： Variable containing:
 0.1611
[torch.FloatTensor of size 1]

时间步 1019000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.291163e+01/ 轮得分 4.71
损失函数： Variable containing:
 0.1030
[torch.FloatTensor of size 1]

时间步 1020000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.025963e+01/ 轮得分 4.71
损失函数： Variable containing:
 0.1851
[torch.FloatTensor of size 1]

时间步 1021000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.462232e+01/ 轮得分 4.75
损失函数： Variable containing:
 1.2950
[torch.FloatTensor of size 1]

时间步 1022000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.343206e+01/ 轮得分 4.77
损失函数： Variable containing:
 0.8296
[torch.FloatTensor of size 1]

时间步 1023000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.308540e+01/ 轮得分 4.78
损失函数： Variable containing:
 0.2702
[torch.FloatTensor of size 1]

时间步 1024000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.233915e+01/ 轮得分 4.77
损失函数： Variable containing:
 1.1412
[torch.FloatTensor of size 1]

时间步 1025000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.545915e+01/ 轮得分 4.80
损失函数： Variable containing:
 0.1569
[torch.FloatTensor of size 1]

时间步 1026000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.171505e+01/ 轮得分 4.80
损失函数： Variable containing:
 0.2168
[torch.FloatTensor of size 1]

时间步 1027000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.300303e+01/ 轮得分 4.79
损失函数： Variable containing:
1.00000e-02 *
  6.0040
[torch.FloatTensor of size 1]

时间步 1028000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.410754e+01/ 轮得分 4.81
损失函数： Variable containing:
 0.4152
[torch.FloatTensor of size 1]

时间步 1029000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.313343e+01/ 轮得分 4.82
损失函数： Variable containing:
1.00000e-02 *
  7.3742
[torch.FloatTensor of size 1]

时间步 1030000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.155226e+01/ 轮得分 4.81
损失函数： Variable containing:
 0.1592
[torch.FloatTensor of size 1]

时间步 1031000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.329754e+01/ 轮得分 4.81
损失函数： Variable containing:
 0.2527
[torch.FloatTensor of size 1]

时间步 1032000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.053582e+01/ 轮得分 4.83
损失函数： Variable containing:
 0.1639
[torch.FloatTensor of size 1]

时间步 1033000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.359038e+01/ 轮得分 4.80
损失函数： Variable containing:
1.00000e-02 *
  8.4239
[torch.FloatTensor of size 1]

时间步 1034000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.353929e+01/ 轮得分 4.74
损失函数： Variable containing:
 0.1917
[torch.FloatTensor of size 1]

时间步 1035000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.459154e+01/ 轮得分 4.76
损失函数： Variable containing:
 0.1498
[torch.FloatTensor of size 1]

时间步 1036000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.529385e+00/ 轮得分 4.73
损失函数： Variable containing:
 0.1704
[torch.FloatTensor of size 1]

时间步 1037000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.327657e+01/ 轮得分 4.71
损失函数： Variable containing:
1.00000e-02 *
  7.7897
[torch.FloatTensor of size 1]

时间步 1038000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.149455e+01/ 轮得分 4.70
损失函数： Variable containing:
1.00000e-02 *
  8.5622
[torch.FloatTensor of size 1]

时间步 1039000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.172358e+01/ 轮得分 4.73
损失函数： Variable containing:
 0.8074
[torch.FloatTensor of size 1]

时间步 1040000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.495310e+01/ 轮得分 4.73
损失函数： Variable containing:
 0.2030
[torch.FloatTensor of size 1]

时间步 1041000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.183336e+01/ 轮得分 4.76
损失函数： Variable containing:
 0.2307
[torch.FloatTensor of size 1]

时间步 1042000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.400299e+01/ 轮得分 4.73
损失函数： Variable containing:
1.00000e-02 *
  6.7625
[torch.FloatTensor of size 1]

时间步 1043000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.432361e+01/ 轮得分 4.72
损失函数： Variable containing:
 0.1714
[torch.FloatTensor of size 1]

时间步 1044000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.547235e+00/ 轮得分 4.76
损失函数： Variable containing:
 0.1073
[torch.FloatTensor of size 1]

时间步 1045000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.348528e+00/ 轮得分 4.70
损失函数： Variable containing:
 0.1506
[torch.FloatTensor of size 1]

时间步 1046000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.478038e+01/ 轮得分 4.71
损失函数： Variable containing:
 2.8424
[torch.FloatTensor of size 1]

时间步 1047000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.094311e+01/ 轮得分 4.70
损失函数： Variable containing:
 0.3201
[torch.FloatTensor of size 1]

时间步 1048000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.445234e+01/ 轮得分 4.71
损失函数： Variable containing:
1.00000e-02 *
  7.4276
[torch.FloatTensor of size 1]

时间步 1049000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.270299e+01/ 轮得分 4.73
损失函数： Variable containing:
 0.1245
[torch.FloatTensor of size 1]

时间步 1050000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.091860e+01/ 轮得分 4.70
损失函数： Variable containing:
 0.1231
[torch.FloatTensor of size 1]

时间步 1051000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 8.765408e+00/ 轮得分 4.70
损失函数： Variable containing:
1.00000e-02 *
  6.7605
[torch.FloatTensor of size 1]

时间步 1052000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 9.228464e+00/ 轮得分 4.75
损失函数： Variable containing:
 0.2035
[torch.FloatTensor of size 1]

时间步 1053000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.318869e+01/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  7.6789
[torch.FloatTensor of size 1]

时间步 1054000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.186266e+01/ 轮得分 4.75
损失函数： Variable containing:
 0.8412
[torch.FloatTensor of size 1]

时间步 1055000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.166487e+01/ 轮得分 4.76
损失函数： Variable containing:
1.00000e-02 *
  3.3330
[torch.FloatTensor of size 1]

时间步 1056000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.385004e+01/ 轮得分 4.79
损失函数： Variable containing:
 0.3008
[torch.FloatTensor of size 1]

时间步 1057000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.358018e+01/ 轮得分 4.78
损失函数： Variable containing:
 0.2759
[torch.FloatTensor of size 1]

时间步 1058000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.290229e+01/ 轮得分 4.76
损失函数： Variable containing:
 0.1052
[torch.FloatTensor of size 1]

时间步 1059000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.396148e+01/ 轮得分 4.76
损失函数： Variable containing:
 0.5840
[torch.FloatTensor of size 1]

时间步 1060000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.012823e+01/ 轮得分 4.75
损失函数： Variable containing:
 0.3524
[torch.FloatTensor of size 1]

时间步 1061000/ 状态 explore/ Epsilon 0.07/ 行动 0/ 奖励 0.1/ Q_MAX 1.095619e+01/ 轮得分 4.77
损失函数： Variable containing:
 0.1437
[torch.FloatTensor of size 1]

时间步 1062000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.214077e+01/ 轮得分 4.77
损失函数： Variable containing:
 0.1021
[torch.FloatTensor of size 1]

时间步 1063000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.638342e+01/ 轮得分 4.80
损失函数： Variable containing:
 0.1965
[torch.FloatTensor of size 1]

时间步 1064000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.227042e+01/ 轮得分 4.81
损失函数： Variable containing:
 0.1885
[torch.FloatTensor of size 1]

时间步 1065000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.488785e+01/ 轮得分 4.84
损失函数： Variable containing:
1.00000e-02 *
  6.6934
[torch.FloatTensor of size 1]

时间步 1066000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.385323e+01/ 轮得分 4.85
损失函数： Variable containing:
1.00000e-02 *
  9.8500
[torch.FloatTensor of size 1]

时间步 1067000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 9.403782e+00/ 轮得分 4.87
损失函数： Variable containing:
 0.1548
[torch.FloatTensor of size 1]

时间步 1068000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.353661e+01/ 轮得分 4.82
损失函数： Variable containing:
 0.1275
[torch.FloatTensor of size 1]

时间步 1069000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.039299e+01/ 轮得分 4.80
损失函数： Variable containing:
1.00000e-02 *
  7.8895
[torch.FloatTensor of size 1]

时间步 1070000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.398713e+01/ 轮得分 4.82
损失函数： Variable containing:
 0.1072
[torch.FloatTensor of size 1]

时间步 1071000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 -1/ Q_MAX 5.237525e+00/ 轮得分 4.82
损失函数： Variable containing:
 0.3359
[torch.FloatTensor of size 1]

时间步 1072000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.413139e+01/ 轮得分 4.80
损失函数： Variable containing:
 0.1564
[torch.FloatTensor of size 1]

时间步 1073000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.072175e+01/ 轮得分 4.75
损失函数： Variable containing:
 0.2084
[torch.FloatTensor of size 1]

时间步 1074000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.369526e+01/ 轮得分 4.74
损失函数： Variable containing:
1.00000e-02 *
  5.0637
[torch.FloatTensor of size 1]

时间步 1075000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.025746e+01/ 轮得分 4.71
损失函数： Variable containing:
1.00000e-02 *
  8.7739
[torch.FloatTensor of size 1]

时间步 1076000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.297347e+01/ 轮得分 4.73
损失函数： Variable containing:
 0.1156
[torch.FloatTensor of size 1]

时间步 1077000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.315056e+01/ 轮得分 4.74
损失函数： Variable containing:
1.00000e-02 *
  8.2104
[torch.FloatTensor of size 1]

时间步 1078000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.443956e+01/ 轮得分 4.73
损失函数： Variable containing:
1.00000e-02 *
  7.4717
[torch.FloatTensor of size 1]

时间步 1079000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.423128e+01/ 轮得分 4.72
损失函数： Variable containing:
 0.1118
[torch.FloatTensor of size 1]

时间步 1080000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.445405e+01/ 轮得分 4.72
损失函数： Variable containing:
 0.2172
[torch.FloatTensor of size 1]

时间步 1081000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.231902e+01/ 轮得分 4.75
损失函数： Variable containing:
 0.1310
[torch.FloatTensor of size 1]

时间步 1082000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.307765e+01/ 轮得分 4.70
损失函数： Variable containing:
1.00000e-02 *
  7.8453
[torch.FloatTensor of size 1]

时间步 1083000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.360803e+01/ 轮得分 4.70
损失函数： Variable containing:
 0.2818
[torch.FloatTensor of size 1]

时间步 1084000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.253778e+01/ 轮得分 4.70
损失函数： Variable containing:
 0.3251
[torch.FloatTensor of size 1]

时间步 1085000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 9.510182e+00/ 轮得分 4.69
损失函数： Variable containing:
1.00000e-02 *
  7.2783
[torch.FloatTensor of size 1]

时间步 1086000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 9.843907e+00/ 轮得分 4.71
损失函数： Variable containing:
 0.3602
[torch.FloatTensor of size 1]

时间步 1087000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.406859e+01/ 轮得分 4.72
损失函数： Variable containing:
 0.1756
[torch.FloatTensor of size 1]

时间步 1088000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.393515e+01/ 轮得分 4.69
损失函数： Variable containing:
 2.2010
[torch.FloatTensor of size 1]

时间步 1089000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.348700e+01/ 轮得分 4.68
损失函数： Variable containing:
 0.1183
[torch.FloatTensor of size 1]

时间步 1090000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.494302e+01/ 轮得分 4.68
损失函数： Variable containing:
1.00000e-02 *
  8.6870
[torch.FloatTensor of size 1]

时间步 1091000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.410182e+01/ 轮得分 4.66
损失函数： Variable containing:
 0.1644
[torch.FloatTensor of size 1]

时间步 1092000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.383509e+01/ 轮得分 4.68
损失函数： Variable containing:
 0.2713
[torch.FloatTensor of size 1]

时间步 1093000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.395664e+01/ 轮得分 4.70
损失函数： Variable containing:
 0.2294
[torch.FloatTensor of size 1]

时间步 1094000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.383104e+01/ 轮得分 4.68
损失函数： Variable containing:
1.00000e-02 *
  6.0544
[torch.FloatTensor of size 1]

时间步 1095000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.277082e+01/ 轮得分 4.68
损失函数： Variable containing:
1.00000e-02 *
  7.4896
[torch.FloatTensor of size 1]

时间步 1096000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.054649e+01/ 轮得分 4.69
损失函数： Variable containing:
 0.1635
[torch.FloatTensor of size 1]

时间步 1097000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.200643e+01/ 轮得分 4.69
损失函数： Variable containing:
 0.1041
[torch.FloatTensor of size 1]

时间步 1098000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.208795e+01/ 轮得分 4.71
损失函数： Variable containing:
 0.7801
[torch.FloatTensor of size 1]

时间步 1099000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.456977e+01/ 轮得分 4.70
损失函数： Variable containing:
 0.6073
[torch.FloatTensor of size 1]

时间步 1100000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.411202e+01/ 轮得分 4.72
损失函数： Variable containing:
 0.1325
[torch.FloatTensor of size 1]

时间步 1101000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.174233e+01/ 轮得分 4.72
损失函数： Variable containing:
 0.2210
[torch.FloatTensor of size 1]

时间步 1102000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.440296e+01/ 轮得分 4.70
损失函数： Variable containing:
 0.1110
[torch.FloatTensor of size 1]

时间步 1103000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.045397e+01/ 轮得分 4.69
损失函数： Variable containing:
1.00000e-02 *
  6.8332
[torch.FloatTensor of size 1]

时间步 1104000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.237141e+01/ 轮得分 4.71
损失函数： Variable containing:
 0.1043
[torch.FloatTensor of size 1]

时间步 1105000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.452241e+01/ 轮得分 4.65
损失函数： Variable containing:
 0.1447
[torch.FloatTensor of size 1]

时间步 1106000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 7.132699e+00/ 轮得分 4.68
损失函数： Variable containing:
 0.1193
[torch.FloatTensor of size 1]

时间步 1107000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.129107e+01/ 轮得分 4.69
损失函数： Variable containing:
 0.1813
[torch.FloatTensor of size 1]

时间步 1108000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.127096e+01/ 轮得分 4.69
损失函数： Variable containing:
1.00000e-02 *
  8.7471
[torch.FloatTensor of size 1]

时间步 1109000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.387240e+01/ 轮得分 4.69
损失函数： Variable containing:
 0.1693
[torch.FloatTensor of size 1]

时间步 1110000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.445350e+01/ 轮得分 4.71
损失函数： Variable containing:
 0.4129
[torch.FloatTensor of size 1]

时间步 1111000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.263331e+01/ 轮得分 4.72
损失函数： Variable containing:
 0.1061
[torch.FloatTensor of size 1]

时间步 1112000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.477319e+01/ 轮得分 4.71
损失函数： Variable containing:
 0.4414
[torch.FloatTensor of size 1]

时间步 1113000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 1/ Q_MAX 4.497935e+00/ 轮得分 4.71
损失函数： Variable containing:
 0.2700
[torch.FloatTensor of size 1]

时间步 1114000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.380569e+01/ 轮得分 4.66
损失函数： Variable containing:
 0.2932
[torch.FloatTensor of size 1]

时间步 1115000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.194764e+01/ 轮得分 4.67
损失函数： Variable containing:
 0.1025
[torch.FloatTensor of size 1]

时间步 1116000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.326210e+01/ 轮得分 4.68
损失函数： Variable containing:
 1.5260
[torch.FloatTensor of size 1]

时间步 1117000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.339075e+01/ 轮得分 4.64
损失函数： Variable containing:
 0.1035
[torch.FloatTensor of size 1]

时间步 1118000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.398409e+01/ 轮得分 4.63
损失函数： Variable containing:
1.00000e-02 *
  9.0152
[torch.FloatTensor of size 1]

时间步 1119000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.234161e+01/ 轮得分 4.59
损失函数： Variable containing:
 0.2175
[torch.FloatTensor of size 1]

时间步 1120000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.004435e+01/ 轮得分 4.59
损失函数： Variable containing:
 0.2581
[torch.FloatTensor of size 1]

时间步 1121000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 8.978605e+00/ 轮得分 4.56
损失函数： Variable containing:
 0.1253
[torch.FloatTensor of size 1]

时间步 1122000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.287456e+01/ 轮得分 4.58
损失函数： Variable containing:
 0.2721
[torch.FloatTensor of size 1]

时间步 1123000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.101947e+01/ 轮得分 4.59
损失函数： Variable containing:
 0.6335
[torch.FloatTensor of size 1]

时间步 1124000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.331984e+01/ 轮得分 4.60
损失函数： Variable containing:
 0.8092
[torch.FloatTensor of size 1]

时间步 1125000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.081886e+01/ 轮得分 4.62
损失函数： Variable containing:
 0.2168
[torch.FloatTensor of size 1]

时间步 1126000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.311182e+01/ 轮得分 4.61
损失函数： Variable containing:
 0.2080
[torch.FloatTensor of size 1]

时间步 1127000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.218831e+01/ 轮得分 4.62
损失函数： Variable containing:
 0.2847
[torch.FloatTensor of size 1]

时间步 1128000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.158128e+01/ 轮得分 4.63
损失函数： Variable containing:
1.00000e-02 *
  9.2024
[torch.FloatTensor of size 1]

时间步 1129000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.333225e+01/ 轮得分 4.65
损失函数： Variable containing:
1.00000e-02 *
  9.0312
[torch.FloatTensor of size 1]

时间步 1130000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 9.883484e+00/ 轮得分 4.63
损失函数： Variable containing:
 0.3314
[torch.FloatTensor of size 1]

时间步 1131000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.125932e+01/ 轮得分 4.64
损失函数： Variable containing:
 0.2333
[torch.FloatTensor of size 1]

时间步 1132000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.107055e+01/ 轮得分 4.69
损失函数： Variable containing:
 0.8087
[torch.FloatTensor of size 1]

时间步 1133000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.102512e+01/ 轮得分 4.68
损失函数： Variable containing:
 0.1032
[torch.FloatTensor of size 1]

时间步 1134000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.464462e+01/ 轮得分 4.68
损失函数： Variable containing:
1.00000e-02 *
  7.1817
[torch.FloatTensor of size 1]

时间步 1135000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.267970e+01/ 轮得分 4.67
损失函数： Variable containing:
1.00000e-02 *
  7.9314
[torch.FloatTensor of size 1]

时间步 1136000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.061281e+01/ 轮得分 4.67
损失函数： Variable containing:
1.00000e-02 *
  8.9786
[torch.FloatTensor of size 1]

时间步 1137000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.464287e+01/ 轮得分 4.69
损失函数： Variable containing:
 0.4081
[torch.FloatTensor of size 1]

时间步 1138000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 9.752889e+00/ 轮得分 4.67
损失函数： Variable containing:
 0.2281
[torch.FloatTensor of size 1]

时间步 1139000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.299692e+01/ 轮得分 4.65
损失函数： Variable containing:
 2.2132
[torch.FloatTensor of size 1]

时间步 1140000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.399816e+01/ 轮得分 4.67
损失函数： Variable containing:
 0.1240
[torch.FloatTensor of size 1]

时间步 1141000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.574102e+01/ 轮得分 4.66
损失函数： Variable containing:
 0.1608
[torch.FloatTensor of size 1]

时间步 1142000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.498311e+01/ 轮得分 4.66
损失函数： Variable containing:
 0.1889
[torch.FloatTensor of size 1]

时间步 1143000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.382826e+01/ 轮得分 4.68
损失函数： Variable containing:
 0.1146
[torch.FloatTensor of size 1]

时间步 1144000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.411355e+01/ 轮得分 4.65
损失函数： Variable containing:
 0.2062
[torch.FloatTensor of size 1]

时间步 1145000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.299251e+01/ 轮得分 4.65
损失函数： Variable containing:
 0.3892
[torch.FloatTensor of size 1]

时间步 1146000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.192272e+01/ 轮得分 4.62
损失函数： Variable containing:
 0.3949
[torch.FloatTensor of size 1]

时间步 1147000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.186286e+01/ 轮得分 4.59
损失函数： Variable containing:
 0.1345
[torch.FloatTensor of size 1]

时间步 1148000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.184713e+01/ 轮得分 4.57
损失函数： Variable containing:
1.00000e-02 *
  8.8923
[torch.FloatTensor of size 1]

时间步 1149000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.034995e+01/ 轮得分 4.53
损失函数： Variable containing:
 0.1759
[torch.FloatTensor of size 1]

时间步 1150000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.337068e+01/ 轮得分 4.53
损失函数： Variable containing:
 0.1999
[torch.FloatTensor of size 1]

时间步 1151000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.403500e+01/ 轮得分 4.54
损失函数： Variable containing:
1.00000e-02 *
  7.3407
[torch.FloatTensor of size 1]

时间步 1152000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 8.013847e+00/ 轮得分 4.51
损失函数： Variable containing:
1.00000e-02 *
  7.5992
[torch.FloatTensor of size 1]

时间步 1153000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.333300e+01/ 轮得分 4.49
损失函数： Variable containing:
 0.2920
[torch.FloatTensor of size 1]

时间步 1154000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.463659e+01/ 轮得分 4.51
损失函数： Variable containing:
 0.1173
[torch.FloatTensor of size 1]

时间步 1155000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.265594e+01/ 轮得分 4.51
损失函数： Variable containing:
 0.1456
[torch.FloatTensor of size 1]

时间步 1156000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.443108e+01/ 轮得分 4.46
损失函数： Variable containing:
 0.1109
[torch.FloatTensor of size 1]

时间步 1157000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.168952e+01/ 轮得分 4.43
损失函数： Variable containing:
 0.1385
[torch.FloatTensor of size 1]

时间步 1158000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.260733e+01/ 轮得分 4.39
损失函数： Variable containing:
 0.4430
[torch.FloatTensor of size 1]

时间步 1159000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.192793e+01/ 轮得分 4.39
损失函数： Variable containing:
1.00000e-02 *
  7.1273
[torch.FloatTensor of size 1]

时间步 1160000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.242206e+01/ 轮得分 4.35
损失函数： Variable containing:
 0.1379
[torch.FloatTensor of size 1]

时间步 1161000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.303587e+01/ 轮得分 4.33
损失函数： Variable containing:
 0.3502
[torch.FloatTensor of size 1]

时间步 1162000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.376209e+01/ 轮得分 4.34
损失函数： Variable containing:
1.00000e-02 *
  8.9316
[torch.FloatTensor of size 1]

时间步 1163000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.379988e+01/ 轮得分 4.34
损失函数： Variable containing:
 1.8185
[torch.FloatTensor of size 1]

时间步 1164000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.493442e+01/ 轮得分 4.38
损失函数： Variable containing:
 0.1101
[torch.FloatTensor of size 1]

时间步 1165000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.130970e+01/ 轮得分 4.41
损失函数： Variable containing:
 0.1419
[torch.FloatTensor of size 1]

时间步 1166000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.214421e+01/ 轮得分 4.38
损失函数： Variable containing:
 0.4255
[torch.FloatTensor of size 1]

时间步 1167000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.512578e+01/ 轮得分 4.39
损失函数： Variable containing:
 0.8170
[torch.FloatTensor of size 1]

时间步 1168000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.491980e+01/ 轮得分 4.38
损失函数： Variable containing:
 0.1174
[torch.FloatTensor of size 1]

时间步 1169000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.412921e+01/ 轮得分 4.41
损失函数： Variable containing:
 0.1617
[torch.FloatTensor of size 1]

时间步 1170000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.202827e+01/ 轮得分 4.42
损失函数： Variable containing:
 0.1085
[torch.FloatTensor of size 1]

时间步 1171000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.263197e+01/ 轮得分 4.44
损失函数： Variable containing:
 0.1503
[torch.FloatTensor of size 1]

时间步 1172000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.212518e+01/ 轮得分 4.43
损失函数： Variable containing:
1.00000e-02 *
  9.8026
[torch.FloatTensor of size 1]

时间步 1173000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.203514e+01/ 轮得分 4.39
损失函数： Variable containing:
 0.1743
[torch.FloatTensor of size 1]

时间步 1174000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.023786e+01/ 轮得分 4.38
损失函数： Variable containing:
 0.3378
[torch.FloatTensor of size 1]

时间步 1175000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.240429e+01/ 轮得分 4.37
损失函数： Variable containing:
 0.1297
[torch.FloatTensor of size 1]

时间步 1176000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.454421e+01/ 轮得分 4.39
损失函数： Variable containing:
 0.2825
[torch.FloatTensor of size 1]

时间步 1177000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.298238e+01/ 轮得分 4.35
损失函数： Variable containing:
 0.1963
[torch.FloatTensor of size 1]

时间步 1178000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.467409e+01/ 轮得分 4.33
损失函数： Variable containing:
1.00000e-02 *
  9.6757
[torch.FloatTensor of size 1]

时间步 1179000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.118649e+01/ 轮得分 4.30
损失函数： Variable containing:
 0.2680
[torch.FloatTensor of size 1]

时间步 1180000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.462446e+01/ 轮得分 4.30
损失函数： Variable containing:
 0.2598
[torch.FloatTensor of size 1]

时间步 1181000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.187605e+01/ 轮得分 4.32
损失函数： Variable containing:
 0.1294
[torch.FloatTensor of size 1]

时间步 1182000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.539608e+01/ 轮得分 4.32
损失函数： Variable containing:
 0.1306
[torch.FloatTensor of size 1]

时间步 1183000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.420711e+01/ 轮得分 4.34
损失函数： Variable containing:
 0.1690
[torch.FloatTensor of size 1]

时间步 1184000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.659374e+01/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-02 *
  8.6982
[torch.FloatTensor of size 1]

时间步 1185000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.444086e+01/ 轮得分 4.31
损失函数： Variable containing:
 0.5754
[torch.FloatTensor of size 1]

时间步 1186000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.051285e+01/ 轮得分 4.31
损失函数： Variable containing:
 0.3624
[torch.FloatTensor of size 1]

时间步 1187000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.448265e+01/ 轮得分 4.30
损失函数： Variable containing:
 0.4592
[torch.FloatTensor of size 1]

时间步 1188000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.549985e+01/ 轮得分 4.31
损失函数： Variable containing:
 0.3190
[torch.FloatTensor of size 1]

时间步 1189000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.466471e+01/ 轮得分 4.30
损失函数： Variable containing:
 0.2246
[torch.FloatTensor of size 1]

时间步 1190000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.455942e+01/ 轮得分 4.29
损失函数： Variable containing:
 0.6844
[torch.FloatTensor of size 1]

时间步 1191000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.360967e+01/ 轮得分 4.29
损失函数： Variable containing:
 0.1260
[torch.FloatTensor of size 1]

时间步 1192000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.411651e+01/ 轮得分 4.31
损失函数： Variable containing:
1.00000e-02 *
  9.7090
[torch.FloatTensor of size 1]

时间步 1193000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.024206e+01/ 轮得分 4.32
损失函数： Variable containing:
1.00000e-02 *
  6.0891
[torch.FloatTensor of size 1]

时间步 1194000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.219742e+01/ 轮得分 4.33
损失函数： Variable containing:
 0.2040
[torch.FloatTensor of size 1]

时间步 1195000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.441309e+01/ 轮得分 4.33
损失函数： Variable containing:
 0.2258
[torch.FloatTensor of size 1]

时间步 1196000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.474822e+01/ 轮得分 4.33
损失函数： Variable containing:
 0.1565
[torch.FloatTensor of size 1]

时间步 1197000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.339231e+01/ 轮得分 4.36
损失函数： Variable containing:
1.00000e-02 *
  7.6705
[torch.FloatTensor of size 1]

时间步 1198000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.199154e+01/ 轮得分 4.34
损失函数： Variable containing:
1.00000e-02 *
  8.1441
[torch.FloatTensor of size 1]

时间步 1199000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.311460e+01/ 轮得分 4.37
损失函数： Variable containing:
 0.1576
[torch.FloatTensor of size 1]

时间步 1200000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.365484e+01/ 轮得分 4.42
损失函数： Variable containing:
 0.2521
[torch.FloatTensor of size 1]

时间步 1201000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.018749e+01/ 轮得分 4.44
损失函数： Variable containing:
 0.3671
[torch.FloatTensor of size 1]

时间步 1202000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.376924e+01/ 轮得分 4.40
损失函数： Variable containing:
 0.7800
[torch.FloatTensor of size 1]

时间步 1203000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 1/ Q_MAX 1.439046e+01/ 轮得分 4.42
损失函数： Variable containing:
 0.4925
[torch.FloatTensor of size 1]

时间步 1204000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 1/ Q_MAX 1.400936e+01/ 轮得分 4.44
损失函数： Variable containing:
 0.2389
[torch.FloatTensor of size 1]

时间步 1205000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.476501e+01/ 轮得分 4.47
损失函数： Variable containing:
 0.4213
[torch.FloatTensor of size 1]

时间步 1206000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.342479e+01/ 轮得分 4.48
损失函数： Variable containing:
1.00000e-02 *
  8.3287
[torch.FloatTensor of size 1]

时间步 1207000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.481341e+01/ 轮得分 4.52
损失函数： Variable containing:
1.00000e-02 *
  9.5570
[torch.FloatTensor of size 1]

时间步 1208000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.049497e+01/ 轮得分 4.49
损失函数： Variable containing:
 0.2151
[torch.FloatTensor of size 1]

时间步 1209000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.270799e+01/ 轮得分 4.48
损失函数： Variable containing:
 0.5302
[torch.FloatTensor of size 1]

时间步 1210000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.437647e+01/ 轮得分 4.51
损失函数： Variable containing:
1.00000e-02 *
  6.4137
[torch.FloatTensor of size 1]

时间步 1211000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.532284e+01/ 轮得分 4.50
损失函数： Variable containing:
1.00000e-02 *
  9.7209
[torch.FloatTensor of size 1]

时间步 1212000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.000427e+01/ 轮得分 4.49
损失函数： Variable containing:
 0.1281
[torch.FloatTensor of size 1]

时间步 1213000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.390789e+01/ 轮得分 4.50
损失函数： Variable containing:
 0.1839
[torch.FloatTensor of size 1]

时间步 1214000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.499288e+01/ 轮得分 4.49
损失函数： Variable containing:
 0.2527
[torch.FloatTensor of size 1]

时间步 1215000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.431768e+01/ 轮得分 4.43
损失函数： Variable containing:
 0.1435
[torch.FloatTensor of size 1]

时间步 1216000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.297755e+01/ 轮得分 4.43
损失函数： Variable containing:
 0.2882
[torch.FloatTensor of size 1]

时间步 1217000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.358146e+01/ 轮得分 4.42
损失函数： Variable containing:
 0.2471
[torch.FloatTensor of size 1]

时间步 1218000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.507114e+01/ 轮得分 4.40
损失函数： Variable containing:
 0.1164
[torch.FloatTensor of size 1]

时间步 1219000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.455421e+01/ 轮得分 4.37
损失函数： Variable containing:
 0.2900
[torch.FloatTensor of size 1]

时间步 1220000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.271912e+01/ 轮得分 4.35
损失函数： Variable containing:
 0.2125
[torch.FloatTensor of size 1]

时间步 1221000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.504195e+01/ 轮得分 4.33
损失函数： Variable containing:
 0.2139
[torch.FloatTensor of size 1]

时间步 1222000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.476431e+01/ 轮得分 4.33
损失函数： Variable containing:
1.00000e-02 *
  4.9122
[torch.FloatTensor of size 1]

时间步 1223000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 9.782649e+00/ 轮得分 4.31
损失函数： Variable containing:
 0.1818
[torch.FloatTensor of size 1]

时间步 1224000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 -1/ Q_MAX 8.442558e+00/ 轮得分 4.31
损失函数： Variable containing:
 0.2379
[torch.FloatTensor of size 1]

时间步 1225000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.351385e+01/ 轮得分 4.30
损失函数： Variable containing:
1.00000e-02 *
  8.1384
[torch.FloatTensor of size 1]

时间步 1226000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.369118e+01/ 轮得分 4.30
损失函数： Variable containing:
 0.4229
[torch.FloatTensor of size 1]

时间步 1227000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.491886e+01/ 轮得分 4.28
损失函数： Variable containing:
 0.1576
[torch.FloatTensor of size 1]

时间步 1228000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.197409e+01/ 轮得分 4.28
损失函数： Variable containing:
 0.1234
[torch.FloatTensor of size 1]

时间步 1229000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.524588e+01/ 轮得分 4.30
损失函数： Variable containing:
1.00000e-02 *
  3.9008
[torch.FloatTensor of size 1]

时间步 1230000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.403395e+01/ 轮得分 4.29
损失函数： Variable containing:
 0.1176
[torch.FloatTensor of size 1]

时间步 1231000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.297067e+01/ 轮得分 4.23
损失函数： Variable containing:
1.00000e-02 *
  4.5981
[torch.FloatTensor of size 1]

时间步 1232000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.300527e+01/ 轮得分 4.22
损失函数： Variable containing:
 0.1478
[torch.FloatTensor of size 1]

时间步 1233000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.365504e+01/ 轮得分 4.22
损失函数： Variable containing:
 1.0122
[torch.FloatTensor of size 1]

时间步 1234000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.303169e+01/ 轮得分 4.19
损失函数： Variable containing:
 0.1361
[torch.FloatTensor of size 1]

时间步 1235000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.433203e+01/ 轮得分 4.20
损失函数： Variable containing:
 0.1897
[torch.FloatTensor of size 1]

时间步 1236000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 8.219258e+00/ 轮得分 4.19
损失函数： Variable containing:
 0.4028
[torch.FloatTensor of size 1]

时间步 1237000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.181069e+01/ 轮得分 4.18
损失函数： Variable containing:
1.00000e-02 *
  5.7300
[torch.FloatTensor of size 1]

时间步 1238000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.523502e+01/ 轮得分 4.16
损失函数： Variable containing:
 0.1044
[torch.FloatTensor of size 1]

时间步 1239000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.232477e+01/ 轮得分 4.16
损失函数： Variable containing:
 0.1306
[torch.FloatTensor of size 1]

时间步 1240000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.280885e+01/ 轮得分 4.15
损失函数： Variable containing:
 0.1009
[torch.FloatTensor of size 1]

时间步 1241000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.563274e+01/ 轮得分 4.14
损失函数： Variable containing:
1.00000e-02 *
  5.5005
[torch.FloatTensor of size 1]

时间步 1242000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.327162e+01/ 轮得分 4.13
损失函数： Variable containing:
1.00000e-02 *
  6.6265
[torch.FloatTensor of size 1]

时间步 1243000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.400844e+01/ 轮得分 4.12
损失函数： Variable containing:
 0.1785
[torch.FloatTensor of size 1]

时间步 1244000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.442610e+01/ 轮得分 4.12
损失函数： Variable containing:
 0.3348
[torch.FloatTensor of size 1]

时间步 1245000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.219578e+01/ 轮得分 4.08
损失函数： Variable containing:
 0.1099
[torch.FloatTensor of size 1]

时间步 1246000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.416068e+01/ 轮得分 4.08
损失函数： Variable containing:
 0.1363
[torch.FloatTensor of size 1]

时间步 1247000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.086982e+01/ 轮得分 4.07
损失函数： Variable containing:
 0.4277
[torch.FloatTensor of size 1]

时间步 1248000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.138611e+01/ 轮得分 3.98
损失函数： Variable containing:
 0.5047
[torch.FloatTensor of size 1]

时间步 1249000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.391552e+01/ 轮得分 4.00
损失函数： Variable containing:
 0.1085
[torch.FloatTensor of size 1]

时间步 1250000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.333700e+01/ 轮得分 3.99
损失函数： Variable containing:
1.00000e-02 *
  6.3266
[torch.FloatTensor of size 1]

时间步 1251000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.278483e+01/ 轮得分 4.01
损失函数： Variable containing:
 0.1413
[torch.FloatTensor of size 1]

时间步 1252000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.464583e+01/ 轮得分 3.95
损失函数： Variable containing:
1.00000e-02 *
  7.0025
[torch.FloatTensor of size 1]

时间步 1253000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.515597e+01/ 轮得分 3.96
损失函数： Variable containing:
 0.2886
[torch.FloatTensor of size 1]

时间步 1254000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.388793e+01/ 轮得分 3.96
损失函数： Variable containing:
1.00000e-02 *
  7.2163
[torch.FloatTensor of size 1]

时间步 1255000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.603682e+01/ 轮得分 3.96
损失函数： Variable containing:
 0.1682
[torch.FloatTensor of size 1]

时间步 1256000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.283026e+01/ 轮得分 3.97
损失函数： Variable containing:
 0.1442
[torch.FloatTensor of size 1]

时间步 1257000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.171175e+01/ 轮得分 3.96
损失函数： Variable containing:
 0.2873
[torch.FloatTensor of size 1]

时间步 1258000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.488047e+01/ 轮得分 3.96
损失函数： Variable containing:
1.00000e-02 *
  6.6649
[torch.FloatTensor of size 1]

时间步 1259000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.427289e+01/ 轮得分 3.94
损失函数： Variable containing:
1.00000e-02 *
  7.9978
[torch.FloatTensor of size 1]

时间步 1260000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.311790e+01/ 轮得分 3.95
损失函数： Variable containing:
1.00000e-02 *
  7.3575
[torch.FloatTensor of size 1]

时间步 1261000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.521879e+01/ 轮得分 3.97
损失函数： Variable containing:
 0.1511
[torch.FloatTensor of size 1]

时间步 1262000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.562828e+01/ 轮得分 3.99
损失函数： Variable containing:
 0.7842
[torch.FloatTensor of size 1]

时间步 1263000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.439343e+01/ 轮得分 3.99
损失函数： Variable containing:
1.00000e-02 *
  6.9918
[torch.FloatTensor of size 1]

时间步 1264000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.466656e+01/ 轮得分 3.98
损失函数： Variable containing:
 0.4736
[torch.FloatTensor of size 1]

时间步 1265000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.574968e+01/ 轮得分 3.98
损失函数： Variable containing:
 0.2419
[torch.FloatTensor of size 1]

时间步 1266000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.492933e+01/ 轮得分 4.00
损失函数： Variable containing:
 0.1632
[torch.FloatTensor of size 1]

时间步 1267000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.248761e+01/ 轮得分 4.01
损失函数： Variable containing:
1.00000e-02 *
  5.8204
[torch.FloatTensor of size 1]

时间步 1268000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.427525e+01/ 轮得分 4.00
损失函数： Variable containing:
 0.3626
[torch.FloatTensor of size 1]

时间步 1269000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.345202e+01/ 轮得分 4.01
损失函数： Variable containing:
1.00000e-02 *
  7.3488
[torch.FloatTensor of size 1]

时间步 1270000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.495162e+01/ 轮得分 4.03
损失函数： Variable containing:
1.00000e-02 *
  5.4348
[torch.FloatTensor of size 1]

时间步 1271000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.370371e+01/ 轮得分 4.02
损失函数： Variable containing:
1.00000e-02 *
  4.0993
[torch.FloatTensor of size 1]

时间步 1272000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.363243e+01/ 轮得分 4.00
损失函数： Variable containing:
1.00000e-02 *
  8.6425
[torch.FloatTensor of size 1]

时间步 1273000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.411586e+01/ 轮得分 4.00
损失函数： Variable containing:
 0.1850
[torch.FloatTensor of size 1]

时间步 1274000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.317928e+01/ 轮得分 3.99
损失函数： Variable containing:
 0.1150
[torch.FloatTensor of size 1]

时间步 1275000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.483985e+01/ 轮得分 4.00
损失函数： Variable containing:
 0.1793
[torch.FloatTensor of size 1]

时间步 1276000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.298802e+01/ 轮得分 3.98
损失函数： Variable containing:
 0.1606
[torch.FloatTensor of size 1]

时间步 1277000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.400475e+01/ 轮得分 3.98
损失函数： Variable containing:
 0.2170
[torch.FloatTensor of size 1]

时间步 1278000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.120354e+01/ 轮得分 3.98
损失函数： Variable containing:
1.00000e-02 *
  5.7015
[torch.FloatTensor of size 1]

时间步 1279000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.411135e+01/ 轮得分 3.98
损失函数： Variable containing:
1.00000e-02 *
  5.5473
[torch.FloatTensor of size 1]

时间步 1280000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.158001e+01/ 轮得分 3.95
损失函数： Variable containing:
1.00000e-02 *
  5.9341
[torch.FloatTensor of size 1]

时间步 1281000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.539590e+01/ 轮得分 3.97
损失函数： Variable containing:
1.00000e-02 *
  6.8009
[torch.FloatTensor of size 1]

时间步 1282000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.426250e+01/ 轮得分 3.98
损失函数： Variable containing:
1.00000e-02 *
  7.2260
[torch.FloatTensor of size 1]

时间步 1283000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.190073e+01/ 轮得分 4.00
损失函数： Variable containing:
 0.4000
[torch.FloatTensor of size 1]

时间步 1284000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.447372e+01/ 轮得分 4.00
损失函数： Variable containing:
1.00000e-02 *
  1.2835
[torch.FloatTensor of size 1]

时间步 1285000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.425220e+01/ 轮得分 4.01
损失函数： Variable containing:
1.00000e-02 *
  7.3436
[torch.FloatTensor of size 1]

时间步 1286000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.259432e+01/ 轮得分 4.04
损失函数： Variable containing:
 0.1751
[torch.FloatTensor of size 1]

时间步 1287000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.238904e+01/ 轮得分 4.04
损失函数： Variable containing:
1.00000e-02 *
  4.2653
[torch.FloatTensor of size 1]

时间步 1288000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 8.389017e+00/ 轮得分 4.02
损失函数： Variable containing:
1.00000e-02 *
  3.5024
[torch.FloatTensor of size 1]

时间步 1289000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.202069e+01/ 轮得分 4.03
损失函数： Variable containing:
 0.1419
[torch.FloatTensor of size 1]

时间步 1290000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.380442e+01/ 轮得分 4.05
损失函数： Variable containing:
 0.9819
[torch.FloatTensor of size 1]

时间步 1291000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.453267e+01/ 轮得分 4.05
损失函数： Variable containing:
 0.1925
[torch.FloatTensor of size 1]

时间步 1292000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.586532e+01/ 轮得分 4.06
损失函数： Variable containing:
 0.6083
[torch.FloatTensor of size 1]

时间步 1293000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.399226e+01/ 轮得分 4.05
损失函数： Variable containing:
 0.1113
[torch.FloatTensor of size 1]

时间步 1294000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.289657e+01/ 轮得分 4.03
损失函数： Variable containing:
1.00000e-02 *
  5.3260
[torch.FloatTensor of size 1]

时间步 1295000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.439630e+01/ 轮得分 4.06
损失函数： Variable containing:
 1.6066
[torch.FloatTensor of size 1]

时间步 1296000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.247454e+01/ 轮得分 4.08
损失函数： Variable containing:
 1.4376
[torch.FloatTensor of size 1]

时间步 1297000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.366857e+01/ 轮得分 4.09
损失函数： Variable containing:
1.00000e-02 *
  9.7500
[torch.FloatTensor of size 1]

时间步 1298000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.390882e+01/ 轮得分 4.11
损失函数： Variable containing:
1.00000e-02 *
  2.7531
[torch.FloatTensor of size 1]

时间步 1299000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.277401e+01/ 轮得分 4.07
损失函数： Variable containing:
1.00000e-02 *
  6.1374
[torch.FloatTensor of size 1]

时间步 1300000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.418966e+01/ 轮得分 4.09
损失函数： Variable containing:
1.00000e-02 *
  8.1835
[torch.FloatTensor of size 1]

时间步 1301000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.053015e+01/ 轮得分 4.03
损失函数： Variable containing:
 0.2499
[torch.FloatTensor of size 1]

时间步 1302000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.091818e+01/ 轮得分 4.05
损失函数： Variable containing:
 0.1544
[torch.FloatTensor of size 1]

时间步 1303000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 -1/ Q_MAX 4.822335e+00/ 轮得分 4.05
损失函数： Variable containing:
 0.1142
[torch.FloatTensor of size 1]

时间步 1304000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.334761e+01/ 轮得分 4.02
损失函数： Variable containing:
 0.1304
[torch.FloatTensor of size 1]

时间步 1305000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.546921e+01/ 轮得分 4.03
损失函数： Variable containing:
1.00000e-02 *
  9.1817
[torch.FloatTensor of size 1]

时间步 1306000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.232848e+01/ 轮得分 4.05
损失函数： Variable containing:
1.00000e-02 *
  7.4836
[torch.FloatTensor of size 1]

时间步 1307000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.463234e+01/ 轮得分 4.09
损失函数： Variable containing:
 0.1579
[torch.FloatTensor of size 1]

时间步 1308000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.561777e+01/ 轮得分 4.09
损失函数： Variable containing:
 0.5370
[torch.FloatTensor of size 1]

时间步 1309000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.559110e+01/ 轮得分 4.08
损失函数： Variable containing:
 0.1320
[torch.FloatTensor of size 1]

时间步 1310000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.524100e+01/ 轮得分 4.09
损失函数： Variable containing:
 0.1132
[torch.FloatTensor of size 1]

时间步 1311000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.605250e+01/ 轮得分 4.09
损失函数： Variable containing:
1.00000e-02 *
  6.9588
[torch.FloatTensor of size 1]

时间步 1312000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.691060e+01/ 轮得分 4.09
损失函数： Variable containing:
 0.1056
[torch.FloatTensor of size 1]

时间步 1313000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.498062e+01/ 轮得分 4.11
损失函数： Variable containing:
 0.1305
[torch.FloatTensor of size 1]

时间步 1314000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.287364e+01/ 轮得分 4.13
损失函数： Variable containing:
 1.2030
[torch.FloatTensor of size 1]

时间步 1315000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.339162e+01/ 轮得分 4.14
损失函数： Variable containing:
1.00000e-02 *
  9.7929
[torch.FloatTensor of size 1]

时间步 1316000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.427558e+01/ 轮得分 4.15
损失函数： Variable containing:
1.00000e-02 *
  8.2692
[torch.FloatTensor of size 1]

时间步 1317000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.587273e+01/ 轮得分 4.15
损失函数： Variable containing:
 0.1864
[torch.FloatTensor of size 1]

时间步 1318000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.410438e+01/ 轮得分 4.14
损失函数： Variable containing:
 0.3047
[torch.FloatTensor of size 1]

时间步 1319000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.672065e+01/ 轮得分 4.14
损失函数： Variable containing:
 0.2306
[torch.FloatTensor of size 1]

时间步 1320000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.173335e+01/ 轮得分 4.17
损失函数： Variable containing:
1.00000e-02 *
  4.7776
[torch.FloatTensor of size 1]

时间步 1321000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.455067e+01/ 轮得分 4.18
损失函数： Variable containing:
 0.1091
[torch.FloatTensor of size 1]

时间步 1322000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.697311e+01/ 轮得分 4.20
损失函数： Variable containing:
 0.2725
[torch.FloatTensor of size 1]

时间步 1323000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.520923e+01/ 轮得分 4.20
损失函数： Variable containing:
1.00000e-02 *
  8.7027
[torch.FloatTensor of size 1]

时间步 1324000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 7.849274e+00/ 轮得分 4.20
损失函数： Variable containing:
 0.8265
[torch.FloatTensor of size 1]

时间步 1325000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.499781e+01/ 轮得分 4.20
损失函数： Variable containing:
1.00000e-02 *
  6.9924
[torch.FloatTensor of size 1]

时间步 1326000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.531340e+01/ 轮得分 4.20
损失函数： Variable containing:
 0.1136
[torch.FloatTensor of size 1]

时间步 1327000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 3.002403e+00/ 轮得分 4.22
损失函数： Variable containing:
1.00000e-02 *
  5.7930
[torch.FloatTensor of size 1]

时间步 1328000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.331255e+01/ 轮得分 4.22
损失函数： Variable containing:
 0.1484
[torch.FloatTensor of size 1]

时间步 1329000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.618724e+01/ 轮得分 4.25
损失函数： Variable containing:
 0.2528
[torch.FloatTensor of size 1]

时间步 1330000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.519123e+01/ 轮得分 4.21
损失函数： Variable containing:
1.00000e-02 *
  2.1835
[torch.FloatTensor of size 1]

时间步 1331000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.478661e+01/ 轮得分 4.19
损失函数： Variable containing:
 0.1031
[torch.FloatTensor of size 1]

时间步 1332000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.325176e+01/ 轮得分 4.20
损失函数： Variable containing:
 0.1587
[torch.FloatTensor of size 1]

时间步 1333000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.193671e+01/ 轮得分 4.22
损失函数： Variable containing:
1.00000e-02 *
  3.1906
[torch.FloatTensor of size 1]

时间步 1334000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.461292e+01/ 轮得分 4.23
损失函数： Variable containing:
 0.1524
[torch.FloatTensor of size 1]

时间步 1335000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.730280e+01/ 轮得分 4.20
损失函数： Variable containing:
1.00000e-02 *
  6.5486
[torch.FloatTensor of size 1]

时间步 1336000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 8.330060e+00/ 轮得分 4.21
损失函数： Variable containing:
 0.2440
[torch.FloatTensor of size 1]

时间步 1337000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.270278e+01/ 轮得分 4.22
损失函数： Variable containing:
1.00000e-02 *
  5.6390
[torch.FloatTensor of size 1]

时间步 1338000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 4.328400e+00/ 轮得分 4.23
损失函数： Variable containing:
 0.1199
[torch.FloatTensor of size 1]

时间步 1339000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.747496e+01/ 轮得分 4.21
损失函数： Variable containing:
 0.7353
[torch.FloatTensor of size 1]

时间步 1340000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.504031e+01/ 轮得分 4.23
损失函数： Variable containing:
 0.6633
[torch.FloatTensor of size 1]

时间步 1341000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.665310e+01/ 轮得分 4.23
损失函数： Variable containing:
 1.4901
[torch.FloatTensor of size 1]

时间步 1342000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.476888e+01/ 轮得分 4.24
损失函数： Variable containing:
 0.1609
[torch.FloatTensor of size 1]

时间步 1343000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.329298e+01/ 轮得分 4.26
损失函数： Variable containing:
 0.1385
[torch.FloatTensor of size 1]

时间步 1344000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.507757e+01/ 轮得分 4.24
损失函数： Variable containing:
 0.1577
[torch.FloatTensor of size 1]

时间步 1345000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.181291e+01/ 轮得分 4.25
损失函数： Variable containing:
 0.3041
[torch.FloatTensor of size 1]

时间步 1346000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.398442e+01/ 轮得分 4.24
损失函数： Variable containing:
 0.1560
[torch.FloatTensor of size 1]

时间步 1347000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.273634e+01/ 轮得分 4.22
损失函数： Variable containing:
1.00000e-02 *
  3.5744
[torch.FloatTensor of size 1]

时间步 1348000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.330471e+01/ 轮得分 4.22
损失函数： Variable containing:
 0.1908
[torch.FloatTensor of size 1]

时间步 1349000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.263480e+01/ 轮得分 4.21
损失函数： Variable containing:
1.00000e-02 *
  5.7433
[torch.FloatTensor of size 1]

时间步 1350000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.491555e+01/ 轮得分 4.25
损失函数： Variable containing:
1.00000e-02 *
  5.1958
[torch.FloatTensor of size 1]

时间步 1351000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.499604e+01/ 轮得分 4.28
损失函数： Variable containing:
1.00000e-02 *
  9.0323
[torch.FloatTensor of size 1]

时间步 1352000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.768733e+01/ 轮得分 4.29
损失函数： Variable containing:
1.00000e-02 *
  7.5489
[torch.FloatTensor of size 1]

时间步 1353000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.575253e+01/ 轮得分 4.29
损失函数： Variable containing:
1.00000e-02 *
  6.1625
[torch.FloatTensor of size 1]

时间步 1354000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.282172e+01/ 轮得分 4.27
损失函数： Variable containing:
 0.2698
[torch.FloatTensor of size 1]

时间步 1355000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.684097e+01/ 轮得分 4.29
损失函数： Variable containing:
 0.1858
[torch.FloatTensor of size 1]

时间步 1356000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.366657e+01/ 轮得分 4.28
损失函数： Variable containing:
 0.1272
[torch.FloatTensor of size 1]

时间步 1357000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.122254e+01/ 轮得分 4.28
损失函数： Variable containing:
 0.9342
[torch.FloatTensor of size 1]

时间步 1358000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.379819e+01/ 轮得分 4.28
损失函数： Variable containing:
 0.3678
[torch.FloatTensor of size 1]

时间步 1359000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.465174e+01/ 轮得分 4.25
损失函数： Variable containing:
 0.1833
[torch.FloatTensor of size 1]

时间步 1360000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.312324e+01/ 轮得分 4.27
损失函数： Variable containing:
1.00000e-02 *
  8.0705
[torch.FloatTensor of size 1]

时间步 1361000/ 状态 explore/ Epsilon 0.06/ 行动 0/ 奖励 0.1/ Q_MAX 1.694113e+01/ 轮得分 4.27
损失函数： Variable containing:
 0.1296
[torch.FloatTensor of size 1]

时间步 1362000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.524207e+01/ 轮得分 4.28
损失函数： Variable containing:
 0.2369
[torch.FloatTensor of size 1]

时间步 1363000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.637340e+01/ 轮得分 4.25
损失函数： Variable containing:
1.00000e-02 *
  7.9346
[torch.FloatTensor of size 1]

时间步 1364000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.499402e+01/ 轮得分 4.25
损失函数： Variable containing:
 0.1902
[torch.FloatTensor of size 1]

时间步 1365000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.013747e+01/ 轮得分 4.21
损失函数： Variable containing:
1.00000e-02 *
  5.9162
[torch.FloatTensor of size 1]

时间步 1366000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.423325e+01/ 轮得分 4.23
损失函数： Variable containing:
 0.5846
[torch.FloatTensor of size 1]

时间步 1367000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.287341e+01/ 轮得分 4.25
损失函数： Variable containing:
1.00000e-02 *
  5.0358
[torch.FloatTensor of size 1]

时间步 1368000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 5.988059e+00/ 轮得分 4.26
损失函数： Variable containing:
1.00000e-02 *
  4.3917
[torch.FloatTensor of size 1]

时间步 1369000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.600941e+01/ 轮得分 4.23
损失函数： Variable containing:
1.00000e-02 *
  8.6822
[torch.FloatTensor of size 1]

时间步 1370000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.548197e+01/ 轮得分 4.25
损失函数： Variable containing:
1.00000e-02 *
  7.0515
[torch.FloatTensor of size 1]

时间步 1371000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.794974e+01/ 轮得分 4.26
损失函数： Variable containing:
1.00000e-02 *
  5.6991
[torch.FloatTensor of size 1]

时间步 1372000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX -1.172487e+00/ 轮得分 4.25
损失函数： Variable containing:
1.00000e-02 *
  8.2050
[torch.FloatTensor of size 1]

时间步 1373000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.562779e+01/ 轮得分 4.27
损失函数： Variable containing:
 0.1762
[torch.FloatTensor of size 1]

时间步 1374000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.703471e+01/ 轮得分 4.30
损失函数： Variable containing:
 0.4588
[torch.FloatTensor of size 1]

时间步 1375000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.480015e+01/ 轮得分 4.31
损失函数： Variable containing:
 0.4258
[torch.FloatTensor of size 1]

时间步 1376000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.785561e+01/ 轮得分 4.30
损失函数： Variable containing:
 0.1010
[torch.FloatTensor of size 1]

时间步 1377000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.752147e+01/ 轮得分 4.32
损失函数： Variable containing:
 0.1423
[torch.FloatTensor of size 1]

时间步 1378000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.572668e+01/ 轮得分 4.33
损失函数： Variable containing:
1.00000e-02 *
  7.1811
[torch.FloatTensor of size 1]

时间步 1379000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.491350e+01/ 轮得分 4.34
损失函数： Variable containing:
 0.5205
[torch.FloatTensor of size 1]

时间步 1380000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.805968e+01/ 轮得分 4.38
损失函数： Variable containing:
 0.5094
[torch.FloatTensor of size 1]

时间步 1381000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.150430e+01/ 轮得分 4.38
损失函数： Variable containing:
 1.1232
[torch.FloatTensor of size 1]

时间步 1382000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.649384e+01/ 轮得分 4.37
损失函数： Variable containing:
1.00000e-02 *
  9.8902
[torch.FloatTensor of size 1]

时间步 1383000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.380739e+01/ 轮得分 4.39
损失函数： Variable containing:
 0.1881
[torch.FloatTensor of size 1]

时间步 1384000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.678091e+01/ 轮得分 4.36
损失函数： Variable containing:
1.00000e-02 *
  7.6955
[torch.FloatTensor of size 1]

时间步 1385000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.555374e+01/ 轮得分 4.39
损失函数： Variable containing:
 0.1521
[torch.FloatTensor of size 1]

时间步 1386000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.053933e+01/ 轮得分 4.39
损失函数： Variable containing:
 0.1486
[torch.FloatTensor of size 1]

时间步 1387000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.821539e+01/ 轮得分 4.42
损失函数： Variable containing:
 0.1031
[torch.FloatTensor of size 1]

时间步 1388000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.378086e+01/ 轮得分 4.40
损失函数： Variable containing:
 1.1105
[torch.FloatTensor of size 1]

时间步 1389000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.583215e+01/ 轮得分 4.39
损失函数： Variable containing:
 0.3086
[torch.FloatTensor of size 1]

时间步 1390000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.705759e+01/ 轮得分 4.36
损失函数： Variable containing:
 0.1592
[torch.FloatTensor of size 1]

时间步 1391000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.559493e+01/ 轮得分 4.38
损失函数： Variable containing:
 0.3566
[torch.FloatTensor of size 1]

时间步 1392000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.691225e+01/ 轮得分 4.41
损失函数： Variable containing:
 0.1995
[torch.FloatTensor of size 1]

时间步 1393000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.561146e+01/ 轮得分 4.43
损失函数： Variable containing:
1.00000e-02 *
  7.3975
[torch.FloatTensor of size 1]

时间步 1394000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.459947e+01/ 轮得分 4.46
损失函数： Variable containing:
1.00000e-02 *
  3.6030
[torch.FloatTensor of size 1]

时间步 1395000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.656328e+01/ 轮得分 4.51
损失函数： Variable containing:
 0.1835
[torch.FloatTensor of size 1]

时间步 1396000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.474696e+01/ 轮得分 4.53
损失函数： Variable containing:
 0.2938
[torch.FloatTensor of size 1]

时间步 1397000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.478822e+01/ 轮得分 4.52
损失函数： Variable containing:
 0.1016
[torch.FloatTensor of size 1]

时间步 1398000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.626347e+01/ 轮得分 4.53
损失函数： Variable containing:
 0.1751
[torch.FloatTensor of size 1]

时间步 1399000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.520194e+01/ 轮得分 4.57
损失函数： Variable containing:
 1.6411
[torch.FloatTensor of size 1]

时间步 1400000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.800047e+01/ 轮得分 4.59
损失函数： Variable containing:
 0.1088
[torch.FloatTensor of size 1]

时间步 1401000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.478143e+01/ 轮得分 4.58
损失函数： Variable containing:
 0.1337
[torch.FloatTensor of size 1]

时间步 1402000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.627165e+01/ 轮得分 4.57
损失函数： Variable containing:
 0.1141
[torch.FloatTensor of size 1]

时间步 1403000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.654837e+01/ 轮得分 4.54
损失函数： Variable containing:
 2.2753
[torch.FloatTensor of size 1]

时间步 1404000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.711394e+01/ 轮得分 4.54
损失函数： Variable containing:
 0.1214
[torch.FloatTensor of size 1]

时间步 1405000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.733872e+01/ 轮得分 4.56
损失函数： Variable containing:
1.00000e-02 *
  2.0180
[torch.FloatTensor of size 1]

时间步 1406000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.690641e+01/ 轮得分 4.60
损失函数： Variable containing:
1.00000e-02 *
  8.1657
[torch.FloatTensor of size 1]

时间步 1407000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 -1/ Q_MAX 9.138852e+00/ 轮得分 4.61
损失函数： Variable containing:
 0.1157
[torch.FloatTensor of size 1]

时间步 1408000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.719437e+01/ 轮得分 4.60
损失函数： Variable containing:
1.00000e-02 *
  9.7885
[torch.FloatTensor of size 1]

时间步 1409000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.841278e+01/ 轮得分 4.59
损失函数： Variable containing:
1.00000e-02 *
  9.3503
[torch.FloatTensor of size 1]

时间步 1410000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.876432e+01/ 轮得分 4.62
损失函数： Variable containing:
 0.1252
[torch.FloatTensor of size 1]

时间步 1411000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.974614e+01/ 轮得分 4.63
损失函数： Variable containing:
 0.1792
[torch.FloatTensor of size 1]

时间步 1412000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.547789e+01/ 轮得分 4.63
损失函数： Variable containing:
 0.1999
[torch.FloatTensor of size 1]

时间步 1413000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.839694e+01/ 轮得分 4.65
损失函数： Variable containing:
 0.1904
[torch.FloatTensor of size 1]

时间步 1414000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.597237e+01/ 轮得分 4.64
损失函数： Variable containing:
 0.1020
[torch.FloatTensor of size 1]

时间步 1415000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.696577e+01/ 轮得分 4.64
损失函数： Variable containing:
 0.1296
[torch.FloatTensor of size 1]

时间步 1416000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.398677e+01/ 轮得分 4.64
损失函数： Variable containing:
 0.1173
[torch.FloatTensor of size 1]

时间步 1417000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 3.678239e+00/ 轮得分 4.65
损失函数： Variable containing:
 0.5332
[torch.FloatTensor of size 1]

时间步 1418000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.525328e+01/ 轮得分 4.67
损失函数： Variable containing:
 0.1081
[torch.FloatTensor of size 1]

时间步 1419000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.224273e+01/ 轮得分 4.63
损失函数： Variable containing:
 0.9166
[torch.FloatTensor of size 1]

时间步 1420000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.286069e+01/ 轮得分 4.65
损失函数： Variable containing:
 0.1173
[torch.FloatTensor of size 1]

时间步 1421000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.282300e+01/ 轮得分 4.65
损失函数： Variable containing:
1.00000e-02 *
  4.9909
[torch.FloatTensor of size 1]

时间步 1422000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.666358e+01/ 轮得分 4.67
损失函数： Variable containing:
 0.2016
[torch.FloatTensor of size 1]

时间步 1423000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.694927e+01/ 轮得分 4.65
损失函数： Variable containing:
1.00000e-02 *
  6.6274
[torch.FloatTensor of size 1]

时间步 1424000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.439860e+01/ 轮得分 4.65
损失函数： Variable containing:
 0.1146
[torch.FloatTensor of size 1]

时间步 1425000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 1/ Q_MAX 1.197904e+01/ 轮得分 4.68
损失函数： Variable containing:
 0.4804
[torch.FloatTensor of size 1]

时间步 1426000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.693166e+01/ 轮得分 4.69
损失函数： Variable containing:
 0.1317
[torch.FloatTensor of size 1]

时间步 1427000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.744474e+01/ 轮得分 4.64
损失函数： Variable containing:
 0.5269
[torch.FloatTensor of size 1]

时间步 1428000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.726198e+01/ 轮得分 4.64
损失函数： Variable containing:
 0.1903
[torch.FloatTensor of size 1]

时间步 1429000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.653884e+01/ 轮得分 4.62
损失函数： Variable containing:
 0.1465
[torch.FloatTensor of size 1]

时间步 1430000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.748230e+01/ 轮得分 4.64
损失函数： Variable containing:
 0.1279
[torch.FloatTensor of size 1]

时间步 1431000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.675936e+01/ 轮得分 4.66
损失函数： Variable containing:
 0.2548
[torch.FloatTensor of size 1]

时间步 1432000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.725254e+01/ 轮得分 4.67
损失函数： Variable containing:
 0.1120
[torch.FloatTensor of size 1]

时间步 1433000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.769274e+01/ 轮得分 4.69
损失函数： Variable containing:
 0.1228
[torch.FloatTensor of size 1]

时间步 1434000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.569181e+01/ 轮得分 4.66
损失函数： Variable containing:
1.00000e-02 *
  6.4657
[torch.FloatTensor of size 1]

时间步 1435000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.796012e+01/ 轮得分 4.70
损失函数： Variable containing:
1.00000e-02 *
  7.8636
[torch.FloatTensor of size 1]

时间步 1436000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.652022e+01/ 轮得分 4.65
损失函数： Variable containing:
1.00000e-02 *
  4.0617
[torch.FloatTensor of size 1]

时间步 1437000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.681675e+01/ 轮得分 4.67
损失函数： Variable containing:
 0.1014
[torch.FloatTensor of size 1]

时间步 1438000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.776375e+01/ 轮得分 4.64
损失函数： Variable containing:
 0.1413
[torch.FloatTensor of size 1]

时间步 1439000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.323769e+01/ 轮得分 4.63
损失函数： Variable containing:
 0.1154
[torch.FloatTensor of size 1]

时间步 1440000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.571705e+01/ 轮得分 4.63
损失函数： Variable containing:
1.00000e-02 *
  6.8636
[torch.FloatTensor of size 1]

时间步 1441000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.838034e+01/ 轮得分 4.63
损失函数： Variable containing:
1.00000e-02 *
  3.9233
[torch.FloatTensor of size 1]

时间步 1442000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.483264e+01/ 轮得分 4.63
损失函数： Variable containing:
 0.1200
[torch.FloatTensor of size 1]

时间步 1443000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.828234e+01/ 轮得分 4.64
损失函数： Variable containing:
1.00000e-02 *
  2.5841
[torch.FloatTensor of size 1]

时间步 1444000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.506907e+01/ 轮得分 4.65
损失函数： Variable containing:
 0.5997
[torch.FloatTensor of size 1]

时间步 1445000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.890898e+01/ 轮得分 4.67
损失函数： Variable containing:
 0.1223
[torch.FloatTensor of size 1]

时间步 1446000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.795605e+01/ 轮得分 4.62
损失函数： Variable containing:
 0.2828
[torch.FloatTensor of size 1]

时间步 1447000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.696267e+01/ 轮得分 4.56
损失函数： Variable containing:
 0.1901
[torch.FloatTensor of size 1]

时间步 1448000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.694737e+01/ 轮得分 4.51
损失函数： Variable containing:
 0.1886
[torch.FloatTensor of size 1]

时间步 1449000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.728972e+01/ 轮得分 4.49
损失函数： Variable containing:
 0.2530
[torch.FloatTensor of size 1]

时间步 1450000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.658863e+01/ 轮得分 4.45
损失函数： Variable containing:
 0.3170
[torch.FloatTensor of size 1]

时间步 1451000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.470767e+01/ 轮得分 4.42
损失函数： Variable containing:
 0.2446
[torch.FloatTensor of size 1]

时间步 1452000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.786950e+01/ 轮得分 4.41
损失函数： Variable containing:
1.00000e-02 *
  4.2246
[torch.FloatTensor of size 1]

时间步 1453000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.741850e+01/ 轮得分 4.39
损失函数： Variable containing:
 0.1952
[torch.FloatTensor of size 1]

时间步 1454000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.637932e+01/ 轮得分 4.40
损失函数： Variable containing:
 0.1931
[torch.FloatTensor of size 1]

时间步 1455000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.584732e+01/ 轮得分 4.41
损失函数： Variable containing:
 0.6026
[torch.FloatTensor of size 1]

时间步 1456000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.463280e+01/ 轮得分 4.36
损失函数： Variable containing:
 0.1753
[torch.FloatTensor of size 1]

时间步 1457000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 1/ Q_MAX 1.635700e+01/ 轮得分 4.36
损失函数： Variable containing:
 0.1487
[torch.FloatTensor of size 1]

时间步 1458000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.612537e+01/ 轮得分 4.35
损失函数： Variable containing:
1.00000e-02 *
  8.0333
[torch.FloatTensor of size 1]

时间步 1459000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.691496e+01/ 轮得分 4.32
损失函数： Variable containing:
 0.1148
[torch.FloatTensor of size 1]

时间步 1460000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.466806e+01/ 轮得分 4.27
损失函数： Variable containing:
 0.8715
[torch.FloatTensor of size 1]

时间步 1461000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.040201e+01/ 轮得分 4.28
损失函数： Variable containing:
1.00000e-02 *
  7.9157
[torch.FloatTensor of size 1]

时间步 1462000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.299781e+01/ 轮得分 4.25
损失函数： Variable containing:
 0.7269
[torch.FloatTensor of size 1]

时间步 1463000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.742583e+01/ 轮得分 4.22
损失函数： Variable containing:
 0.1085
[torch.FloatTensor of size 1]

时间步 1464000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.371568e+01/ 轮得分 4.21
损失函数： Variable containing:
 0.1608
[torch.FloatTensor of size 1]

时间步 1465000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.468859e+01/ 轮得分 4.23
损失函数： Variable containing:
 0.2354
[torch.FloatTensor of size 1]

时间步 1466000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.702446e+01/ 轮得分 4.24
损失函数： Variable containing:
1.00000e-02 *
  6.9354
[torch.FloatTensor of size 1]

时间步 1467000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.898382e+01/ 轮得分 4.24
损失函数： Variable containing:
 0.1688
[torch.FloatTensor of size 1]

时间步 1468000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.300914e+01/ 轮得分 4.25
损失函数： Variable containing:
 0.2738
[torch.FloatTensor of size 1]

时间步 1469000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.811322e+01/ 轮得分 4.26
损失函数： Variable containing:
 0.1763
[torch.FloatTensor of size 1]

时间步 1470000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.772765e+01/ 轮得分 4.25
损失函数： Variable containing:
 0.9846
[torch.FloatTensor of size 1]

时间步 1471000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.437825e+01/ 轮得分 4.24
损失函数： Variable containing:
 0.1525
[torch.FloatTensor of size 1]

时间步 1472000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.463479e+01/ 轮得分 4.27
损失函数： Variable containing:
 0.1994
[torch.FloatTensor of size 1]

时间步 1473000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 -1/ Q_MAX 5.315584e+00/ 轮得分 4.28
损失函数： Variable containing:
1.00000e-02 *
  6.6655
[torch.FloatTensor of size 1]

时间步 1474000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.617879e+01/ 轮得分 4.26
损失函数： Variable containing:
 0.1684
[torch.FloatTensor of size 1]

时间步 1475000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.549612e+01/ 轮得分 4.23
损失函数： Variable containing:
 0.3286
[torch.FloatTensor of size 1]

时间步 1476000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.438738e+01/ 轮得分 4.23
损失函数： Variable containing:
 0.1618
[torch.FloatTensor of size 1]

时间步 1477000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.611765e+01/ 轮得分 4.24
损失函数： Variable containing:
 0.2830
[torch.FloatTensor of size 1]

时间步 1478000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.613704e+01/ 轮得分 4.24
损失函数： Variable containing:
1.00000e-02 *
  4.7094
[torch.FloatTensor of size 1]

时间步 1479000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.694526e+01/ 轮得分 4.17
损失函数： Variable containing:
 0.1215
[torch.FloatTensor of size 1]

时间步 1480000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.735994e+01/ 轮得分 4.13
损失函数： Variable containing:
 0.1196
[torch.FloatTensor of size 1]

时间步 1481000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.523408e+01/ 轮得分 4.09
损失函数： Variable containing:
1.00000e-02 *
  5.1437
[torch.FloatTensor of size 1]

时间步 1482000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.358241e+01/ 轮得分 4.09
损失函数： Variable containing:
 0.3994
[torch.FloatTensor of size 1]

时间步 1483000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.381103e+01/ 轮得分 4.05
损失函数： Variable containing:
 0.1333
[torch.FloatTensor of size 1]

时间步 1484000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.879472e+01/ 轮得分 4.06
损失函数： Variable containing:
 0.1000
[torch.FloatTensor of size 1]

时间步 1485000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.519205e+01/ 轮得分 4.06
损失函数： Variable containing:
 0.1017
[torch.FloatTensor of size 1]

时间步 1486000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.659440e+01/ 轮得分 4.07
损失函数： Variable containing:
 0.3294
[torch.FloatTensor of size 1]

时间步 1487000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.604937e+01/ 轮得分 4.05
损失函数： Variable containing:
1.00000e-02 *
  8.8702
[torch.FloatTensor of size 1]

时间步 1488000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.367863e+01/ 轮得分 4.03
损失函数： Variable containing:
 0.3692
[torch.FloatTensor of size 1]

时间步 1489000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.319905e+01/ 轮得分 4.04
损失函数： Variable containing:
 0.1713
[torch.FloatTensor of size 1]

时间步 1490000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.327721e+01/ 轮得分 4.05
损失函数： Variable containing:
1.00000e-02 *
  9.0001
[torch.FloatTensor of size 1]

时间步 1491000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.382984e+01/ 轮得分 4.01
损失函数： Variable containing:
1.00000e-02 *
  3.5108
[torch.FloatTensor of size 1]

时间步 1492000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.224936e+01/ 轮得分 3.98
损失函数： Variable containing:
 0.1836
[torch.FloatTensor of size 1]

时间步 1493000/ 状态 explore/ Epsilon 0.05/ 行动 0/ 奖励 0.1/ Q_MAX 1.544460e+01/ 轮得分 4.01
损失函数： Variable containing:
1.00000e-02 *
  7.5796
[torch.FloatTensor of size 1]

In [18]:

    

f = open('final_log_file.txt', 'r')
line = f.read().strip().split('\n')
values = []
for ln in line:
    segs = ln.split('/')
    values.append(float(segs[-1].split(' ')[-1]))
plt.figure()
plt.plot(np.arange(len(values))*1000, values)
plt.xlabel('Frames')
plt.ylabel('Average Score')
plt.show()


    

In [20]:

    

#net = torch.load('saving_nets/' + GAME + '-dqn' + str(2876000) + '.txt')
net = torch.load('final_model.mdl')
FINAL_EPSILON = 0.0001 # epsilon的最终值
BATCH = 32 # 每一个批次的数据记录条数
FRAME_PER_ACTION = 1 # 每间隔多少时间完成一次有效动作的输出


    

In [21]:

    

# 开始在内存／GPU上定义一个网络
use_cuda = torch.cuda.is_available() #检测本台机器中是否有GPU

# 如果有GPU，就把神经网络全部搬到GPU内存中做运算
net = net.cuda() if use_cuda else net

# 开启一个游戏进程，开始与游戏引擎通话
game_state = GameState()

# 状态打印log记录位置
#a_file = open("logs_" + GAME + "/readout.txt", 'w')
#h_file = open("logs_" + GAME + "/hidden.txt", 'w')

# 将游戏设置为初始状态，并获得一个80*80的游戏湖面
do_nothing = np.zeros(ACTIONS)
do_nothing[0] = 1
x_t, r_0, terminal = game_state.frame_step(do_nothing)
x_t = cv2.cvtColor(cv2.resize(x_t, (80, 80)), cv2.COLOR_BGR2GRAY)
ret, x_t = cv2.threshold(x_t,1,255,cv2.THRESH_BINARY)

# 将初始的游戏画面叠加成4张作为神经网络的初始输入状态s_t
s_t = np.stack((x_t, x_t, x_t, x_t), axis=0)

# 设置初始的epsilon（采取随机行动的概率），并准备训练
epsilon = FINAL_EPSILON
t = 0# 记录每轮平均得分的容器
scores = []
all_turn_scores = []

fig = plt.figure()
axe = fig.add_subplot(111)
dat = np.zeros((10, 10))
img = axe.imshow(dat)
while "flappy bird" != "angry bird":
    # 开始游戏循环
    ######################################################
    ##########首先，按照贪婪策略选择一个行动 ##################
    s = Variable(torch.from_numpy(s_t).type(torch.FloatTensor))
    s = s.cuda() if use_cuda else s
    s = s.view(-1, s.size()[0], s.size()[1], s.size()[2])
    # 获取当前时刻的游戏画面，输入到神经网络中
    readout, h_fc1 = net(s)
    # 神经网络产生的输出为readout：选择每一个行动的预期Q值
    readout = readout.cpu() if use_cuda else readout
    # readout为一个二维向量，分别对应每一个动作的预期Q值
    readout_t = readout.data.numpy()[0]

    # 按照epsilon贪婪策略产生小鸟的行动，即以epsilon的概率随机输出行动或者以
    # 1-epsilon的概率按照预期输出最大的Q值给出行动
    a_t = np.zeros([ACTIONS])
    action_index = 0
    if t % FRAME_PER_ACTION == 0:
        # 如果当前帧可以行动，则
        if random.random() <= epsilon:
            # 产生随机行动
            #print("----------Random Action----------")
            action_index = random.randrange(ACTIONS)
        else:
            # 选择神经网络判断的预期Q最大的行动
            action_index = np.argmax(readout_t)
        a_t[action_index] = 1
    else:
        a_t[0] = 1 # do nothing
    ######################################################################### 
    ##########其次，将选择好的行动输入给游戏引擎，并得到下一帧的状态 ################### 
    x_t1_colored, r_t, terminal = game_state.frame_step(a_t)
    # 返回的x_t1_colored为游戏画面，r_t为本轮的得分，terminal为游戏在本轮是否已经结束
    
    # 记录一下每一步的成绩
    scores.append(r_t)
    if terminal:
        # 当游戏结束的时候，计算一下本轮的总成绩，并将总成绩存储到all_turn_scores中
        all_turn_scores.append(sum(scores))
        scores = []
    
    # 对游戏的原始画面做相应的处理，从而变成一张80*80的，朴素的（无背景画面）的图
    x_t1 = cv2.cvtColor(cv2.resize(x_t1_colored, (80, 80)), cv2.COLOR_BGR2GRAY)
    ret, x_t1 = cv2.threshold(x_t1, 1, 255, cv2.THRESH_BINARY)
    x_t1 = np.reshape(x_t1, (1, 80, 80))
    # 将当前帧的画面和前三帧的画面合并起来作为Agent获得的环境反馈结果
    s_t1 = np.append(x_t1, s_t[:3, :, :], axis=0)
    s_t = s_t1
    t += 1
    clear_output(wait = True)
    
    image = np.transpose(x_t1_colored, (1, 0, 2))
    img.set_data(image)
    img.autoscale()
    display(fig)


    

    




---------------------------------------------------------------------------
KeyboardInterrupt                         Traceback (most recent call last)
<ipython-input-21-6053185c23ce> in <module>()
     87     img.set_data(image)
     88     img.autoscale()
---> 89     display(fig)

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/IPython/core/display.py in display(include, exclude, metadata, transient, display_id, *objs, **kwargs)
    300             publish_display_data(data=obj, metadata=metadata, **kwargs)
    301         else:
--> 302             format_dict, md_dict = format(obj, include=include, exclude=exclude)
    303             if not format_dict:
    304                 # nothing to display (e.g. _ipython_display_ took over)

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/IPython/core/formatters.py in format(self, obj, include, exclude)
    169             md = None
    170             try:
--> 171                 data = formatter(obj)
    172             except:
    173                 # FIXME: log the exception

<decorator-gen-9> in __call__(self, obj)

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/IPython/core/formatters.py in catch_format_error(method, self, *args, **kwargs)
    213     """show traceback on failed format call"""
    214     try:
--> 215         r = method(self, *args, **kwargs)
    216     except NotImplementedError:
    217         # don't warn on NotImplementedErrors

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/IPython/core/formatters.py in __call__(self, obj)
    330                 pass
    331             else:
--> 332                 return printer(obj)
    333             # Finally look for special method names
    334             method = get_real_method(obj, self.print_method)

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/IPython/core/pylabtools.py in <lambda>(fig)
    235 
    236     if 'png' in formats:
--> 237         png_formatter.for_type(Figure, lambda fig: print_figure(fig, 'png', **kwargs))
    238     if 'retina' in formats or 'png2x' in formats:
    239         png_formatter.for_type(Figure, lambda fig: retina_figure(fig, **kwargs))

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/IPython/core/pylabtools.py in print_figure(fig, fmt, bbox_inches, **kwargs)
    119 
    120     bytes_io = BytesIO()
--> 121     fig.canvas.print_figure(bytes_io, **kw)
    122     data = bytes_io.getvalue()
    123     if fmt == 'svg':

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/backend_bases.py in print_figure(self, filename, dpi, facecolor, edgecolor, orientation, format, **kwargs)
   2198                     orientation=orientation,
   2199                     dryrun=True,
-> 2200                     **kwargs)
   2201                 renderer = self.figure._cachedRenderer
   2202                 bbox_inches = self.figure.get_tightbbox(renderer)

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/backends/backend_agg.py in print_png(self, filename_or_obj, *args, **kwargs)
    543 
    544     def print_png(self, filename_or_obj, *args, **kwargs):
--> 545         FigureCanvasAgg.draw(self)
    546         renderer = self.get_renderer()
    547         original_dpi = renderer.dpi

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/backends/backend_agg.py in draw(self)
    462 
    463         try:
--> 464             self.figure.draw(self.renderer)
    465         finally:
    466             RendererAgg.lock.release()

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/artist.py in draw_wrapper(artist, renderer, *args, **kwargs)
     61     def draw_wrapper(artist, renderer, *args, **kwargs):
     62         before(artist, renderer)
---> 63         draw(artist, renderer, *args, **kwargs)
     64         after(artist, renderer)
     65 

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/figure.py in draw(self, renderer)
   1142 
   1143             mimage._draw_list_compositing_images(
-> 1144                 renderer, self, dsu, self.suppressComposite)
   1145 
   1146             renderer.close_group('figure')

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/image.py in _draw_list_compositing_images(renderer, parent, dsu, suppress_composite)
    137     if not_composite or not has_images:
    138         for zorder, a in dsu:
--> 139             a.draw(renderer)
    140     else:
    141         # Composite any adjacent images together

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/artist.py in draw_wrapper(artist, renderer, *args, **kwargs)
     61     def draw_wrapper(artist, renderer, *args, **kwargs):
     62         before(artist, renderer)
---> 63         draw(artist, renderer, *args, **kwargs)
     64         after(artist, renderer)
     65 

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/axes/_base.py in draw(self, renderer, inframe)
   2424             renderer.stop_rasterizing()
   2425 
-> 2426         mimage._draw_list_compositing_images(renderer, self, dsu)
   2427 
   2428         renderer.close_group('axes')

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/image.py in _draw_list_compositing_images(renderer, parent, dsu, suppress_composite)
    137     if not_composite or not has_images:
    138         for zorder, a in dsu:
--> 139             a.draw(renderer)
    140     else:
    141         # Composite any adjacent images together

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/artist.py in draw_wrapper(artist, renderer, *args, **kwargs)
     61     def draw_wrapper(artist, renderer, *args, **kwargs):
     62         before(artist, renderer)
---> 63         draw(artist, renderer, *args, **kwargs)
     64         after(artist, renderer)
     65 

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/axis.py in draw(self, renderer, *args, **kwargs)
   1134         renderer.open_group(__name__)
   1135 
-> 1136         ticks_to_draw = self._update_ticks(renderer)
   1137         ticklabelBoxes, ticklabelBoxes2 = self._get_tick_bboxes(ticks_to_draw,
   1138                                                                 renderer)

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/axis.py in _update_ticks(self, renderer)
   1058             if not mtransforms.interval_contains(interval_expanded, loc):
   1059                 continue
-> 1060             tick.update_position(loc)
   1061             tick.set_label1(label)
   1062             tick.set_label2(label)

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/axis.py in update_position(self, loc)
    479 
    480         self._loc = loc
--> 481         self.stale = True
    482 
    483     def get_view_interval(self):

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/artist.py in stale(self, val)
    277 
    278         if val and self.stale_callback is not None:
--> 279             self.stale_callback(self, val)
    280 
    281     def get_window_extent(self, renderer):

~/anaconda/envs/learning_pytorch/lib/python3.5/site-packages/matplotlib/artist.py in _stale_axes_callback(self, val)
     72 
     73 
---> 74 def _stale_axes_callback(self, val):
     75     if self.axes:
     76         self.axes.stale = val

KeyboardInterrupt: 

In [ ]: