google-deepmind/streetlearn google-deepmind/streetlearn

  • Stars
    star
    279
  • Rank 142,874 (Top 3 %)
  • Language
    C++
  • License
    Apache License 2.0
  • Created over 5 years ago
  • Updated almost 4 years ago
Twitter logo Share LinkedIn logo Share Facebook logo Share
google-deepmind/streetlearn
github

google-deepmind

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

A C++/Python implementation of the StreetLearn environment based on images from Street View, as well as a TensorFlow implementation of goal-driven navigation agents solving the task published in “Learning to Navigate in Cities Without a Map”, NeurIPS 2018

StreetLearn

Overview

This repository contains an implementation of the StreetLearn C++ engine and Python environment for training navigation agents in real-world photographic street environments, as well as code for implementing the agents used in [1] "Learning to Navigate in Cities Without a Map" (NeurIPS 2018). This environment was also used in two follow-up papers: [2] "Cross-View Policy Learning for Street Navigation" (ICCV 2019) and [3] "Learning to follow directions in Street View" (AAAI 2020), as well as in technical report [4] "The StreetLearn Environment and Dataset". The StreetLearn environment relies on panorama images from Google Street View and provides an interface for moving a first-person view agent inside the Street View graph. This is not an officially supported Google product. Please cite papers [1] and [4] if you use the code from this repository in your work.

Our papers [1], [2] and [3] also provide a detailed description of how to train and implement navigation agents in the StreetLearn environment by using a TensorFlow implementation of "Importance Weighted Actor-Learner Architectures", published in Espeholt, Soyer, Munos et al. (2018) "IMPALA: Scalable Distributed Deep-RL with Importance Weighted Actor-Learner Architectures"). The generic agent and trainer code have been published by Lasse Espeholt under an Apache license at: https://github.com/deepmind/scalable_agent.

Bibtex

@inproceedings{mirowski2018learning,
  title={Learning to Navigate in Cities Without a Map},
  author={Mirowski, Piotr and Grimes, Matthew Koichi and Malinowski, Mateusz and Hermann, Karl Moritz and Anderson, Keith and Teplyashin, Denis and Simonyan, Karen and Kavukcuoglu, Koray and Zisserman, Andrew and Hadsell, Raia},
  booktitle={Neural Information Processing Systems (NeurIPS)},
  year={2018}
}

@article{mirowski2019streetlearn,
  title={The StreetLearn Environment and Dataset},
  author={Mirowski, Piotr and Banki-Horvath, Andras and Anderson, Keith and Teplyashin, Denis and Hermann, Karl Moritz and Malinowski, Mateusz and Grimes, Matthew Koichi and Simonyan, Karen and Kavukcuoglu, Koray and Zisserman, Andrew and others},
  journal={arXiv preprint arXiv:1903.01292},
  year={2019}
}

Code structure

This environment code contains:

  • streetlearn/engine Our C++ StreetLearn engine for loading, caching and serving Google Street View panoramas by projecting them from a equirectangular representation to first-person projected view at a given yaw, pitch and field of view, and for handling navigation (moving from one panorama to another) depending on the city street graph and the current orientation.
  • streetlearn/proto The message protocol buffer used to store panoramas and street graph.
  • streetlearn/python/environment A Python-based interface for calling the StreetLearn environment with custom action spaces. Within the Python StreetLearn interface, several games are defined in individual files whose names end with game.py. A second interface, called BatchedStreetLearn, can be used to instantiate multiple StreetLearn environments that share the same action specs, observation specs, and panorama cache, and return observations in batched format.
  • streetlearn/python/ui A simple interactive human_agent and an oracle_agent and instruction_following_oracle_agent for courier and instruction-following tasks respectively; all agents are implemented in Python using pygame and instantiate the StreetLearn environment on the requested map, along with a simple user interface. The interactive human_agent enables a user to play various games. The oracle_agent and instruction_following_oracle_agent are similar to the human agent and automatically navigate towards the goal (courier game) or towards the goal via waypoints, following instructions (instruction-following game) and they report oracle performance on these tasks. A batched version of th oracle agent can be started using batched_oracle_agent.

Compilation from source

Bazel is the official build system for StreetLearn. The build has only been tested running on Ubuntu 18.04.

Install build prerequisites

sudo apt-get install autoconf automake libtool curl make g++ unzip virtualenv python-virtualenv cmake subversion pkg-config libpython-dev libcairo2-dev libboost-all-dev python-pip libssl-dev
pip install setuptools
pip install pyparsing

