def reset(self):
print('start to reset env')
self.image_i_ = 0
self.image_dir_ = None
self.render_ = False
self.reward_time = 0
self.prev_measurements = None
self.prev_action = {'steer': 0.0, 'acc': 0.0, 'brake': 0.0}
settings = CarlaSettings()
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=20,
NumberOfPedestrians=40,
WeatherId=random.choice([1, 3, 7, 8, 14]),
QualityLevel='Epic')
settings.randomize_seeds()
camera = Camera('CameraRGB')
camera.set(FOV=100)
camera.set_image_size(800, 600)
camera.set_position(2.0, 0.0, 1.4)
camera.set_rotation(-15.0, 0, 0)
settings.add_sensor(camera)
observation = None
scene = self.client.load_settings(settings)
number_of_player_starts = len(scene.player_start_spots)
player_start = random.randint(0, max(0, number_of_player_starts - 1))
self.client.start_episode(player_start)
for i in range(20):
action = {'steer': 0.0, 'acc': 0.0, 'brake': 0.0}
observation, _, _, _ = self.step(action)
time.sleep(0.1)
self.reward_time = 0
print('reset finished')
return observation
def __init__(self, port, gpu_num=0, host='localhost', frame_skip=1, cam_width=800, cam_height=600, town_string='Town01', obs_size=84):
super(StraightDriveEnv, self).__init__()
self.c = CarlaServer(port, gpu_num=gpu_num)
self.port = port
while True:
try:
self.client = CarlaClient(host, port)
self.client.connect()
break
except TCPConnectionError as error:
print(error)
time.sleep(1)
self.frame_skip = frame_skip
self._planner = Planner(town_string)
camera0 = Camera('CameraRGB')
camera0.set(CameraFOV=100)
camera0.set_image_size(cam_height, cam_width)
camera0.set_position(200, 0, 140)
camera0.set_rotation(-15.0, 0, 0)
self.start_goal_pairs = [[36, 40], [39, 35], [110, 114], [7, 3], [0, 4],
[68, 50], [61, 59], [47, 64], [147, 90], [33, 87],
[26, 19], [80, 76], [45, 49], [55, 44], [29, 107],
[95, 104], [84, 34], [53, 67], [22, 17], [91, 148],
[20, 107], [78, 70], [95, 102], [68, 44], [45, 69]]
vehicles = 0
pedestrians = 0
weather = 1
settings = CarlaSettings()
settings.set(
SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather,
)
settings.randomize_seeds()
settings.add_sensor(camera0)
self.scene = self.client.load_settings(settings)
img_shape = (obs_size, obs_size, 3)
self.observation_space = spaces.Tuple(
(spaces.Box(0, 255, img_shape),
spaces.Box(-np.inf, np.inf, (8,))
)
)
self.action_space = spaces.Box(-1, 1, shape=(3,))
self.prev_state = np.array([0., 0., 0.])
self.prev_collisions = np.array([0., 0., 0.])
self.prev_intersections = np.array([0., 0.])
def run_driving_benchmark(agent,
experiment_suite,
city_name='Town01',
log_name='Test',
continue_experiment=False,
host='127.0.0.1',
port=2000):
while True:
try:
with make_carla_client(host, port) as client:
# Hack to fix for the issue 310, we force a reset, so it does not get
# the positions on first server reset.
client.load_settings(CarlaSettings())
client.start_episode(0)
# We instantiate the driving benchmark, that is the engine used to
# benchmark an agent. The instantiation starts the log process, sets
benchmark = DrivingBenchmark(
city_name=city_name,
name_to_save=log_name + '_' +
type(experiment_suite).__name__ + '_' + city_name,
continue_experiment=continue_experiment)
# This function performs the benchmark. It returns a dictionary summarizing
# the entire execution.
benchmark_summary = benchmark.benchmark_agent(
experiment_suite, agent, client)
print("")
print("")
print(
"----- Printing results for training weathers (Seen in Training) -----"
)
print("")
print("")
results_printer.print_summary(benchmark_summary,
experiment_suite.train_weathers,
benchmark.get_path())
print("")
print("")
print(
"----- Printing results for test weathers (Unseen in Training) -----"
)
print("")
print("")
results_printer.print_summary(benchmark_summary,
experiment_suite.test_weathers,
benchmark.get_path())
break
except TCPConnectionError as error:
logging.error(error)
time.sleep(1)
def reset(self):
print("Start to reset env")
settings = CarlaSettings()
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=False,
NumberOfVehicles=0,
NumberOfPedestrians=0,
WeatherId=random.choice([1]),
QualityLevel='Epic')
settings.randomize_seeds()
camera = Camera('CameraRGB')
camera.set(FOV=100)
camera.set_image_size(160, 120)
camera.set_position(2.0, 0.0, 1.4)
camera.set_rotation(-15.0, 0, 0)
settings.add_sensor(camera)
observation = None
scene = self.client.load_settings(settings)
number_of_player_starts = len(scene.player_start_spots)
player_start = random.randint(0, max(0, number_of_player_starts - 1))
self.client.start_episode(player_start)
measurements, sensor_data = self.client.read_data()
im = sensor_data['CameraRGB'].data
im = np.array(im)
im = im[:, :, ::-1] # convert to BGR
observation = self.vae.encode_from_raw_image(im)
self.command_history = np.zeros(
(1, self.n_commands * self.n_command_history))
if self.n_command_history > 0:
observation = np.concatenate((observation, self.command_history),
axis=-1)
if self.n_stack > 1:
self.stacked_obs[...] = 0
self.stacked_obs[..., -observation.shape[-1]:] = observation
return self.stacked_obs
print('reset finished')
return observation
def build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depends on the selected Town.
"""
# We check the town, based on that we define the town related parameters
# The size of the vector is related to the number of tasks, inside each
# task there is also multiple poses ( start end, positions )
if self._city_name == 'Town01':
poses_tasks = [[[7, 3]], [[138, 17]], [[140, 134]], [[140, 134]]]
vehicles_tasks = [0, 0, 0, 20]
pedestrians_tasks = [0, 0, 0, 50]
else:
poses_tasks = [[[4, 2]], [[37, 76]], [[19, 66]], [[19, 66]]]
vehicles_tasks = [0, 0, 0, 15]
pedestrians_tasks = [0, 0, 0, 50]
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('CameraRGB')
camera.set(FOV=100)
camera.set_image_size(800, 600)
camera.set_position(2.0, 0.0, 1.4)
camera.set_rotation(-15.0, 0, 0)
# Based on the parameters, creates a vector with experiment objects.
experiments_vector = []
for weather in self.weathers:
for iteration in range(len(poses_tasks)):
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
conditions = CarlaSettings()
conditions.set(SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(Conditions=conditions,
Poses=poses,
Task=iteration,
Repetitions=1)
experiments_vector.append(experiment)
return experiments_vector
def build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depend on the selected Town.
"""
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('CameraRGB')
camera.set(FOV=100)
camera.set_image_size(800, 600)
camera.set_position(2.0, 0.0, 1.4)
camera.set_rotation(-15.0, 0, 0)
if self._city_name == 'Town01':
poses_tasks = self._poses_town01()
vehicles_tasks = [0, 0, 0, 20]
pedestrians_tasks = [0, 0, 0, 50]
else:
poses_tasks = self._poses_town02()
vehicles_tasks = [0, 0, 0, 15]
pedestrians_tasks = [0, 0, 0, 50]
experiments_vector = []
for weather in self.weathers:
for iteration in range(len(poses_tasks)):
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
conditions = CarlaSettings()
conditions.set(SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(Conditions=conditions,
Poses=poses,
Task=iteration,
Repetitions=1)
experiments_vector.append(experiment)
return experiments_vector
import time
import random
sess = tf.Session()
Image_agent = ImitationLearning(sess)
Vec_ = []
Image_agent.load_model()
global_episode = 0
while True:
try:
with make_carla_client('localhost', 2000) as client:
for episode in range(3):
if episode < global_episode:
continue
print(episode)
settings = CarlaSettings()
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=20,
NumberOfPedestrians=40,
WeatherId=random.choice([1, 3, 7, 8, 14]),
QualityLevel='Epic')
settings.randomize_seeds()
camera = Camera('CameraRGB')
camera.set(FOV=100)
camera.set_image_size(800, 600)
camera.set_position(2.0, 0.0, 1.4)
camera.set_rotation(-15.0, 0, 0)
settings.add_sensor(camera)
scene = client.load_settings(settings)
def run_carla_client(args):
# Here we will run 3 episodes with 300 frames each.
number_of_episodes = 10
frames_per_episode = 500
# We assume the CARLA server is already waiting for a client to connect at
# host:port. To create a connection we can use the `make_carla_client`
# context manager, it creates a CARLA client object and starts the
# connection. It will throw an exception if something goes wrong. The
# context manager makes sure the connection is always cleaned up on exit.
with make_carla_client(args.host, args.port) as client:
print('CarlaClient connected')
for episode in range(0, number_of_episodes):
# Start a new episode.
# Create a CarlaSettings object. This object is a wrapper around
# the CarlaSettings.ini file. Here we set the configuration we
# want for the new episode.
settings = CarlaSettings()
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=False,
NumberOfVehicles=0,
NumberOfPedestrians=0,
WeatherId=random.choice([1]),
QualityLevel=args.quality_level)
settings.randomize_seeds()
camera0 = Camera('CameraRGB')
camera0.set_image_size(160, 120)
camera0.set(FOV=100)
camera0.set_position(2.0, 0.0, 1.4)
camera0.set_rotation(-15.0, 0, 0)
settings.add_sensor(camera0)
# Now we load these settings into the server. The server replies
# with a scene description containing the available start spots for
# the player. Here we can provide a CarlaSettings object or a
# CarlaSettings.ini file as string.
scene = client.load_settings(settings)
# Choose one player start at random.
number_of_player_starts = len(scene.player_start_spots)
player_start = random.randint(0, max(0,
number_of_player_starts - 1))
# Notify the server that we want to start the episode at the
# player_start index. This function blocks until the server is ready
# to start the episode.
print('Starting new episode...')
client.start_episode(player_start)
# Iterate every frame in the episode.
for frame in range(0, frames_per_episode):
# Read the data produced by the server this frame.
measurements, sensor_data = client.read_data()
# Print some of the measurements.
print_measurements(measurements)
# Save the images to disk if requested.
if args.save_images_to_disk:
for name, measurement in sensor_data.items():
filename = args.out_filename_format.format(
episode, name, frame)
measurement.save_to_disk(filename)
# We can access the encoded data of a given image as numpy
# array using its "data" property. For instance, to get the
# depth value (normalized) at pixel X, Y
#
# depth_array = sensor_data['CameraDepth'].data
# value_at_pixel = depth_array[Y, X]
#
# Now we have to send the instructions to control the vehicle.
# If we are in synchronous mode the server will pause the
# simulation until we send this control.
if not args.autopilot:
client.send_control(steer=random.uniform(-1.0, 1.0),
throttle=0.5,
brake=0.0,
hand_brake=False,
reverse=False)
else:
# Together with the measurements, the server has sent the
# control that the in-game autopilot would do this frame. We
# can enable autopilot by sending back this control to the
# server. We can modify it if wanted, here for instance we
# will add some noise to the steer.
control = measurements.player_measurements.autopilot_control
# control.steer += random.uniform(-0.1, 0.1)
control.steer += random.uniform(-0.2, 0.2)
client.send_control(control)
def __init__(self):
self.Task = 0
self.Conditions = CarlaSettings()
self.Poses = [[]]
self.Repetitions = 1
def make_carla_settings(args):
"""Make a CarlaSettings object with the settings we need."""
settings = CarlaSettings()
# settings.set(
# SynchronousMode=False,
# SendNonPlayerAgentsInfo=True,
# NumberOfVehicles=15,
# NumberOfPedestrians=30,
# WeatherId=random.choice([1, 3, 7, 8, 14]),
# QualityLevel=args.quality_level)
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=False,
NumberOfVehicles=0,
NumberOfPedestrians=0,
WeatherId=random.choice([1, 3, 7, 8, 14]),
QualityLevel=args.quality_level)
settings.randomize_seeds()
camera0 = sensor.Camera('CameraRGB')
camera0.set_image_size(WINDOW_WIDTH, WINDOW_HEIGHT)
camera0.set_position(2.0, 0.0, 1.4)
camera0.set_rotation(0.0, 0.0, 0.0)
settings.add_sensor(camera0)
camera1 = sensor.Camera('CameraDepth', PostProcessing='Depth')
camera1.set_image_size(MINI_WINDOW_WIDTH, MINI_WINDOW_HEIGHT)
camera1.set_position(2.0, 0.0, 1.4)
camera1.set_rotation(0.0, 0.0, 0.0)
settings.add_sensor(camera1)
camera2 = sensor.Camera('CameraSemSeg',
PostProcessing='SemanticSegmentation')
camera2.set_image_size(MINI_WINDOW_WIDTH, MINI_WINDOW_HEIGHT)
camera2.set_position(2.0, 0.0, 1.4)
camera2.set_rotation(0.0, 0.0, 0.0)
settings.add_sensor(camera2)
if args.lidar:
lidar = sensor.Lidar('Lidar32')
lidar.set_position(0, 0, 2.5)
lidar.set_rotation(0, 0, 0)
lidar.set(Channels=32,
Range=50,
PointsPerSecond=100000,
RotationFrequency=10,
UpperFovLimit=10,
LowerFovLimit=-30)
settings.add_sensor(lidar)
return settings