def main():
# Download the data.
download_and_extract_cola()
config = Config()
metagraph = Metagraph(config)
dendrite = Dendrite(config, metagraph)
neuron = Neuron(config, dendrite)
neuron.start()
def tear_down(_config, _dendrite, _neuron):
logger.debug('tear down.')
_neuron.stop()
del _neuron
del _dendrite
del _config
try:
logger.info('Begin wait on main...')
while True:
logger.debug('heartbeat')
time.sleep(100)
except KeyboardInterrupt:
logger.debug('Neuron stopped with keyboard interrupt.')
tear_down(config, dendrite, neuron)
except Exception as e:
logger.error('Neuron stopped with interrupt on error: ' + str(e))
tear_down(config, dendrite, neuron)
def main():
config = Config()
metagraph = Metagraph(config)
dendrite = Dendrite(config, metagraph)
nucleus = Nucleus(config)
neuron = Neuron(config, dendrite, nucleus, metagraph)
neuron.serve()
# Start timed calls.
tl = Timeloop()
set_timed_loops(tl, config, neuron, metagraph)
tl.start(block=False)
logger.info('Started Timers.')
def tear_down(_config, _neuron, _dendrite, _nucleus, _metagraph):
logger.debug('tear down.')
del _neuron
del _dendrite
del _nucleus
del _metagraph
del _config
try:
logger.info('Begin wait on main...')
while True:
logger.debug('heartbeat')
time.sleep(100)
except KeyboardInterrupt:
logger.debug('Neuron stopped with keyboard interrupt.')
tear_down(config, neuron, dendrite, nucleus, metagraph)
except Exception as e:
logger.error('Neuron stopped with interrupt on error: ' + str(e))
tear_down(config, neuron, dendrite, nucleus, metagraph)
def main(hparams):
metagraph = Metagraph(hparams)
modelfn = Modelfn(hparams)
nucleus = Nucleus(hparams, modelfn)
dendrite = Dendrite(hparams, metagraph)
dataset = Dataset(hparams)
neuron = Neuron(hparams, nucleus, dendrite, dataset)
synapse = Synapse(hparams, neuron, metagraph)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
bittensor_grpc.add_BittensorServicer_to_server(synapse, server)
server.add_insecure_port(hparams.bind_address + ":" + hparams.port)
server.start()
neuron.start_training()
tl = Timeloop()
set_timed_loops(tl, hparams, neuron)
tl.start(block=False)
logger.info('Started Timers.')
try:
logger.info('Begin wait on main...')
while True:
logger.debug('heartbeat')
time.sleep(100)
except KeyboardInterrupt:
logger.debug('Neuron stopped with keyboard interrupt.')
server.stop(2)
del neuron
del metagraph
del synapse
except Exception as e:
logger.error('Neuron stopped with interrupt on error: ' + str(e))
server.stop(2)
del neuron
del metagraph
def serve():
# TODO(const) Use Hparams and FLAGS like in ARC nets.
config = Config()
logger.debug(config)
# The metagrpah manages the global network state.
metagraph = Metagraph(config)
# The dendrite manages our connections to 'upstream' nodes.
dendrite = Dendrite(config, metagraph)
# The nucleus trains the NN object.
nucleus = Nucleus(config, metagraph, dendrite)
# The synapse manages our connection to downstream nodes.
synapse = BoltServicer(config, metagraph)
logger.info('Started Synapse.')
# Start the Nucleus.
nucleus.start()
logger.info('Started Nucleus.')
# Start timed calls.
tl = Timeloop()
set_timed_loops(tl, metagraph, nucleus, synapse, dendrite)
tl.start(block=False)
logger.info('Started Timers.')
# Serve the synapse on a grpc server.
server_address = config.bind_address + ":" + config.port
grpc_server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
bittensor.proto.bittensor_pb2_grpc.add_BittensorServicer_to_server(
synapse, grpc_server)
grpc_server.add_insecure_port(server_address)
logger.debug('Served synapse on: {}.', server_address)
grpc_server.start()
def tear_down(_server, _nucleus, _metagraph, _dendrite, _synapse):
_server.stop(0)
_nucleus.stop()
del _metagraph
del _dendrite
del _nucleus
del _synapse
try:
logger.info('Begin wait on main...')
while True:
# NOTE(const): Matplotib must run in the main thread.
image_buffer = visualization.generate_edge_weight_buffer(
metagraph.nodes)
nucleus.update_metagraph_summary(image_buffer)
logger.info('Updated metagraph image.')
time.sleep(30)
except KeyboardInterrupt:
logger.debug('keyboard interrupt.')
tear_down(grpc_server, nucleus, metagraph, dendrite, synapse)
except:
logger.error('unknown interrupt.')
tear_down(grpc_server, nucleus, metagraph, dendrite, synapse)
####
# Connect button on port D5 of grovepi
# connect relay of the dendrite on port D3 of grovepi
# program waits for a buton press
# if button is pressed it tries to turn the dendrite on
# if the denrite is in recovered state, it gets turned on and plant bows down
####
from dendrite import Dendrite
from cloudmesh.pi import Button
import time
dendrite = Dendrite(3, recovery_time=10, max_on_time=2.5)
b = Button(5)
pressed = 0
while True:
print "\n\n--- Waitig for button press ---"
val = 0
while not pressed:
val = b.get()
pressed = val
if val:
dendrite.on()
pressed = 0
time.sleep(1)
import paho.mqtt.client as mqtt
import time
from cloudmesh.pi import Button
from cloudmesh.pi import GroveRelay
from dendrite import Dendrite
dendrites = []
for i in range(2, 4):
d = Dendrite(pin=2 * i, recovery_time=1, max_on_time=5)
dendrites.append(d)
#dict = {"ON":1, "OFF":0}
def on_connect(client, user_data, flags, rc):
client.subscribe("topic/dendrite/respond2")
if rc == 0:
print "connected OK"
else:
print "error connecting to server"
def on_log(client, userdata, level, buff):
print "log : ", buff
def on_disconnect(client, user_data, flags, rc=0):
print "disconnected with code :", rc
radius = 1e-6
Rl = 0.352
rm = Rm / (2 * np.pi * radius)
cm = Cm * 2 * np.pi * radius
rl = Rl / (np.pi * radius**2)
x = np.linspace(0, 1, m)
def InitialCondition(x, x0=0.1, sigma=0.07):
return np.exp(-(x - x0)**2 / (2 * sigma**2))
# return np.zeros(np.shape(x))
dendrite = Dendrite(dt, m)
# dendrite.SetInitialCondition(InitialCondition(x),D*2,drift)
dendrite.SetInitialCondition(InitialCondition(x), D, drift)
for i in xrange(n_spines):
dendrite.AddSpine(drift=0.1)
dat_spine = Spine(4)
dat_spine.AddSpike()
"""
for i in xrange(50):
dat_spine.Solve()
outfile = open('RW_verify_%03d.txt'%i,'w')
outfile.write('%d\n'%len(dat_spine.Ions))
for j in xrange(len(dat_spine.Ions)):
pos = dat_spine.Ions[j].r
outfile.write('%g %g \n'%(pos[0],pos[1]))