Install Protocol Buffers

For detailed information see: https://github.com/protocolbuffers/protobuf/blob/master/src/README.md

git clone https://github.com/protocolbuffers/protobuf.git
cd protobuf
git submodule update --init --recursive
./autogen.sh
./configure
make -j7
sudo make install
sudo ldconfig
cd python
python setup.py build
sudo python setup.py install
cd ../..

Install CLIF

git clone https://github.com/google/clif.git
cd clif
./INSTALL.sh
cd ..

Install OpenCV 2.4.13

wget https://github.com/opencv/opencv/archive/2.4.13.6.zip
unzip 2.4.13.6.zip
cd opencv-2.4.13.6
mkdir build
cd build
cmake -D CMAKE_BUILD_TYPE=Release -D CMAKE_INSTALL_PREFIX=/usr/local ..
make -j7
sudo make install
sudo ldconfig
cd ../..

Install Python dependencies

pip install six
pip install absl-py
pip install inflection
pip install wrapt
pip install numpy
pip install dm-sonnet
pip install tensorflow-gpu
pip install pygame

Install Bazel

This page describes how to install the Bazel build and test tool on your machine. We currently support Bazel versions up to 0.24.0, whose installation instructions are listed on this page under section Using the binary installer (copy-pasted below):

wget https://github.com/bazelbuild/bazel/releases/download/0.24.0/bazel-0.24.0-installer-linux-x86_64.sh
chmod +x bazel-0.24.0-installer-linux-x86_64.sh
./bazel-0.24.0-installer-linux-x86_64.sh  --user
export PATH="$PATH:$HOME/bin"

Building StreetLearn

Clone this repository and install Scalable Agent:

git clone https://github.com/deepmind/streetlearn.git
cd streetlearn
sh get_scalable_agent.sh

To build the StreetLearn engine only:

export CLIF_PATH=$HOME/opt
bazel build streetlearn:streetlearn_engine_py

To build the human agent and the oracle agent in the StreetLearn environment, with all the dependencies:

export CLIF_PATH=$HOME/opt
bazel build streetlearn/python/ui:all

Running the StreetLearn human agent

To run the human agent using one of the StreetLearn datasets downloaded and stored at dataset_path (note that dataset_path needs to be absolute, not relative):

bazel run streetlearn/python/ui:human_agent -- --dataset_path=<dataset_path>

For help with the options of the human_agent:

bazel run streetlearn/python/ui:human_agent -- --help

Similarly, to run the oracle agent on the courier game:

bazel run streetlearn/python/ui:oracle_agent -- --dataset_path=<dataset_path>

The human agent and the oracle agent show a view_image (on top) and a graph_image (on bottom).

Note: you need to add the following line to your .bashrc script to avoid specifying the CLIF path each time you open a new terminal:

export CLIF_PATH=$HOME/opt

Actions available to an agent:

  • Rotate left or right in the panorama, by a specified angle (change the yaw of the agent). In the human_agent, press a or d.
  • Rotate up or down in the panorama, by a specified angle (change the pitch of the agent). In the human_agent, press w or s.
  • Move from current panorama A forward to another panorama B if the current bearing of the agent from A to B is within a tolerance angle of 30 degrees. In the human_agent, press space.
  • Zoom in and out in the panorama. In the human_agent, press i or o.

Additional keys for the human_agent are escape and p (to print the current view as a bitmap image).

For training RL agents, action spaces are discretized using integers. For instance, in our paper, we used 5 actions: (move forward, turn left by 22.5 deg, turn left by 67.5 deg, turn right by 22.5 deg, turn right by 67.5 deg).

Navigation Bar

Along the bottom of the view_image is the navigation bar which displays a small circle in any direction in which travel is possible:

  • When within the centre range, they will turn green meaning the user can move in this direction.
  • When they are out of this range, they will turn red meaning this is inaccessible.
  • When more than one dots are within the centre range, all except the most central will turn orange, meaning that there are multiple (forward) directions available.

Stop signs

The graph is constructed by breadth first search to the depth specified by the graph depth flags. At the maximum depth the graph will suddenly stop, generally in the middle of a street. Because we are trying to train agents to recognize streets as navigable, and in order not to confuse the agents, red stop signs are shown from two panoramas away from any terminal node in the graph.

Obtaining the StreetLearn dataset

