def __init__(self, inputs, threshold=0, weight=None, activation=None, input_values=None): """ initialize the Neuron """ Logger.log("initializing neuron with {0} inputs".format(inputs)) self.weights = [] self.input_values = [] if activation == None: self.activate = self.__activateSign else: self.activate = activation self.threshold = threshold w = 0 if (weight == None): # Set all the weights and threshold levels of the network to random numbers uniformly distributed inside a small range (Haykin, 1999): # meaning only one random number / number of inputs w = random.uniform(-0.5, 0.5) w = round(w / float(inputs), 2) else: w = round(weight / float(inputs), 2) for x in range(inputs): self.weights.append(w)
def __init__(self, layers, threshold=0): """ initialize a new network :param layers: list containing number of neurons in each layer with optionally associated weights """ self.layers = [] self.threshold = threshold layer_number = 0 self.outputs = [] # initialize input layer input_layer = layers[0] inputs = 1 if isinstance(input_layer, int): Logger.log( "appending {0} neurons to input layer".format(input_layer), "green") self.layers.append([]) for x in range(input_layer): self.layers[0].append(Neuron(inputs, self.threshold, 0)) # initialize all hidden and output layers inputs = len(self.layers[0]) for (layer_number, layer) in enumerate(layers[1:]): if isinstance(layer, int): Logger.log( "appending {0} neurons to layer {1}".format( layer, layer_number + 1), "green") self.layers.append([]) for x in range(layer): self.layers[-1].append(Neuron(inputs, self.threshold)) inputs = layer
def retrieve(self, probe): bipolar = make_bipolar(probe) flat_probe = [item for sublist in bipolar for item in sublist] Logger.log("retrieving probe:{0}".format(probe)) # stuff with 0's - incomplete information while len(flat_probe) < len(self.neurons): flat_probe.append(0) Logger.log("probe:{0}".format(flat_probe)) # initial state counter = 0 y = flat_probe test = [] while test != self.state_vector: Logger.log("state vector:{0} is not equal to retrieval:{1}".format(unmake_bipolar(self.state_vector, len(charset[probe[0]])), unmake_bipolar(y, len(charset[probe[0]])))) import random r = random.randint(0, len(self.state_vector)-1) self.neurons[r].retrieve(y) y = self.state_vector test = [neuron.test(self.state_vector) for neuron in self.neurons] counter += 1 Logger.log("stable state after {1}:epochs retrieved:{0}".format(self.state_vector, counter)) Logger.log("stable state unbipolarized:{0}".format(unmake_bipolar(self.state_vector, len(charset[probe[0]]))))
def weight_train(self, desired, layer, output): """ calculates the error gradient desired is either the desired pattern or the error gradient """ if output: self.error_signal = desired - self.output self.error_gradient = self.output * ( 1 - self.output) * self.error_signal # dont apply them yet, we need them for further backpropagation self.weight_corrections = [ self.learning_rate * y.output * self.error_gradient for y in layer ] else: self.error_signal = desired self.error_gradient = self.output * ( 1 - self.output) * self.error_signal self.weight_corrections = [ self.learning_rate * y.output * self.error_gradient for y in layer ] Logger.log( "trained output Neuron to signal:{0}, gradient:{1} and delta:{2}". format(self.error_signal, self.error_gradient, self.weight_corrections))
def initialize(): Logger.createNewLog(purgeLogs) # GUI already initialized on import resolution Client.startClient() Server.startServer() # ControllerClient.startControllerForwarding() Logger.log("DriverStation initialized")
def handleConn(typeOfMessage: messageType, data): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: attemptedConnections = 0 while True: try: s.connect((IP, PORT)) except ConnectionRefusedError: # if connection refused (server not online, wait for it to start) timeout = 3 sec (NOTE: if experiencing memory/CPU intensive ops this is very memory intensive (1 thread per frame of camera :^)) ) attemptedConnections += 1 if (attemptedConnections >= 3): Logger.log( f"Connection to {(IP, PORT)} refused. Is the server online?" ) return time.sleep(1) continue else: break if (typeOfMessage != messageType.camera): # if it is not a camera, it is string s.sendall(typeOfMessage.value.encode() + messageEncoder.encode(data) + EOM) else: s.sendall(typeOfMessage.value.encode() + imageEncoder.encode(data[0], data[1]))
def __init__(self, layers, learning_rate=1, threshold=None): Logger.log("initializing MLP with {0} layers".format(len(layers))) # sum of all neurons in the mlp self.F = sum(layers) self.layers = [ Layer(neurons, self.F, learning_rate, threshold) for neurons in layers ]
def __combineInputs(self, inputs): """ lineary combine the neurons input """ x = sum( int(value) * float(self.weights[index]) for (index, value) in enumerate(inputs)) x -= self.threshold Logger.log("activation x = " + str(x) + ", threshold: " + str(self.threshold) + ", weight: " + str(self.weights)) return x
def learn(self, input_vector, neuron_index, state): """ generalized hebbian learning rule """ for j, weight in enumerate(self.weights): if j != neuron_index: dw = 0 if state == input_vector[j]: dw = 1 else: dw = -1 self.weights[j] += dw Logger.log("for weight i:{0} j:{1} - dw = {2} and weight = {3}".format(neuron_index, j, dw, self.weights[j]))
def startControllerServer(): Logger.log("Controller Server Started") while True: try: doServer() except ConnectionAbortedError: Logger.logError(format_exc()) time.sleep(2) continue
def activate(self, pattern): """ activates the layer using the patterns """ for i, neuron in enumerate(self.neurons): # input layer if not neuron.weights: neuron.output = pattern[i] # processing layers else: neuron.activate(pattern) Logger.log("activated layer: {0}".format(self.output))
def calibrate(self): Logger.log( "Calibrating IMU, ensure this occured at a time when robot is completely still" ) last = time.time() while (not self.BNO055.calibrated): if (time.time() - last >= 1): results = self.BNO055.calibration_status print( f"\n\nSys status: {results[0]}\nGyro status: {results[1]}\nAccel status: {results[2]}\nMagn status: {results[3]}" ) pass
def initialize(): """Initialize all relevant robot components/tools here""" Logger.createNewLog(purgeLogs) # create daemons # Client.startClient() # Server.startServer() # Cameras.start() # initialize all components here components.append(Drive()) components.append(Manipulator()) Logger.log("Components initialized")
def subscribe(fn): # create wrapper function to manipulate wrapped fn if(not inspect.iscoroutinefunction(fn)): # ensure function has been defined as async def name(): ... (could add functionality for both but would add like 50 lines and its easy enough to write an asynchronous function that does not need to wait on anything :P) raise SubscriptionException("Cannot subscribe synchronous function to asynchronous event system") if not event_type in subscribers: # add subscribed event to subscription tracker subscribers[event_type] = [] if fn in subscribers[event_type]: # ensure no function is subscribed twice try: raise SubscriptionException("Cannot subscribe function twice") except SubscriptionException: Logger.logError(format_exc()) return fn subscribers[event_type].append(fn) # add function to subscribed event in tracker Logger.log(fn, "successfully subscribed to event " + event_type.__name__) # DEBUG log return fn
def activate(self, inputs=None): """ calculate the network's output, this is the first step in backpropagation learning """ if inputs != None: self.assignInput(inputs) inputs = None for (index, layer) in enumerate(self.layers): self.outputs = [] self.outputs.extend(neuron.output(inputs) for neuron in layer) inputs = self.outputs Logger.log("layer {0} output = {1}".format(index, self.outputs)) return self.outputs
def learn(self, M, epochs=1, learning_rate = .1, forgetting_factor = .01): """ a method for network learning M - the patterns """ for e in range(epochs): for m in M: for i, neuron in enumerate(self.neurons): bipolar = make_bipolar(m) flat_input = [item for sublist in bipolar for item in sublist] neuron.learn(flat_input, i, flat_input[i]) Logger.log("I've learned:") for i, neuron in enumerate(self.neurons): Logger.log("w{0}: {1}".format(i, neuron.weights))
def __init__(self, F, learning_rate, threshold): """ F - number of all neurons in the network """ self.weights = [] import random if not threshold: self.threshold = random.uniform(-2.4 / F, 2.4 / F) else: self.threshold = threshold self.output = None self.learning_rate = learning_rate Logger.log("initializing Neuron")
def __init__(self, F, learning_rate, threshold): """ F - number of all neurons in the network """ self.weights = [] import random if not threshold: self.threshold = random.uniform(-2.4/F, 2.4/F) else: self.threshold = threshold self.output = None self.learning_rate = learning_rate Logger.log("initializing Neuron")
def weight_train(self, desired, layer, output): """ calculates the error gradient desired is either the desired pattern or the error gradient """ if output: self.error_signal = desired - self.output self.error_gradient = self.output * (1 - self.output) * self.error_signal # dont apply them yet, we need them for further backpropagation self.weight_corrections = [self.learning_rate * y.output * self.error_gradient for y in layer] else: self.error_signal = desired self.error_gradient = self.output * (1 - self.output) * self.error_signal self.weight_corrections = [self.learning_rate * y.output * self.error_gradient for y in layer] Logger.log("trained output Neuron to signal:{0}, gradient:{1} and delta:{2}".format(self.error_signal, self.error_gradient, self.weight_corrections))
def post_event(event_type: Event, *args, **kwargs): """Post event and notify subscribers""" if not event_type in subscribers: print(f"Event '{event_type}' was posted, but either does not exist or has no subscribers") return # create list of coroutines to run coros:list[Coroutine] = [] for fn in subscribers[event_type]: try: coros.append(fn(*args, **kwargs)) # create coroutines and add to list except TypeError: # if type error happens, attempted to create coroutine with arguments not accepted by it (not a big deal, log and move on) Logger.log(f"Attempted to create coroutine from function {fn} with arguments: {args} , {kwargs}") continue res = asyncio.run(__doCoros(coros)) # run all coroutines for i, result in enumerate(res): if result is not None: # if coroutine returned value, log and move on Logger.log(f"Function: {subscribers[event_type][i]} returned {result} when called on event bus")
def initialize(self): """ initializes the neuron weights """ for i, layer in enumerate(self.layers): try: layer.assign_weights(self.layers[i+1], self.F) Logger.log("assigned weights to layer {0}".format(i+2)) except IndexError: Logger.log("finished assigning weights") for i, layer in enumerate(self.layers): Logger.log("initialized layer {0}".format(i+1)) for j, n in enumerate(layer.neurons): Logger.log("neuron {0}:{1} weights {2}".format(i+1, j+1, n.weights))
def __init__(self): # Grab the relevant servos from the map self.elbow_servo = MANIP_SERVOS["MANIP_ELBOW_SERVO"] self.elbow_servo2 = MANIP_SERVOS["MANIP_ELBOW_SERVO_2"] self.level_servo = MANIP_SERVOS["MANIP_LEVEL_SERVO"] self.wrist_servo = MANIP_SERVOS["MANIP_WRIST_SERVO"] self.clamp_servo = MANIP_SERVOS["MANIP_CLAMP_SERVO"] self.enabled = False self.chicken = False self.clamp = False self.elbow_angle = 90 self.elbow_angle_old = 90 self.wrist_angle = 90 self.wrist_angle_old = 90 self.level_angle = 90 self.level_angle_old = 90 self.elbow_tune = 11 self.elbow_tune2 = 12 self.level_tune = 0 self.wrist_tune = 15 self.x_velocity = 0 self.y_velocity = 0 self.VELOCITY_SCALING_FACTOR = .1 # SUBJECT TO CHANGE self.VELOCITY_IGNORE = .1 # Tunes how sensitive joystick is to changes self.ELBOW_ANGLE_MAX = 180 self.ELBOW_ANGLE_MIN = 0 self.LEVEL_ANGLE_MAX = 180 self.LEVEL_ANGLE_MIN = 0 self.WRIST_ANGLE_MAX = 180 self.WRIST_ANGLE_MIN = 0 self.wrist_servo.angle = 90 + self.wrist_tune self.elbow_servo.angle = 90 + self.elbow_tune self.elbow_servo2.angle = 90 + self.elbow_tune2 self.level_servo.angle = 90 + self.level_tune self.clamp_servo.angle = 85 Logger.log("MANIPULATOR CONSTRUCTED")
def initialize(self): """ initializes the neuron weights """ for i, layer in enumerate(self.layers): try: layer.assign_weights(self.layers[i + 1], self.F) Logger.log("assigned weights to layer {0}".format(i + 2)) except IndexError: Logger.log("finished assigning weights") for i, layer in enumerate(self.layers): Logger.log("initialized layer {0}".format(i + 1)) for j, n in enumerate(layer.neurons): Logger.log("neuron {0}:{1} weights {2}".format( i + 1, j + 1, n.weights))
def test(self, fundamental_memories): fundamental_memories.append("abcd.efg") for fundamental_memory in fundamental_memories: Logger.log("testing fundamental memory:{0} with state vector:{1}".format(fundamental_memory, self.state_vector)) corelation = [] bipolar = make_bipolar(fundamental_memory) flat_memory = [item for sublist in bipolar for item in sublist] Logger.log("{0} length: {1}".format(fundamental_memory, len(flat_memory))) for i in flat_memory: x_mi = i # there is no sign function in python... :D y_mi = self.neurons[i].test(flat_memory) if x_mi == y_mi: corelation.append(True) response = [n.test(flat_memory) for n in self.neurons] Logger.log("{0}: {1}".format(fundamental_memory, unmake_bipolar(response, len(charset[fundamental_memory[0]])))) Logger.log("{0}: {1}".format(fundamental_memory, len(corelation)))
def backpropagate(self, pattern): Logger.log("beginning backpropagation of pattern {0}".format(pattern[1])) Logger.log("training output layer") self.layers[-1].backpropagate(pattern[1], self.layers[-2], True) current = self.layers[-1] backward = self.layers[1:-1] backward.reverse() for i, layer in enumerate(backward): Logger.log("training hidden layer {0}".format(len(self.layers)-i-1)) layer.backpropagate(None, current) current = layer for layer in self.layers[1:]: for neuron in layer.neurons: neuron.update_weight()
def backpropagate(self, pattern): Logger.log("beginning backpropagation of pattern {0}".format( pattern[1])) Logger.log("training output layer") self.layers[-1].backpropagate(pattern[1], self.layers[-2], True) current = self.layers[-1] backward = self.layers[1:-1] backward.reverse() for i, layer in enumerate(backward): Logger.log( "training hidden layer {0}".format(len(self.layers) - i - 1)) layer.backpropagate(None, current) current = layer for layer in self.layers[1:]: for neuron in layer.neurons: neuron.update_weight()
def doControllerForwarding(): # try to connect to server while True: try: Logger.log("Attempting to connect to Controller Server") SOC.connect((IP, PORT)) time.sleep( .01 ) # wait 10 milliseconds before sending anything (no reason, just be safe i guess) Logger.log( "Sucessfully connected to Controller Server......starting controller" ) break except: # in case of error (such as server not running yet), retry connection in 5 seconds Logger.log( "Connection unable to be established. Retrying in 2 seconds") time.sleep(2) continue # after ensuring connection to controller server, start sending data asyncio.run(run_forward())
# initialize Robot initialize() # Start Robot try: # Define initial state STATE = State.idle last = time.time() while True: # place update methods for things that should be updated at idle here Controller.updateController() if (STATE == State.idle): # when idle, continue doing nothing (Daemon's/other threads of control will continue to run) continue # when not idle, decide what to do if (STATE == State.teleop): for component in components: component.update() elif (STATE == State.auto): for component in components: component.autoUpdate() else: raise IllegalStateException("Robot state is undefined") except: # Log Exception (removes \n from the end) Logger.logError(format_exc()[0:-1]) finally: Logger.log("Killing Components") for component in components: component.kill()
def __init__(self, neurons, F, learning_rate, threshold): Logger.log("initializing Layer with {0} neurons".format(neurons)) self.neurons = [ Neuron(F, learning_rate, threshold) for neuron in range(neurons) ]
def activate(self, pattern): """ activates the mlp using the patterns """ Logger.log("activating input layer") self.layers[0].activate(pattern[0]) for i, layer in enumerate(self.layers[1:]): layer.activate(self.layers[i].output)
def doServer(): # create new socket object with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) # bind our socket to our port s.listen() # listen for connections # outside loop to enable restarting the server while True: conn, addr = s.accept( ) # once connection available, accept it (THIS IS BLOCKING) try: with conn: # Start by getting controller information json (first packet received) # print("Connected to", addr) # print who we are connected with data: bytes = b"" while not data: data += conn.recv(4096) # if message post-curser not found, keep polling the socket if (EOM not in data): continue split = data.index(EOM) controllerInformation = data[:split] data = data[split + len(EOM):] controllerInformation = controllerInformation.decode() try: controllerInformation = json.loads( controllerInformation) except JSONDecodeError: # JSONDecode error here is FATAL, abort the connection (and retry connection) Logger.logError(format_exc()) s.close() raise ConnectionAbortedError # TODO: MAKE OBSOLETE # parse any events grabbed from socket at this time events: List[List] = [] while EOM in data: split = data.index(EOM) try: events.append( json.loads(data[:split].decode().replace( '\n', ''))) except JSONDecodeError: Logger.logError(format_exc()) data = data[split + len( EOM ):] # if we cut off data, leave cut off data in buffer # once we start getting data, get the first thing sent (our controller information) devices_json = controllerInformation devices = [] for device_json in devices_json: capabilities = {} for k, v in device_json['capabilities'].items( ): # parse capabilities json capabilities[int(k)] = [ x if not isinstance(x, list) else (x[0], evdev.AbsInfo(**x[1])) for x in v ] # create new EVDev device devices.append( evdev.UInput(capabilities, name=device_json['name'], vendor=device_json["vendor"], product=device_json["product"], version=device_json["version"])) Logger.log('Controller Device created') # while we are connected read controller data (and try not to miss any events) while True: # poll the socket start = time.time() while EOM not in data: # grab data until EOM character reached data += conn.recv(4096) if (not data and time.time() - start > 60 ): # 60 second timeout for controller server raise ConnectionResetError # parse data # deocde, remove EOM character, split events into list dataLST: List[str] = data.decode()[:len(data) - len(EOM)].split( '\n') for possibleEvent in dataLST: if (possibleEvent == '' ): # check if event is valid continue try: events.append( json.loads(possibleEvent.replace('\n', '')) ) # get rid of unwanted \n's if they exist except JSONDecodeError: # Error here is not FATAL, ignore the event and continue parsing events Logger.logError(format_exc()) continue # apply pending events for event in events: if (event == ''): continue # write events to applicable device devices[int(event[0])].write( int(event[1]), int(event[2]), int(event[3])) events = [] # connection was reset from other side (or maybe your network dropped) except ConnectionResetError: Logger.logError(format_exc()) time.sleep(1) # wait second before retrying connection continue
def __init__(self, neurons, F, learning_rate, threshold): Logger.log("initializing Layer with {0} neurons".format(neurons)) self.neurons = [Neuron(F, learning_rate, threshold) for neuron in range(neurons)]
def __init__(self, layers, learning_rate = 1, threshold = None): Logger.log("initializing MLP with {0} layers".format(len(layers))) # sum of all neurons in the mlp self.F = sum(layers) self.layers = [Layer(neurons, self.F, learning_rate, threshold) for neurons in layers]
class Collection(object): def __init__(self, rootdir, dbname='jukepoksi'): self.rootdir = os.path.abspath(os.path.expandvars(os.path.expanduser(rootdir))) self.db = pymongo.Connection()[dbname] self.f_id = [] self.d_id = [] self.logger = Logger() #for t in self.db.tracks.find(): #self.ids.append(t['_id']) def _insert(self, collection, entry): entry.update(entry_id = len(self.ids)) try: oid = self.db[collection].insert(entry) print 'DEBUG: Inserted entry %s into collection %s' % (entry, collection) self.ids.append(oid) except pymongo.errors.InvalidStringData: pass def _file_entry(self, path): assert os.path.isfile(path) filedir = os.path.dirname(path) filename = os.path.basename(path) filetype = os.path.splitext(filename)[1] entry = { 'f_id' : len(self.f_id), 'fpath' : path, 'fname' : filename, 'ftype' : filetype } try: f = mutagen.File(path, easy=True) except: f = None if f: fileinfo = { 'album' : f.tags.get('album'), 'artist' : f.tags.get('artist'), 'bitrate' : getattr(f.info, 'bitrate', 0), 'description' : f.tags.get('description'), 'genre' : f.tags.get('genre'), 'length' : getattr(f.info, 'length', 0.0), 'mtime' : mtime(path), 'title' : f.tags.get('title'), 'tracknumber' : f.tags.get('tracknumber') } entry.update(fileinfo) return entry def _dir_entry(self, path, dirs, files): assert os.path.isdir(path) entry = { 'd_id' : len(self.d_id), 'dname' : path, 'dirs' : dirs, 'files' : files, 'mtime' : mtime(path) } return entry def _insert_file(self, path): assert os.path.isfile(path) self.logger.inc() self.logger.log('Adding file: %s ... ' % (path), newline=False) f_entry = self._file_entry(path) try: f_oid = self.db.files.insert(f_entry) self.f_id.append(f_oid) self.logger.log('Done') except InvalidStringData: self.logger.log('ERROR, paskaa') f_oid = None finally: self.logger.dec() return f_oid def _insert_dir(self, dirname): assert os.path.isdir(dirname) self.logger.inc() self.logger.log('Entering dir: %s' % (dirname)) files = [] dirs = [] for fname in os.listdir(dirname): path = os.path.join(dirname, fname) if os.path.isfile(path): if is_supported(path): f_oid = self._insert_file(path) if f_oid: files.append(f_oid) elif os.path.isdir(path): d_oid = self._insert_dir(path) if d_oid: self.d_id.append(d_oid) dirs.append(d_oid) d_entry = self._dir_entry(dirname, dirs, files) d_oid = self.db.dirs.insert(d_entry) self.logger.log('Leaving dir: %s' % (dirname)) self.logger.dec() return d_oid def update(self): self.logger.inc() self.logger.log('Starting database update') self.db.files.drop() self.db.dirs.drop() self._insert_dir(self.rootdir) self.logger.log('Database update done') self.logger.dec() def open(self, f_id): f_oid = self.f_id[f_id] ffile = self.db.files.find_one(f_oid) print 'DEBUG: Opening file: %s' % (ffile['fpath']) return audiofile(ffile['fpath'].encode('utf-8'))
def kill(self) -> None: for servo in MANIP_SERVOS.values(): servo.angle = None Logger.log("Manipulator Servos Successfully Killed")
from tools import Logger from tools.network import Client, Server from gui import GUI from traceback import format_exc import cv2 # Debug Tools purgeLogs = True def initialize(): Logger.createNewLog(purgeLogs) # GUI already initialized on import resolution Client.startClient() Server.startServer() # ControllerClient.startControllerForwarding() Logger.log("DriverStation initialized") initialize() try: while True: # always update GUI (prevent OS from thinking program has stalled) GUI.rootWindow.update() GUI.updateWidgets() except: Logger.logError(format_exc()[0:-1]) finally: Logger.log("Shutting down")