mirror of
https://github.com/google-deepmind/deepmind-research.git
synced 2026-10-07 14:52:59 +08:00
111 lines
4.0 KiB
Python
111 lines
4.0 KiB
Python
# Copyright 2021 DeepMind Technologies Limited
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# https://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
"""Utilities to compute human-normalized Atari scores.
|
|
|
|
The data used in this module is human and random performance data on Atari-57.
|
|
It comprises of evaluation scores (undiscounted returns), each averaged
|
|
over at least 3 episode runs, on each of the 57 Atari games. Each episode begins
|
|
with the environment already stepped with a uniform random number (between 1 and
|
|
30 inclusive) of noop actions.
|
|
|
|
The two agents are:
|
|
* 'random' (agent choosing its actions uniformly randomly on each step)
|
|
* 'human' (professional human game tester)
|
|
|
|
Scores are obtained by averaging returns over the episodes played by each agent,
|
|
with episode length capped to 108,000 frames (i.e. timeout after 30 minutes).
|
|
|
|
The term 'human-normalized' here means a linear per-game transformation of
|
|
a game score in such a way that 0 corresponds to random performance and 1
|
|
corresponds to human performance.
|
|
"""
|
|
|
|
import math
|
|
|
|
# Game: score-tuple dictionary. Each score tuple contains
|
|
# 0: score random (float) and 1: score human (float).
|
|
_ATARI_DATA = {
|
|
'alien': (227.8, 7127.7),
|
|
'amidar': (5.8, 1719.5),
|
|
'assault': (222.4, 742.0),
|
|
'asterix': (210.0, 8503.3),
|
|
'asteroids': (719.1, 47388.7),
|
|
'atlantis': (12850.0, 29028.1),
|
|
'bank_heist': (14.2, 753.1),
|
|
'battle_zone': (2360.0, 37187.5),
|
|
'beam_rider': (363.9, 16926.5),
|
|
'berzerk': (123.7, 2630.4),
|
|
'bowling': (23.1, 160.7),
|
|
'boxing': (0.1, 12.1),
|
|
'breakout': (1.7, 30.5),
|
|
'centipede': (2090.9, 12017.0),
|
|
'chopper_command': (811.0, 7387.8),
|
|
'crazy_climber': (10780.5, 35829.4),
|
|
'defender': (2874.5, 18688.9),
|
|
'demon_attack': (152.1, 1971.0),
|
|
'double_dunk': (-18.6, -16.4),
|
|
'enduro': (0.0, 860.5),
|
|
'fishing_derby': (-91.7, -38.7),
|
|
'freeway': (0.0, 29.6),
|
|
'frostbite': (65.2, 4334.7),
|
|
'gopher': (257.6, 2412.5),
|
|
'gravitar': (173.0, 3351.4),
|
|
'hero': (1027.0, 30826.4),
|
|
'ice_hockey': (-11.2, 0.9),
|
|
'jamesbond': (29.0, 302.8),
|
|
'kangaroo': (52.0, 3035.0),
|
|
'krull': (1598.0, 2665.5),
|
|
'kung_fu_master': (258.5, 22736.3),
|
|
'montezuma_revenge': (0.0, 4753.3),
|
|
'ms_pacman': (307.3, 6951.6),
|
|
'name_this_game': (2292.3, 8049.0),
|
|
'phoenix': (761.4, 7242.6),
|
|
'pitfall': (-229.4, 6463.7),
|
|
'pong': (-20.7, 14.6),
|
|
'private_eye': (24.9, 69571.3),
|
|
'qbert': (163.9, 13455.0),
|
|
'riverraid': (1338.5, 17118.0),
|
|
'road_runner': (11.5, 7845.0),
|
|
'robotank': (2.2, 11.9),
|
|
'seaquest': (68.4, 42054.7),
|
|
'skiing': (-17098.1, -4336.9),
|
|
'solaris': (1236.3, 12326.7),
|
|
'space_invaders': (148.0, 1668.7),
|
|
'star_gunner': (664.0, 10250.0),
|
|
'surround': (-10.0, 6.5),
|
|
'tennis': (-23.8, -8.3),
|
|
'time_pilot': (3568.0, 5229.2),
|
|
'tutankham': (11.4, 167.6),
|
|
'up_n_down': (533.4, 11693.2),
|
|
'venture': (0.0, 1187.5),
|
|
# Note the random agent score on Video Pinball is sometimes greater than the
|
|
# human score under other evaluation methods.
|
|
'video_pinball': (16256.9, 17667.9),
|
|
'wizard_of_wor': (563.5, 4756.5),
|
|
'yars_revenge': (3092.9, 54576.9),
|
|
'zaxxon': (32.5, 9173.3),
|
|
}
|
|
|
|
_RANDOM_COL = 0
|
|
_HUMAN_COL = 1
|
|
|
|
ATARI_GAMES = tuple(sorted(_ATARI_DATA.keys()))
|
|
|
|
|
|
def get_human_normalized_score(game: str, raw_score: float) -> float:
|
|
"""Converts game score to human-normalized score."""
|
|
game_scores = _ATARI_DATA.get(game, (math.nan, math.nan))
|
|
random, human = game_scores[_RANDOM_COL], game_scores[_HUMAN_COL]
|
|
return (raw_score - random) / (human - random)
|