You can request the StreetLearn dataset on the StreetLearn project website. The following datasets are currently distributed:

The downsampled version of the panoramas can be used when the RGB inputs are small (e.g., 84 x 84), to save on panorama image loading and projection time.

Using the StreetLearn environment code

The Python StreetLearn environment follows the specifications from OpenAI Gym. The call to function step(action) returns:

  • observation (tuple of observations requested at construction),
  • reward (a float with the current reward of the agent),
  • done (boolean indicating whether the episode has ended)
  • and info (a dictionary of environment state variables). After creating the environment, it is initialised by calling function reset(). If the flag auto_reset is set to True at construction, reset() will be called automatically every time that an episode ends.

Environment Settings

Default environment settings are stored in streetlearn/python/default_config.py.

  • seed: Random seed.
  • width: Width of the streetview image.
  • height: Height of the streetview image.
  • graph_width: Width of the map graph image.
  • graph_height: Height of the map graph image.
  • status_height: Status bar height in pixels.
  • field_of_view: Horizontal field of view, in degrees.
  • min_graph_depth: Min bound on BFS depth for panos.
  • max_graph_depth: Max bound on BFS depth for panos.
  • max_cache_size: Pano cache size.
  • bbox_lat_min: Minimum value for normalizing the target latitude.
  • bbox_lat_max: Maximum value for normalizing the target latitude.
  • bbox_lng_min: Minimum value for normalizing the target longitude.
  • bbox_lng_max: Maximum value for normalizing the target longitude.
  • min_radius_meters: Minimum distance from goal at which reward shaping starts in the courier game.
  • max_radius_meters: Maximum distance from goal at which reward shaping starts in the courier game.
  • timestamp_start_curriculum: Integer timestamp (UNIX time) when curriculum learning starts, used in the curriculum courier game.
  • hours_curriculum_part_1: Number of hours for the first part of curriculum training (goal location within minimum distance), used in the curriculum courier game.
  • hours_curriculum_part_2: Number of hours for the second part of curriculum training (goal location annealed further away), used in the curriculum courier game.
  • min_goal_distance_curriculum: Distance in meters of the goal location at the beginning of curriculum learning, used in the curriculum courier game.
  • max_goal_distance_curriculum: Distance in meters of the goal location at the beginning of curriculum learning, used in the curriculum courier game.
  • instruction_curriculum_type: Type of curriculum learning, used in the instruction following games.
  • frame_cap: Episode frame cap.
  • full_graph: Boolean indicating whether to build the entire graph upon episode start.
  • sample_graph_depth: Boolean indicating whether to sample graph depth between min_graph_depth and max_graph_depth.
  • start_pano: The pano ID string to start from. The graph will be build out from this point.
  • graph_zoom: Initial graph zoom. Valid between 1 and 32.
  • graph_black_on_white: Show the graph as black on white. Default value: false (shows the graph as white on black).
  • show_shortest_path: Boolean indicator asking whether the shortest path to the goal shall be shown on the graph.
  • calculate_ground_truth: Boolean indicator asking whether the ground truth direction to the goal should be calculated during the game (useful for oracle agents, visualisation and for imitation learning).
  • neighbor_resolution: Used to calculate a binary occupancy vector of neighbors to the current pano.
  • color_for_touched_pano: RGB color for the panos touched by the agent.
  • color_for_observer: RGB color for the observer.
  • color_for_coin: RGB color for the panos containing coins.
  • color_for_goal: RGB color for the goal pano.
  • color_for_shortest_path: RGB color for panos on the shortest path to the goal.
  • color_for_waypoint: RGB color for a waypoint pano.
  • observations: Array containing one or more names of the observations requested from the environment: ['view_image', 'graph_image', 'yaw', 'pitch', 'metadata', 'target_metadata', 'latlng', 'target_latlng', 'latlng_label', 'target_latlng_label', 'yaw_label', 'neighbors', 'thumbnails', 'instructions', 'ground_truth_direction']
  • reward_per_coin: Coin reward for coin game.
  • reward_at_waypoint: Waypoint reward for the instruction-following games.
  • reward_at_goal: Goal reward for the instruction-following games.
  • proportion_of_panos_with_coins: The proportion of panos with coins.
  • game_name: Game name, can be: 'coin_game', 'exploration_game', 'courier_game', 'curriculum_courier_game', 'goal_instruction_game', 'incremental_instruction_game' and 'step_by_step_instruction_game'.
  • action_spec: Either of 'streetlearn_default', 'streetlearn_fast_rotate', 'streetlearn_tilt'
  • rotation_speed: Rotation speed in degrees. Used to create the action spec.
  • auto_reset: Boolean indicator whether games are reset automatically when the max number of frames is achieved.

