def __init__(self,
hostname='localhost',
port=3001,
*,
driver=None,
serializer=None,
data=None):
self.hostaddr = (hostname, port)
self.driver = driver or Driver()
self.serializer = serializer or Serializer()
self.state = State.STOPPED
self.socket = None
self.datafile = data
_logger.debug('Initializing {}.'.format(self))
self.crashed = False
self.stuck = False
self.fitness = 0
self.timespend = 0
self.stack = 0
self.count = 0
self.sumspeed = 0
self.speed = 0
self.position = 0
self.positionReward = 0
self.accelReward = 0
self.countOutside = 0
def __init__(self,
model_file,
H,
depth,
port,
record_train_file=None,
normalize=False):
super().__init__(False)
if normalize:
self.norm = True
else:
self.norm = False
# Select right model
if depth == 3:
self.model = train.ThreeLayerNet(22, H, 3)
elif depth == 5:
self.model = train.FiveLayerNet(22, H, 3)
else:
print("Using depth=2")
self.model = train.TwoLayerNet(22, H, 3)
# Load model
self.model.load_state_dict(
torch.load(model_file, map_location=lambda storage, loc: storage))
# Check if we want to record the actuator & sensor data
self.record = False
if record_train_file is not None:
self.record = True
self.file_handler = open(record_train_file, 'w')
self.file_handler.write("ACCELERATION,BRAKE,STEERING,SPEED,\
TRACK_POSITION,ANGLE_TO_TRACK_AXIS,TRACK_EDGE_0,TRACK_EDGE_1,\
TRACK_EDGE_2,TRACK_EDGE_3,TRACK_EDGE_4,TRACK_EDGE_5,TRACK_EDGE_6,\
TRACK_EDGE_7,TRACK_EDGE_8,TRACK_EDGE_9,TRACK_EDGE_10,\
TRACK_EDGE_11,TRACK_EDGE_12,TRACK_EDGE_13,TRACK_EDGE_14,\
TRACK_EDGE_15,TRACK_EDGE_16,TRACK_EDGE_17,TRACK_EDGE_18")
self.is_leader = True
self.helper = StupidDriver(self.record)
self.standard_driver = Driver()
self.race_started = False
self.recovers = 0
self.recover_mode = False
self.speeds = []
self.dict = {}
self.dict["crashes"] = []
self.crash_recorded = False
self.dict_teammate = {}
self.port = port
self.partner = -1
path = os.path.abspath(os.path.dirname(__file__))
for i in os.listdir(path):
if os.path.isfile(os.path.join(path, i)) and 'mjv_partner' in i:
try:
os.remove(path + "/" + i)
except:
pass
def test_init_encoding():
d = Driver(False)
s = Serializer()
data = {'init': d.range_finder_angles}
encoded = s.encode(data, prefix='SCR')
assert encoded == b'SCR(init -90 -75 -60 -45 -30 -20 -15 -10 -5 0 5 10 15 20 30 45 60 75 90)'
def __init__(self, hostname='localhost', port=3001, *,
driver=None, serializer=None):
self.hostaddr = (hostname, port)
self.driver = driver or Driver()
self.serializer = serializer or Serializer()
self.state = State.STOPPED
self.socket = None
_logger.debug('Initializing {}.'.format(self))
def __init__(self, logdata=True):
""" Handles difficult situations in which the car gets stuck
"""
super(CrisisDriver, self).__init__(logdata=logdata)
self.iter = 0
self.driver = Driver(logdata=False)
self.is_in_control = False
self.approaches = [self.navigate_to_middle, self.original_implementation]
self.previous_angles = []
self.previous_accels = []
self.previous_gears = []
self.bad_counter = 0
self.needs_help = False
def __init__(self, steering_values, global_max_speed):
super(Final_Driver, self).__init__()
self.steer = ffnn_steer.Steer(10)
self.steer.load_state_dict(torch.load("./steer.data"))
self.speed = ffnn_speed.Speed(10)
self.speed.load_state_dict(torch.load("./ffnn_speed.data"))
self.back_up_driver = Driver(logdata=False)
self.bad_counter = 0
self.lap_counter = 0
self.brake_row = 0
self.angles = [90, 75, 60, 45, 30, 20, 15, 10, 5, 0, -5, -10, -15, -20, -30, -45, -60, -75, -90]
self.alphas = [math.radians(x) for x in self.angles]
self.last_opponents = [0 for x in range(36)]
self.steering_values = steering_values
self.global_max_speed = global_max_speed
def __init__(self,
hostname='localhost',
port=3001,
*,
driver=None,
serializer=None):
self.hostaddr = (hostname, port)
self.driver = driver or Driver()
self.serializer = serializer or Serializer()
self.state = State.STOPPED
self.socket = None
self.fitness = -1.
self.offroad_count = 0
self.turn_around_count = 0
self.negative_speed_count = 0
_logger.debug('Initializing {}.'.format(self))
def test_special_messages(mock_socket_ctor):
mock_socket = mock.MagicMock()
mock_socket_ctor.return_value = mock_socket
mock_driver = mock.MagicMock()
mock_driver.range_finder_angles = Driver(False).range_finder_angles
client = Client(driver=mock_driver)
assert client.state is State.STOPPED
mock_socket.recvfrom = mock.MagicMock(side_effect=[(b'***identified***', None),
(b'***restart***', None),
(b'***shutdown***', None)])
client.run()
assert client.state is State.STOPPED
# not supported on server side
assert mock_driver.on_restart.call_count == 1
assert mock_driver.on_shutdown.call_count == 1
def __init__(self, model_file, H, depth, record_train_file=None, normalize=False):
super().__init__(False)
if normalize:
self.norm = True
else:
self.norm = False
# Select right model
if depth == 3:
self.model = train.ThreeLayerNet(22, H, 3)
elif depth == 5:
self.model = train.FiveLayerNet(22, H, 3)
else:
print("Using depth=2")
self.model = train.TwoLayerNet(22, H, 3)
# Load model
self.model.load_state_dict(torch.load(
model_file, map_location=lambda storage, loc: storage))
# Check if we want to record the actuator & sensor data
self.record = False
if record_train_file is not None:
self.record = True
self.file_handler = open(record_train_file, 'w')
self.file_handler.write("ACCELERATION,BRAKE,STEERING,SPEED,\
TRACK_POSITION,ANGLE_TO_TRACK_AXIS,TRACK_EDGE_0,TRACK_EDGE_1,\
TRACK_EDGE_2,TRACK_EDGE_3,TRACK_EDGE_4,TRACK_EDGE_5,TRACK_EDGE_6,\
TRACK_EDGE_7,TRACK_EDGE_8,TRACK_EDGE_9,TRACK_EDGE_10,\
TRACK_EDGE_11,TRACK_EDGE_12,TRACK_EDGE_13,TRACK_EDGE_14,\
TRACK_EDGE_15,TRACK_EDGE_16,TRACK_EDGE_17,TRACK_EDGE_18")
self.is_leader = True
self.helper = StupidDriver(self.record)
self.standard_driver = Driver()
self.race_started = False
self.recovers = 0
self.recover_mode = False
self.speeds = []
self.number = 1
def __init__(self,
hostname='localhost',
port=3001,
*,
driver=None,
serializer=None,
fitnessFile='neat/fitnessFile'):
self.hostaddr = (hostname, port)
self.driver = driver or Driver()
self.serializer = serializer or Serializer()
self.state = State.STOPPED
self.socket = None
self.evaluation = {
'crashed': False,
'stuck': False,
'fitness': 0,
'time': 0,
'avgSpeed': 0,
'position': 0,
'steering': 0,
'iteration': 1,
'lapComplete': False
}
self.priorities = {
'speed': 5,
'distance': 1,
'crashPenalty': 0,
'steeringPenalty': 100,
}
self.fitnessFile = fitnessFile
_logger.debug('Initializing {}.'.format(self))
type=str
)
parser.add_argument('-v', help='Debug log level.', action='store_true')
#args = parser.parse_args()
args, _ = parser.parse_known_args()
# switch log level:
if args.v:
level = logging.DEBUG
else:
level = logging.INFO
del args.v
logging.basicConfig(
level=level,
format="%(asctime)s %(levelname)7s %(name)s %(message)s"
)
# start client loop:
client = Client(driver=driver, **args.__dict__)
client.run()
if __name__ == '__main__':
main(Driver())
default='Driver1')
parser.add_argument('-u',
'--unstuck',
help='Make the drivers automatically try to unstuck',
action='store_true')
args, _ = parser.parse_known_args()
print(args.parameters_file)
print(args.output_file)
print(args.driver)
if args.parameters_file is not None:
driver = registry[args.driver](args.parameters_file,
out_file=args.output_file,
unstuck=args.unstuck)
else:
driver = Driver()
try:
main(driver)
except Exception as exc:
traceback.print_exc()
if args.parameters_file is not None:
driver.saveResults()
raise
