def pytest_configure(config): mpl.use("Agg") EmulatorInterface.strict = True nengo_loihi.set_defaults() config.addinivalue_line( "markers", "target_sim: mark test as only running on emulator") config.addinivalue_line( "markers", "target_loihi: mark test as only running on hardware") config.addinivalue_line( "markers", "hang: mark test as hanging indefinitely on hardware") # add unsupported attribute to Simulator (for compatibility with nengo<3.0) # join all the lines and then split (preserving quoted strings) if nengo.version.version_info <= (2, 8, 0): unsupported = shlex.split(" ".join( config.getini("nengo_test_unsupported"))) # group pairs (representing testname + reason) unsupported = [ unsupported[i:i + 2] for i in range(0, len(unsupported), 2) ] # wrap square brackets to interpret them literally # (see https://docs.python.org/3/library/fnmatch.html) for i, (testname, _) in enumerate(unsupported): unsupported[i][0] = "".join("[%s]" % c if c in ("[", "]") else c for c in testname).replace("::", ":") nengo_loihi.Simulator.unsupported = unsupported
def pytest_configure(config): mpl.use("Agg") CxSimulator.strict = True if config.getoption('seed_offset'): TestConfig.test_seed = config.getoption('seed_offset')[0] nengo_loihi.set_defaults() # Only log warnings from Nengo logging.getLogger("nengo").setLevel(logging.WARNING)
def pytest_configure(config): mpl.use("Agg") EmulatorInterface.strict = True if config.getoption('seed_offset'): TestConfig.test_seed = config.getoption('seed_offset')[0] nengo_loihi.set_defaults() # add unsupported attribute to Simulator (for compatibility with nengo<3.0) # join all the lines and then split (preserving quoted strings) unsupported = shlex.split(" ".join( config.getini("nengo_test_unsupported"))) # group pairs (representing testname + reason) unsupported = [unsupported[i:i + 2] for i in range(0, len(unsupported), 2)] # wrap square brackets to interpret them literally # (see https://docs.python.org/3/library/fnmatch.html) for i, (testname, _) in enumerate(unsupported): unsupported[i][0] = "".join("[%s]" % c if c in ('[', ']') else c for c in testname) nengo_loihi.Simulator.unsupported = unsupported
try: os.mkdir(trainOutput) except: pass import sys sys.stdout = open(trainOutput + "/output.txt", 'w') import nengo import nengo_dl import nengo_loihi import pandas as pd import matplotlib.pyplot as plt import tensorflow as tf from myutils import * nengo_loihi.set_defaults() def conv_layer(x, *args, activation=True, **kwargs): # create a Conv2D transform with the given arguments conv = nengo.Convolution(*args, channels_last=False, **kwargs) if activation: # add an ensemble to implement the activation function layer = nengo.Ensemble(conv.output_shape.size, 1).neurons else: # no nonlinearity, so we just use a node layer = nengo.Node(size_in=conv.output_shape.size) # connect up the input object to the new layer nengo.Connection(x, layer, transform=conv)
def demo( backend="cpu", collect_ground_truth=False, motor_neuron_type=LoihiSpikingRectifiedLinear(), neural_vision=True, plot_mounted_camera_freq=None, weights_name=None, ): if backend == "loihi": nengo_loihi.set_defaults() seed = 0 np.random.seed(seed) # target generation limits dist_limit = [0.25, 3.5] angle_limit = [-np.pi, np.pi] accel_scale = 500 steer_scale = 500 # data collection parameters in steps (1ms per step) max_time_to_target = 10000 net = nengo.Network(seed=seed) # create our Mujoco interface interface = Mujoco( xml_file="rover.xml", joint_names=["steering_wheel"], dt=0.001, render_params={ "cameras": [4, 1, 3, 2], # camera ids and order to render "resolution": [32, 32], "frequency": 1, # render images from cameras every time step "plot_frequency": None, # do not plot images from cameras }, track_input=True, input_scale=np.array([steer_scale, accel_scale]), ) # NOTE: why the slow rendering when defined before interface? vision = RoverVision(seed=0) # set up the target position net.target = np.array([-0.0, 0.0, 0.2]) net.config[nengo.Connection].synapse = None with net: net.image_count = 0 net.val_img_count = -1 net.train_img_count = -1 # track position net.target_track = [] net.rover_track = [] net.vision_track = [] net.localtarget_track = [] net.ideal_motor_track = [] if neural_vision: visionsim, visionnet = vision.convert( add_probes=False, swap_activations={tf.nn.relu: LoihiSpikingRectifiedLinear()}, scale_firing_rates=400, ) if weights_name is not None: visionsim.load_params("%s/%s" % (current_dir, weights_name)) with visionsim: visionsim.freeze_params(visionnet) vision.input.size_in = vision.subpixels vision.input.output = None if not neural_vision or collect_ground_truth: # rotation matrix for rotating error from world to rover frame theta = 3 * np.pi / 2 R90 = np.array([ [np.cos(theta), -np.sin(theta), 0], [np.sin(theta), np.cos(theta), 0], [0, 0, 1], ]) def local_target(t): rover_xyz = interface.get_position("base_link") error = net.target - rover_xyz # error in global coordinates, want it in local coordinates for rover R_raw = interface.get_orientation("base_link").T # R.T = R^-1 # rotate it so y points forward toward the steering wheels R = np.dot(R90, R_raw) local_target = np.dot(R, error) net.localtarget_track.append(local_target / np.pi) # used to roughly normalize the local target signal to -1:1 range output_signal = np.array([local_target[0], local_target[1]]) return output_signal local_target = nengo.Node(output=local_target, size_out=2) def check_exit_and_track_data(t, x): if interface.exit: raise ExitSim rover_xyz = interface.get_position("base_link") dist = np.linalg.norm(rover_xyz - net.target) if dist < 0.2 or int(t / interface.dt) % max_time_to_target == 0: # generate a new target 1-2.5m away from current position while dist < 1 or dist > 2.5: phi = np.random.uniform(low=angle_limit[0], high=angle_limit[1]) radius = np.random.uniform(low=dist_limit[0], high=dist_limit[1]) net.target = [ np.cos(phi) * radius, np.sin(phi) * radius, 0.2 ] dist = np.linalg.norm(rover_xyz - net.target) interface.set_mocap_xyz("target", net.target) net.target_track.append(net.target) # track data net.rover_track.append(rover_xyz) net.vision_track.append(np.copy(x)) check_exit_and_track_data = nengo.Node( check_exit_and_track_data, size_in=2, label="check_exit_and_track_data") mujoco_node = interface.make_node() # ----------------------------------------------------------------------------- # --- set up ensemble to calculate acceleration def accel_function(x): return min(np.linalg.norm(-x), 1) accel = nengo.Ensemble( neuron_type=motor_neuron_type, n_neurons=4096, dimensions=2, max_rates=nengo.dists.Uniform(50, 200), radius=1, label="accel", ) nengo.Connection( accel, mujoco_node[1], function=accel_function, synapse=0 if motor_neuron_type == nengo.Direct() else 0.1, ) # --- set up ensemble to calculate torque to apply to steering wheel def steer_function(x): error = x[1:] * np.pi # take out the error signal from vision q = x[0] * 0.7 # scale normalized input back to original range # arctan2 input set this way to account for different alignment # of (x, y) axes of rover and the environment # turn_des = np.arctan2(-error[0], abs(error[1])) turn_des = np.arctan2(-error[0], error[1]) u = (turn_des - q) / 2 # divide by 2 to get in -1 to 1 ish range return u steer = nengo.Ensemble( neuron_type=motor_neuron_type, n_neurons=4096, dimensions=3, max_rates=nengo.dists.Uniform(50, 200), radius=np.sqrt(2), label="steer", ) nengo.Connection( steer, mujoco_node[0], function=lambda x: steer_function(x), # if using Direct mode, a synapse will cause oscillating control synapse=0 if motor_neuron_type == nengo.Direct() else 0.025, ) # add a relay node to amalgamate input to steering ensemble steer_input = nengo.Node(size_in=3, label="relay_motor_input") nengo.Connection(steer_input, steer) # -- connect relevant motor feedback (joint angle of steering wheel) nengo.Connection(mujoco_node[0], steer_input[0]) # --- connect vision up to motor ensembles and mujoco node vision_synapse = 0.05 if neural_vision: # send image input in to vision system nengo.Connection(mujoco_node[2:], vision.input) # connect vision network prediction to steering ensemble nengo.Connection(vision.output, steer_input[1:], synapse=vision_synapse) # connect vision network prediction to accel ensemble nengo.Connection(vision.output, accel, synapse=vision_synapse) # connect vision network to data tracking node nengo.Connection(vision.output, check_exit_and_track_data, synapse=vision_synapse) else: # if we're not using neural vision, then hook up the local_target node # to our motor system to get the location of the target relative to rover nengo.Connection( local_target, steer_input[1:], synapse=vision_synapse, transform=1 / np.pi, ) nengo.Connection( local_target, accel, synapse=vision_synapse, transform=1 / np.pi, ) nengo.Connection(local_target, check_exit_and_track_data, transform=1 / np.pi) if collect_ground_truth: # create a direct mode ensemble performing the same calculation for debugging def calculate_ideal_motor_signals(t, x): net.ideal_motor_track.append([ steer_function(x) * steer_scale, accel_function(x[1:]) * accel_scale, ]) ground_truth = nengo.Node(output=calculate_ideal_motor_signals, size_in=3, size_out=0) # connect local target prediction or node if neural_vision: nengo.Connection( vision.output, ground_truth[1:], synapse=vision_synapse, ) else: nengo.Connection( local_target, ground_truth[1:], synapse=vision_synapse, transform=1 / np.pi, ) # connect steering wheel angle feedback nengo.Connection(mujoco_node[0], ground_truth[0]) if backend == "loihi": nengo_loihi.add_params(net) if neural_vision: net.config[vision.conv0.ensemble].on_chip = False net.control_track = interface.input_track return net