Observations

The following observations can be returned by the agent:

  • view_image: RGB image for the first-person view image returned from the environment and seen by the agent,
  • graph_image: RGB image for the top-down street graph image, usually not seen by the agent,
  • yaw: Scalar value of the yaw angle of the agent, in degrees (zero corresponds to North),
  • pitch: Scalar value of the pitch angle of the agent, in degrees (zero corresponds to horizontal),
  • metadata: Message protocol buffer of type Pano with the metadata of the current panorama,
  • target_metadata: Message protocol buffer of type Pano with the metadata of the target/goal panorama,
  • latlng: Tuple of lat/lng scalar values for the current position of the agent,
  • target_latlng: Tuple of lat/lng scalar values for the target/goal position,
  • latlng_label: Integer discretized value of the current agent position using 1024 bins (32 bins for latitude and 32 bins for longitude),
  • target_latlng_label: Integer discretized value of the target position using 1024 bins (32 bins for latitude and 32 bins for longitude),
  • yaw_label: Integer discretized value of the agent yaw using 16 bins,
  • neighbors: Vector of immediate neighbor egocentric traversability grid around the agent, with 16 bins for the directions around the agent and bin 0 corresponding to the traversability straight ahead of the agent.
  • thumbnails: Array of n+1 RGB images for the first-person view image returned from the environment, that should be seen by the agent at specific waypoints and goal locations when playing the instruction-following game with n instructions,
  • instructions: List of n string instructions for the agent at specific waypoints and goal locations when playing the instruction-following game with n instructions,
  • ground_truth_direction: Scalar value of the relative ground truth direction to be taken by the agent in order to follow a shortest path to the next goal or waypoint. This observation should be requested only for agents trained using imitation learning.

Games

The following games are available in the StreetLearn environment:

  • coin_game: invisible coins scattered throughout the map, yielding a reward of 1 for each. Once picked up, these rewards do not reappear until the end of the episode.
  • courier_game: the agent is given a goal destination, specified as lat/long pairs. Once the goal is reached (with 100m tolerance), a new goal is sampled, until the end of the episode. Rewards at a goal are proportional to the number of panoramas on the shortest path from the agent's position when it gets the new goal assignment to that goal position. Additional reward shaping consists in early rewards when the agent gets within a range of 200m of the goal. Additional coins can also be scattered throughout the environment. The proportion of coins, the goal radius and the early reward radius are parametrizable.
  • curriculum_courier_game: same as the courier game, but with a curriculum on the difficulty of the task (maximum straight-line distance from the agent's position to the goal when it is assigned).
  • goal_instruction_game and its variations incremental_instruction_game and step_by_step_instruction_game use navigation instructions to direct agents to a goal. Agents are provided with a list of instructions as well as thumbnails that guide the agent from its starting position to the goal location. In step_by_step_instruction_game, agents are provided one instruction and two thumbnails at a time, in the other game variants the whole list is available throughout the whole game. Reward is granted upon reaching the goal location (all variants), as well as when hitting individual waypoints (incremental_instruction_game and step_by_step_instruction_game only). During training various curriculum strategies are available to the agents, and reward shaping can be employed to provide fractional rewards when the agent gets within a range of 50m of a waypoint or goal.

License

The Abseil C++ library is licensed under the terms of the Apache license. See LICENSE for more information.

Disclaimer

This is not an official Google product.

More Repositories

1

deepmind-research

This repository contains implementations and illustrative code to accompany DeepMind publications
Jupyter Notebook
12,817
star
2

alphafold

Open source code for AlphaFold.
Python
11,700
star
3

sonnet

TensorFlow-based neural network library
Python
9,691
star
4

pysc2

StarCraft II Learning Environment
Python
7,904
star
5

mujoco

Multi-Joint dynamics with Contact. A general purpose physics simulator.
Jupyter Notebook
7,202
star
6

lab

A customisable 3D platform for agent-based AI research
C
7,012
star
7

graph_nets

Build Graph Nets in Tensorflow
Python
5,325
star
8

graphcast

Python
4,242
star
9

learning-to-learn

Learning to Learn in TensorFlow
Python
4,063
star
10

open_spiel

OpenSpiel is a collection of environments and algorithms for research in general reinforcement learning and search/planning in games.
C++
4,019
star
11

alphageometry

Python
3,580
star
12

dm_control

Google DeepMind's software stack for physics-based simulation and Reinforcement Learning environments, using MuJoCo.
Python
3,473
star
13

acme

A library of reinforcement learning components and agents
Python
3,372
star
14

trfl

TensorFlow Reinforcement Learning
Python
3,139
star
15

dm-haiku

JAX-based neural network library
Python
2,697
star
16

alphatensor

Python
2,616
star
17

dnc

A TensorFlow implementation of the Differentiable Neural Computer.
Python
2,478
star
18

mctx

Monte Carlo tree search in JAX
Python
2,209
star
19

gemma

Open weights LLM from Google DeepMind.
Jupyter Notebook
2,061
star
20

code_contests

C++
2,010
star
21

kinetics-i3d

Convolutional neural network model for video classification trained on the Kinetics dataset.
Python
1,639
star
22

mathematics_dataset

This dataset code generates mathematical question and answer pairs, from a range of question types at roughly school-level difficulty.
Python
1,621
star
23

optax

Optax is a gradient processing and optimization library for JAX.
Python
1,492
star
24

bsuite

bsuite is a collection of carefully-designed experiments that investigate core capabilities of a reinforcement learning (RL) agent
Python
1,465
star
25

penzai

A JAX research toolkit for building, editing, and visualizing neural networks.
Python
1,405
star
26

educational

Jupyter Notebook
1,382
star
27

jraph

A Graph Neural Network Library in Jax
Python
1,306
star
28

rc-data

Question answering dataset featured in "Teaching Machines to Read and Comprehend
Python
1,285
star
29

rlax

Python
1,185
star
30

tapnet

Tracking Any Point (TAP)
Python
1,033
star
31

scalable_agent

A TensorFlow implementation of Scalable Distributed Deep-RL with Importance Weighted Actor-Learner Architectures.
Python
972
star
32

neural-processes

This repository contains notebook implementations of the following Neural Process variants: Conditional Neural Processes (CNPs), Neural Processes (NPs), Attentive Neural Processes (ANPs).
Jupyter Notebook
966
star
33

android_env

RL research on Android devices.
Python
946
star
34

mujoco_menagerie

A collection of high-quality models for the MuJoCo physics engine, curated by Google DeepMind.
Jupyter Notebook
926
star
35

dramatron

Dramatron uses large language models to generate coherent scripts and screenplays.
Jupyter Notebook
904
star
36

tree

tree is a library for working with nested data structures
Python
891
star
37

xmanager

A platform for managing machine learning experiments
Python
794
star
38

mujoco_mpc

Real-time behaviour synthesis with MuJoCo, using Predictive Control
C++
771
star
39

materials_discovery

Python
770
star
40

chex

Python
716
star
41

reverb

Reverb is an efficient and easy-to-use data storage and transport system designed for machine learning research
C++
692
star
42

alphadev

Python
662
star
43

pycolab

A highly-customisable gridworld game engine with some batteries included. Make your own gridworld games to test reinforcement learning agents!
Python
654
star
44

ferminet

An implementation of the Fermionic Neural Network for ab-initio electronic structure calculations
Python
643
star
45

hanabi-learning-environment

hanabi_learning_environment is a research platform for Hanabi experiments.
Python
614
star
46

funsearch

Jupyter Notebook
611
star
47

ai-safety-gridworlds

This is a suite of reinforcement learning environments illustrating various safety properties of intelligent agents.
Python
577
star
48

dqn

Lua/Torch implementation of DQN (Nature, 2015)
Lua
546
star
49

ithaca

Restoring and attributing ancient texts using deep neural networks
Jupyter Notebook
540
star
50

meltingpot

A suite of test scenarios for multi-agent reinforcement learning.
Python
516
star
51

distrax

Python
509
star
52

recurrentgemma

Open weights language model from Google DeepMind, based on Griffin.
Python
505
star
53

surface-distance

Library to compute surface distance based performance metrics for segmentation tasks.
Python
493
star
54

tracr

Python
467
star
55

dsprites-dataset

Dataset to assess the disentanglement properties of unsupervised learning methods
Jupyter Notebook
463
star
56

alphamissense

Python
455
star
57

narrativeqa

This repository contains the NarrativeQA dataset. It includes the list of documents with Wikipedia summaries, links to full stories, and questions and answers.
Shell
432
star
58

lab2d

A customisable 2D platform for agent-based AI research
C++
415
star
59

open_x_embodiment

Jupyter Notebook
409
star
60

dqn_zoo

DQN Zoo is a collection of reference implementations of reinforcement learning agents developed at DeepMind based on the Deep Q-Network (DQN) agent.
Python
406
star
61

clrs

Python
376
star
62

spriteworld

Spriteworld: a flexible, configurable python-based reinforcement learning environment
Python
366
star
63

dm_pix

PIX is an image processing library in JAX, for JAX.
Python
363
star
64

concordia

A library for generative social simulation
Python
351
star
65

mathematics_conjectures

Jupyter Notebook
348
star
66

alphastar

Python
346
star
67

spiral

We provide a pre-trained model for unconditional 19-step generation of CelebA-HQ images
C++
327
star
68

dm_env

A Python interface for reinforcement learning environments
Python
326
star
69

dm_robotics

Libraries, tools and tasks created and used at DeepMind Robotics.
Python
315
star
70

uncertain_ground_truth

Dermatology ddx dataset, Jax implementations of Monte Carlo conformal prediction, plausibility regions and statistical annotation aggregation from our recent work on uncertain ground truth (TMLR'23 and ArXiv pre-print).
Python
315
star
71

long-form-factuality

Benchmarking long-form factuality in large language models. Original code for our paper "Long-form factuality in large language models".
Python
314
star
72

launchpad

Python
305
star
73

leo

Implementation of Meta-Learning with Latent Embedding Optimization
Python
302
star
74

gqn-datasets

Datasets used to train Generative Query Networks (GQNs) in the ‘Neural Scene Representation and Rendering’ paper.
Python
269
star
75

enn

Python
265
star
76

multi_object_datasets

Multi-object image datasets with ground-truth segmentation masks and generative factors.
Python
247
star
77

AQuA

A algebraic word problem dataset, with multiple choice questions annotated with rationales.
238
star
78

card2code

A code generation dataset for generating the code that implements Hearthstone and Magic The Gathering card effects.
236
star
79

grid-cells

Implementation of the supervised learning experiments in Vector-based navigation using grid-like representations in artificial agents, as published at https://www.nature.com/articles/s41586-018-0102-6
Python
236
star
80

arnheim

Jupyter Notebook
235
star
81

synjax

Python
233
star
82

torch-hdf5

Torch interface to HDF5 library
Lua
231
star
83

dm_memorytasks

A set of 13 diverse machine-learning tasks that require memory to solve.
Python
220
star
84

Temporal-3D-Pose-Kinetics

Exploiting temporal context for 3D human pose estimation in the wild: 3D poses for the Kinetics dataset
Python
214
star
85

opro

official code for "Large Language Models as Optimizers"
Python
199
star
86

dm_alchemy

DeepMind Alchemy task environment: a meta-reinforcement learning benchmark
Python
197
star
87

neural_testbed

Jupyter Notebook
187
star
88

kfac-jax

Second Order Optimization and Curvature Estimation with K-FAC in JAX.
Python
187
star
89

pg19

179
star
90

xquad

173
star
91

jmp

JMP is a Mixed Precision library for JAX.
Python
171
star
92

spectral_inference_networks

Implementation of Spectral Inference Networks, ICLR 2019
Python
165
star
93

abstract-reasoning-matrices

Progressive matrices dataset, as described in: Measuring abstract reasoning in neural networks (Barrett*, Hill*, Santoro*, Morcos, Lillicrap), ICML2018
162
star
94

xitari

This is the 0.4 release of the Arcade Learning Environment (ALE), a platform designed for AI research. ALE is based on Stella, an Atari 2600 VCS emulator.
C++
159
star
95

tensor_annotations

Annotating tensor shapes using Python types
Python
158
star
96

neural_networks_chomsky_hierarchy

Neural Networks and the Chomsky Hierarchy
Python
155
star
97

symplectic-gradient-adjustment

A colab that implements the Symplectic Gradient Adjustment optimizer from "The mechanics of n-player differentiable games"
Jupyter Notebook
150
star
98

mc_gradients

Jupyter Notebook
149
star
99

interval-bound-propagation

This repository contains a simple implementation of Interval Bound Propagation (IBP) using TensorFlow: https://arxiv.org/abs/1810.12715
Python
148
star
100

s6

C++
146
star