def read_output(self, settings):
# output_file = open(self.output_dir + "/output/banjo/top.graph.txt", 'r')
output_file = open(self.output_dir + "./output/banjo/top.graph.txt", "r")
import re
network = []
for i in range(len(self.gene_list)):
row = []
for j in range(len(self.gene_list)):
row.append(0)
network.append(row)
lines = output_file.readlines()
for i, line in enumerate(lines):
line = line.strip()
if line != "" and line[0] == '"':
line = re.sub(r"\(.*?\)", "", line).replace('"', "").replace(";", "").strip().replace("->", "")
# print line
ls = line.split()
edge = ls[1]
gene = ls[0]
network[int(gene)][int(edge)] = 1
network[int(edge)][int(gene)] = 1
net = Network()
net.read_netmatrix(network, self.gene_list)
self.network = net
def l4_sendto(node, dest_nid, data):
# get port table for this node and set values for destination target
PortTable = node.GetPortTable()
for link in PortTable:
info = PortTable[link]
if info[0] == dest_nid:
dest_port = info[2]
# get md5 hash of data for checksum
m = hashlib.md5()
m.update(data)
checksum = m.hexdigest()
# build datagram
frame = {}
frame['source_nid'] = node.GetNID()
frame['source_port'] = node.GetPort()
frame['destination_nid'] = dest_nid
frame['destination_port'] = dest_port
frame['sequence_number'] = 1
frame['ack_number'] = 1
frame['window_size'] = 15
frame['checksum'] = checksum
frame['data'] = data
# encode payload
payload = json.dumps(frame)
Network.l3_sendto(node, dest_nid, payload)
def read_output(self,settings):
# Code to write for collecting the output files from the algorithm, writes to the
# output list in the object
# What we want to do here is get the prediction rate on the last time
# point and the network so we can compare it against a gold std.
# This file is a bunch of zscores, so we have to load the cutoff we want
output_file = open(self.output_dir + "/output/ranked_edges.txt", 'r')
topn = None
if "top_n_edges" in settings["genie3"].keys():
topn = settings["genie3"]["top_n_edges"]
else:
topn = len(self.gene_list)
zscores = []
for line in output_file:
gene1, gene2, zscore = line.split()
zscore = float(zscore)
zscores.append((gene1, gene2, zscore))
zscores = sorted(zscores, key=lambda zscore: abs(zscore[2]), reverse=True)
self.zscores = zscores[:]
network = []
#for i,zscore in enumerate(zscores):
#if i < topn:
#gene1, gene2, zscore = zscore
#zscores[i] = (gene1, gene2, 1)
#else:
#gene1, gene2, zscore = zscore
#zscores[i] = (gene1, gene2, 0)
net = Network()
net.read_networklist(zscores)
net.gene_list = self.gene_list
self.network = net
return self.zscores
def launch(name):
# Game
game = Game.Game()
# Try to connect
socket = Network.connect("192.168.0.3", 8080)
Protocol.setName(socket, name)
# Thread for inputs
q = queue.Queue()
t = None
startThread(t, q)
# Main event loop
data = bytes()
while True:
# Send commands
try:
line = q.get_nowait()
interpretCommand(line, socket)
except queue.Empty:
pass
# Get order
order = Network.getOrder(socket)
try:
if order is not None:
Protocol.manageOrder(socket, order, game)
except Protocol.ByeException:
break
socket.close()
def memberVarience(population, alpha):
diffSum = 0.0
for member in population:
mg = Network.vectorizeMatrix(member.genome)
ag = Network.vectorizeMatrix(alpha.genome)
diffSum = diffSum + Network.outputError(mg, ag)
return diffSum / len(population)
def getRooms(self):
if (self.ipResidence == None):
self.ipResidence = util.getResidenceIp()
if (self.ipResidence != "Residence is offline"):
tmp = util.httpGetRequest(self.ipResidence, 5432,"getRooms")
self.rooms = json.loads(tmp).keys()
else:
self.ipResidence = None
def run(self):
"""Método que roda as funções bloqueantes da classe Servidor Bluetooth
"""
while True:
self.serverBlue.waitRequisition()
self.room = self.serverBlue.receiveInformation()
print("passei")
params = {"nameRoom": self.room}
util.httpPostRequest(self.ipResidence, 5432, "setRoomOfControl", params)
def handle_help(command):
mainString = "Try out the website! {}\n(Password: "******")"
try:
return mainString.format(Network.getIPAddress())
except RuntimeError:
IP = Network.readIPFile()
if IP:
return mainString.format(Network.readIPFile() + " (hopefully...)")
return mainString.format("I have no idea what it is, but it probably exists! (Go yell at Daniel)")
def read_output(self, settings):
# Code to write for collecting the output files from the algorithm, writes to the
# output list in the object
# What we want to do here is get the prediction rate on the last time
# point and the network so we can compare it against a gold std.
output_file = self.output_dir + "/output/" + "/nir_output.txt"
net = Network()
net.read_netmatrix_file(output_file, self.gene_list)
self.network = net
def testUpdate():
input = [0.35,0.9]
MyNetwork = Network( (2,2,1) )
MyNetwork.layers[0].nodes = np.array(input)
MyNetwork.layers[1].weights = np.array([ [0.1,0.8],[0.4,0.6] ])
MyNetwork.layers[2].weights = np.array([ [0.3,0.9] ])
MyNetwork.update()
def exit(self):
"""Método que encerra a conexão com Residência
"""
params = {"nameRoom": self.room.getName()}
try:
print util.httpPostRequest(self.ipResidence, 5432, "removeRoom", params)
except AttributeError:
print "Parametros insuficientes"
cherrypy.engine.exit()
os._exit(0)
def sendMsg(self, to_nick, format, *args):
#sends a message to a nick as this client
#eventually, will use the client's preferred notification method, for now it's PRIVMSGs
#Network.sendMsg(IRCMessage(":", self.nick, "PRIVMSG", to_nick, format % args))
if(isinstance(format, types.StringTypes)):
text=format % args
else:
text=format
for line in IRCMessage.wrapText(text):
Network.sendMsg(IRCMessage(":", self.nick, "PRIVMSG", to_nick, line))
def testHandshake(self):
s = TestServer()
c = TestConnection()
c.connect("localhost")
c.sendPacket("moikka")
Network.communicate(100)
client = s.clients.values()[0]
assert client.packet == "moikka"
assert client.id == 1
def read_output(self,settings):
# Code to write for collecting the output files from the algorithm, writes to the
# output list in the object
# What we want to do here is get the prediction rate on the last time
# point and the network so we can compare it against a gold std.
# This file is a bunch of zscores, so we have to load the cutoff we want
output_file = self.output_dir + "/output/inferelator_output.csv"
net = Network()
net.read_netmatrix_file(output_file, self.gene_list)
self.network = net
return self.network
def powerEquipmentsNewRoom(self, roomConfiguration, nameRoom):
"""Método que liga os equipamentos do novo cômodo
:Param data: Dicionário contendo os aparelhos e os comandos
:Type data: Dicionário
:Param nameRoom: Nome do novo cômodo
:Type nameRoom: String
"""
infoRoom = self.__searchRoom(nameRoom.lower())
ip = infoRoom[0]
port = infoRoom[1]
params = {"configuration": str(roomConfiguration)}
method = "setNewConfiguration"
util.httpPostRequest(ip, port, method, params)
def run(self, name, datafiles, goldnet_file):
import numpy
os.chdir(os.environ["gene_path"])
datastore = ReadData(datafiles[0], "steadystate")
for file in datafiles[1:]:
datastore.combine(ReadData(file, "steadystate"))
datastore.normalize()
settings = {}
settings = ReadConfig(settings)
# TODO: CHANGE ME
settings["global"]["working_dir"] = os.getcwd() + '/'
# Setup job manager
print "Starting new job manager"
jobman = JobManager(settings)
# Make GENIE3 jobs
genie3 = GENIE3()
genie3.setup(datastore, settings, name)
print "Queuing job..."
jobman.queueJob(genie3)
print jobman.queue
print "Running queue..."
jobman.runQueue()
jobman.waitToClear()
print "Queue finished"
job = jobman.finished[0]
print job.alg.gene_list
print job.alg.read_output(settings)
jobnet = job.alg.network
print "PREDICTED NETWORK:"
print job.alg.network.network
print jobnet.original_network
if goldnet_file != None:
goldnet = Network()
goldnet.read_goldstd(goldnet_file)
print "GOLD NETWORK:"
print goldnet.network
print jobnet.analyzeMotifs(goldnet).ToString()
print jobnet.calculateAccuracy(goldnet)
return jobnet.original_network
def create_empty_network():
"""
Args:
None
Returns:
hidden_layers: list of Neuron object lists representing the hidden layers
output_layer: list of Neuron objects representing the output layer
Notes:
"""
hidden_layers = []
for item in range(const.NUM_HIDDEN_LAYERS):
hidden_layers.append(Network.make_hidden_layer())
output_layer = Network.make_output_layer()
return hidden_layers, output_layer
def __init__(self,speed=None,health=None,max_health=None,dmg=None,armor=None,size=None,brain=None,name="Yuval",location=None,turns=0):
if speed == None:
speed = attribute()
if health == None:
health = attribute()
if max_health == None:
max_health = attribute()
if dmg == None:
dmg = attribute()
if armor == None:
armor = attribute()
if size == None:
size = attribute()
if location == None:
location = [400,400]
self.location = location
if brain == None:
brain = [3,2,3]
brain1 = Network.network(brain)
self.brain = brain1
self.speed = speed
self.health = health
self.max_health = max_health
self.dmg = dmg
self.armor = armor
self.size = size
self.name = name
self.speed.value = 20
self.turns = turns
def search_by_tvrage_string(self):
"""
Search using TVRage's search API, with a string show name input.
If it matches exactly (ignoring hyphens), then consider it a 100% match.
Otherwise, score each potential match starting from the start_score.
"""
for show_name in self.show_names:
url = tvrage.SEARCH_URL % String.Quote(show_name, True)
xml = Network.fetch_xml(url)
i = 0
for show_xml in xml.xpath("//show"):
i += 1
result_show = str(show_xml.xpath("./name")[0].text)
if tvrage.sanitize_show_name(show_name) == tvrage.sanitize_show_name(result_show):
Log("Found exact match in title %s" % result_show)
score = 100
else:
score = self.start_score - i
nextResult = MetadataSearchResult(id=str(show_xml.xpath("./showid")[0].text),
name=result_show,
year=show_xml.xpath("./started")[0].text,
score=score,
lang=self.lang)
self.results.Append(nextResult)
Log(repr(nextResult))
def testBackprop2():
input = [1,0,1,0]
MyNetwork = Network( (4,3,2) )
MyNetwork.layers[0].nodes = np.array(input)
MyNetwork.layers[1].weights = np.array([ [0.1,0.8],[0.4,0.6] ])
MyNetwork.layers[2].weights = np.array([ [0.3,0.9] ])
print MyNetwork.update()
for i in xrange(500):
MyNetwork.backprop([0.5])
MyNetwork.update()
print MyNetwork.update()
def tryConnect():
global IsConnected
try:
networkCheckCount = 0
while (
Network.isConnected() == False and networkCheckCount < 5
): # we check a number of times to give the network more time to start up.
networkCheckCount = networkCheckCount + 1
sleep(2)
if Network.isConnected() == False:
logging.error("failed to set up network connection")
else:
# make certain that the device & it's features are defined in the cloudapp
IOT.connect()
# IOT.addAsset(TempSensorPin, TempSensorName, "temperature", False, "number", "Secondary")
# IOT.addAsset(WaterLevelSensorPin, WaterLevelSensorName, "Water level", False, "number", "Secondary")
IOT.addAsset(LightsRelaisPin, LightsRelaisName, "Turn the lights on/off", True, "boolean", "Primary")
IOT.addAsset(WaterRelaisPin, WaterRelaisName, "Turn the water flow on/off", True, "boolean", "Primary")
IOT.addAsset(
ConfigSeasonId,
ConfigSeasonName,
"Configure the season",
True,
"{'type': 'string','enum': ['grow', 'flower']}",
"Config",
)
try:
season = IOT.getAssetState(ConfigSeasonId)
except:
logging.exception("failed to get asset state")
LoadConfig(
season
) # load the cloud settings into the appbefore closing the http connection. otherwise this call fails.
IOT.subscribe() # starts the bi-directional communication
sleep(
2
) # wait 2 seconds until the subscription has succeeded (bit of a hack, better would be to use the callback)
IsConnected = True
IOT.send(
str(LightRelaisState).lower(), LightsRelaisPin
) # provide feedback to the platform of the current state of the light (after startup), this failed while loading config, cause mqtt is not yet set up.
IOT.send(str(WaterRelaisState).lower(), WaterRelaisPin)
except:
logging.exception("failed to set up the connection with the cloud")
IsConnected = False
def avgSigma(population):
sigSum = 0.0
sigCount = 0
for member in population:
ms = Network.vectorizeMatrix(member.sigmas)
for singleSigma in ms:
sigSum = sigSum + singleSigma
sigCount = sigCount + 1
return sigSum / sigCount
def introduce(self): svr=Server.getLinkedServer() msg=None if(svr.protoctl["NICKv2"]): if(svr.protoctl["CLK"]): #NICKv2 and CLK if(svr.protoctl["NICKIP"]): #NICKv2 and CLK and NICKIP msg=IRCMessage(None, None, "nick", self.nick, self.hopcount, self.timestamp, self.username, self.hostname, self.server, self.servicestamp, self.usermodes, self.virtualhost, self.cloakedhost, self.nickipaddr, self.realname) else: #NICKv2 and CLK msg=IRCMessage(None, None, "nick", self.nick, self.hopcount, self.timestamp, self.username, self.hostname, self.server, self.servicestamp, self.usermodes, self.virtualhost, self.cloakedhost, self.realname) else: #NICKv2 but not CLK if(svr.protoctl["NICKIP"]): #NICKv2 and NICKIP msg=IRCMessage(None, None, "nick", self.nick, self.hopcount, self.timestamp, self.username, self.hostname, self.server, self.servicestamp, self.usermodes, self.virtualhost, self.nickipaddr, self.realname) else: #nickv2, no clk, no nickip msg=IRCMessage(None, None, "nick", self.nick, self.hopcount, self.timestamp, self.username, self.hostname, self.server, self.servicestamp, self.usermodes, self.virtualhost, self.realname) else: #normal msg=IRCMessage(None, None, "nick", self.nick, self.hopcount, self.timestamp, self.username, self.hostname, self.server, self.servicestamp, self.realname) Network.sendMsg(msg)
def read_output(self,settings):
import scipy
# Code to write for collecting the output files from the algorithm, writes to the
# output list in the object
# What we want to do here is get the prediction rate on the last time
# point and the network so we can compare it against a gold std.
# This file is a bunch of zscores, so we have to load the cutoff we want
co_output = scipy.io.loadmat(self.output_dir + "/output/" + \
"/convex_optimization_output.mat")
self.raw_network = co_output["A"].tolist()
net = Network()
net.read_netmatrix(self.raw_network, self.gene_list)
self.network = net
return self.network
def notificaComodoControle(self, nameRoom, status):
"""Método que notifica ao cômodo se o controle se encontra ou não dentro dele
:Param nameRoom: Nome do cômodo
:Type nameRoom: String
:Param status: String do boolean correspondente a sua presença
:Type status: String
"""
infoRoom = self.__searchRoom(nameRoom.lower())
print("Passandoo 1")
if(infoRoom != False):
ip = infoRoom[0]
port = infoRoom[1]
print("Passandoo 2")
params = {"isFound" : status}
method = "controlIsFound"
print("Passandoo 3")
util.httpPostRequest(ip, port, method, params)
def exchange(self):
""" This is the main method, is where the individuals
are exchanged """
if not self.isReady():
return
# Client section --------------------------------------
# How many will migrate ?
pool = self.selectPool(self.getNumIndividuals())
for individual in pool:
# (code, group name, individual)
networkObject = (Consts.CDefNetworkIndividual,
self.getGroupName(), individual)
networkData = Network.pickleAndCompress(
networkObject, self.getCompressionLevel())
# Send the individuals to the topology
self.clientThread.addData(networkData)
# Server section --------------------------------------
pool = []
while self.serverThread.isReady():
# (IP source, data)
networkData = self.serverThread.popPool()
networkObject = Network.unpickleAndDecompress(networkData[1])
# (code, group name, individual)
pool.append(networkObject)
# No individuals received
if len(pool) <= 0:
return
population = self.GAEngine.getPopulation()
for i in xrange(self.getNumReplacement()):
if len(pool) <= 0:
break
choice = rand_choice(pool)
pool.remove(choice)
# replace the worst
population[len(population) - 1 - i] = choice[2]
def groupDailyDuties():
log.group("Starting daily duties!")
for group in getGroupList(MainGroup): #Go through all the MainGroups to check for events that have ended
group.checkForEndedEvents()
if Network.hasIPChanged():
log.group("IP has changed! Updating bots of all groups")
for group in getGroupList():
if group.bot:
group.handler.updateBots(group.bot)
def powerOffEquipmentsRoom(self):
"""Método que desliga todos os equipamentos do cômodo
"""
for roomTemp in self.rooms.items():
print("---------------------------------", roomTemp)
nameRoomTemp = roomTemp[0]
ipRoomTemp = roomTemp[1][0]
portRoomTemp = roomTemp[1][1]
method = "getNumberOfPeoples"
result = util.httpGetRequest(ipRoomTemp, portRoomTemp, method)
if(result == False):
self.removeRoom(nameRoomTemp)
elif(result == "0"):
params = {"equipment": "all", "command": "poweroff"}
method = "controlEquipment"
util.httpPostRequest(ipRoomTemp, portRoomTemp, method, params)
time.sleep(15)
self.powerOffEquipmentsRoom()
def startThreadResidence(self):
self.pbar.show()
self.residenceButton.set_sensitive(False)
self.pbar.set_text("Iniciando residência")
status = util.getResidenceIp()
self.pbar.hide()
self.clickedResidence = True
if (status == "Residence is offline"):
self.residenceButton.set_label("Residência iniciada")
os.system("python " + os.path.abspath("Residencia/server.py"))
else:
self.residenceButton.set_label("Residência iniciada na rede")
def read_output(self,settings):
# Code to write for collecting the output files from the algorithm, writes to the
# output list in the object
# What we want to do here is get the prediction rate on the last time
# point and the network so we can compare it against a gold std.
# This file is a bunch of zscores, so we have to load the cutoff we want
output_file = open(self.output_dir + "/output/mcz_output.txt", 'r')
output_file = output_file.readlines()
zscores = []
for g1, line in enumerate(output_file[1:]):
for g2, val in enumerate(line.split('\t')[1:]):
zscores.append((self.gene_list[g2], self.gene_list[g1], float(line.split()[1:][g2])))
topn = settings["mcz"]["top_n_edges"]
#for line in output_file:
#gene1, gene2, zscore = line.split()
#zscore = float(zscore)
#zscores.append((gene1, gene2, zscore))
zscores = sorted(zscores, key=lambda zscore: abs(zscore[2]), reverse=True)
self.zscores = zscores[:]
network = []
#for i,zscore in enumerate(zscores):
#if i < topn:
#gene1, gene2, zscore = zscore
#if zscore > 0:
#zscores[i] = (gene1, gene2, 1)
#if zscore < 0:
#zscores[i] = (gene1, gene2, -1)
#else:
#gene1, gene2, zscore = zscore
#zscores[i] = (gene1, gene2, 0)
net = Network()
net.read_networklist(zscores)
net.gene_list = self.gene_list
self.network = net
return self.network
def ewc_train(network,
optimizer,
dataset,
loader,
ewc,
lam,
num_epochs,
type="ewc",
test=None):
for epoch in range(num_epochs):
total_loss = 0
total_correct = 0
for batch in loader:
images, labels = batch
preds = network(images)
loss1 = F.cross_entropy(preds, labels)
if type == "L2":
loss2 = lam * ewc.penalty_l2(network)
else:
loss2 = lam * ewc.penalty_ewc(network)
loss = loss1 + loss2
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_loss += loss.item()
total_correct += Network.get_num_correct(preds, labels)
accuracy = (total_correct / len(dataset)) * 100
print(
f'epoch: {epoch}, loss: {total_loss}, total_correct: {total_correct} / {len(dataset)}, --> {Fore.LIGHTCYAN_EX}Accuracy: {accuracy}{Style.RESET_ALL}'
)
#test is for printing epoch accuracies of past tasks
if test is not None:
for t in test:
print(
f"\t\t\t\t {Fore.LIGHTGREEN_EX}Testing back... {Network.testing(network, t[0], t[1])}{Style.RESET_ALL}"
)
def __init__(self):
super(Window, self).__init__()
self.screen = self.get_screen()
self.set_accept_focus(False)
self.set_type_hint(Gdk.WindowTypeHint.DESKTOP)
self.override_background_color(Gtk.StateType.NORMAL,
Gdk.RGBA(0, 0, 0, 1))
self.overlay = Gtk.Overlay()
self.image = Gtk.Image()
self.overlay.add(self.image)
self.add(self.overlay)
self.headerbar = Gtk.HeaderBar()
self.headerbar.set_valign(Gtk.Align.END)
self.headerbar.set_halign(Gtk.Align.FILL)
style = self.headerbar.get_style_context()
style.add_class("frame")
style.add_class("action-bar")
self.headerbar.pack_start(GnoMenu.Button())
self.headerbar.pack_start(Gtk.Separator.new(Gtk.Orientation.VERTICAL))
self.headerbar.pack_end(Session.Button())
self.headerbar.pack_end(Gtk.Separator.new(Gtk.Orientation.VERTICAL))
self.headerbar.pack_end(Sound.Button())
self.headerbar.pack_end(Network.Button())
self.overlay.add_overlay(self.headerbar)
self.move(0, 0)
self.resize_to_geometry(self.screen.get_width(),
self.screen.get_height())
self.show_all()
try:
self.update_strut()
except:
pass
try:
self.update_background()
except:
pass
GObject.timeout_add(100, self.update_clock)
def main():
global args
global best_acc
best_acc = 0
args = parse_arguments()
transfrom = get_transform()
train_dataset = Dataset.TrackData_SL(args.train_data, transfrom)
test_dataset = Dataset.TrackData_SL(args.test_data, transfrom)
train_loader = DataLoader(train_dataset,
num_workers=args.num_workers,
shuffle=True,
batch_size=args.batch_size)
test_loader = DataLoader(test_dataset,
num_workers=args.num_workers,
shuffle=False,
batch_size=args.batch_size)
net = Network.Tracknet()
net.cuda()
optimizer = torch.optim.Adam(net.parameters(), args.lr)
start_epoch = 0
if args.resume:
if args.resume:
ckpt = torch.load(args.resume)
net.load_state_dict(ckpt['state_dict'])
optimizer.load_state_dict(ckpt['optimizer'])
best_acc = ckpt['best_accuracy']
start_epoch = ckpt['epoch']
for e in range(start_epoch, args.max_epochs):
train(e, net, optimizer, train_loader)
if e % args.test_freq == 0:
acc = test(e, net, test_loader)
is_best = acc > best_acc
best_acc = max(best_acc, acc)
# save model
save_checkpoint(
{
'epoch': e + 1,
'state_dict': net.state_dict(),
'best_accuracy': best_acc,
'optimizer': optimizer.state_dict()
}, is_best)
def __init__(self):
logging.basicConfig(format="%(levelname)s (%(asctime)s): %(message)s", datefmt="%I:%M:%S %p", level=logging.INFO, filename="/var/tmp/R2D2.log")
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
atexit.register(self.Exit)
self.MCP3008 = MCP3008(spi=SPI.SpiDev(0, 0))
self.Voltage = VoltageDivider(self.MCP3008, 0, 984.0, 101.0)
self.Current = ACS711EX(self.MCP3008, 1)
self.BrightnessControl = Potentiometer(self.MCP3008, 2)
self.Battery = LiPo(self.Voltage, self.Current, 6, 10)
self.DomeLightsRelay = self.Relay1 = Relay(16)
self.DomeServosRelay = self.Relay2 = Relay(17)
self.DomeMotorRelay = self.Relay3 = Relay(18)
self.Relay4 = Relay(19)
self.Relay5 = Relay(20)
self.SoundRelay = self.Relay6 = Relay(21)
self.BodyServosRelay = self.Relay7 = Relay(22)
self.BodyLightsRelay = self.Relay8 = Relay(23)
self.Relay9 = Relay(24)
self.Relay10 = Relay(25)
self.Relay11 = Relay(26)
self.Relay12 = Relay(27)
self.Network = Network()
self.Head = HeadMotor(self.DomeMotorRelay)
self.Sound = Sound()
self.StatusDisplay = StatusDisplay(self)
self.FrontLogicDisplay = FrontLogicDisplay(self.DomeLightsRelay)
self.RearLogicDisplay = RearLogicDisplay(self.DomeLightsRelay)
self.FrontProcessStateIndicator = FrontProcessStateIndicator(self.DomeLightsRelay)
self.RearProcessStateIndicator = RearProcessStateIndicator(self.DomeLightsRelay)
self.FrontHoloProjector = FrontHoloProjector(self.DomeLightsRelay)
self.TopHoloProjector = TopHoloProjector(self.DomeLightsRelay)
self.RearHoloProjector = RearHoloProjector(self.DomeLightsRelay)
self.MagicPanel = MagicPanel(self.DomeLightsRelay)
self.LifeFormScanner = LifeFormScanner(self.DomeServosRelay)
self.DomePanels = Panels()
self.BodyServos = Maestro("00126418")
self.LeftUtilityArm = MaestroServo(self.BodyServos, 16, 2390, 1520, 20, 1)
self.RightUtilityArm = MaestroServo(self.BodyServos, 17, 2390, 1520, 20, 1)
def __init__(self,rng, max_hidden_units, size=50, limittup=(-1,1)):
self.dimtup = pimadataf.get_dimension()
rest_set, test_set = pimadataf.give_data()
tup = pimadataf.give_datainshared()
self.rng=rng
self.size = size
self.max_hidden_units = max_hidden_units
self.list_chromo = self.aux_pop(size, limittup) #a numpy array
self.fits_pops = []
self.trainx = rest_set[0]
self.trainy = rest_set[1]
self.testx = test_set[0]
self.testy = test_set[1]
self.strainx, self.strainy = tup[0]
self.stestx, self.stesty = tup[1]
self.net_err = Network.Neterr(inputdim=self.dimtup[0], outputdim=self.dimtup[1], arr_of_net=self.list_chromo, trainx=self.trainx, trainy=self.trainy, testx=self.testx, testy=self.testy,strainx=self.strainx, strainy=self.strainy, stestx=self.stestx, stesty=self.stesty)
self.net_dict={} #dictionary of networks for back-propagation, one for each n_hid
def Build_network(session, robot_num):
'''
Network_set = []
for i in range(robot_num - 1):
Network_set.append(Network.three_robot_network(str(10+i+1)))
for item in Network_set:
item.restore_parameter(session, three_robot_Network_Path)
with tf.name_scope('Smallest_value'):
smaller_value_list = [Network_set[0].value]
for i in range(len(Network_set)-1):
smaller_value_list.append(tf.minimum(smaller_value_list[i], Network_set[i+1].value))
smallest_value = smaller_value_list[-1]
'''
Network_set = [Network.Three_robot_network('123')]
for item in Network_set:
item.restore_parameter(session, three_robot_Network_Path)
smallest_value = Network_set[0].value
return smallest_value, Network_set
def __init__(self,rng, max_hidden_units, size=5, limittup=(-1,1)):
self.dimtup = pimadataf.get_dimension()
rest_set, test_set = pimadataf.give_data()
restx=rest_set[0]
resty=rest_set[1]
testx=test_set[0]
testy=test_set[1]
resty=np.ravel(resty)
testy=np.ravel(testy)
self.rng=rng
self.size = size
self.max_hidden_units = max_hidden_units
self.list_chromo = self.aux_pop(size, limittup) #a numpy array
self.fits_pops = []
restn=538 #a flaw here ,one has to know no. of datapoints in both set before opening it(inside program)
testn=230
print("here you",rest_set[1].shape)
self.rest_setx=tf.Variable(initial_value=np.zeros((restn,self.dimtup[0])),name='rest_setx',dtype=tf.float64)
self.rest_sety=tf.Variable(initial_value=np.zeros((restn,)),name='rest_sety',dtype=tf.int32)
self.test_setx=tf.Variable(initial_value=np.zeros((testn,self.dimtup[0])),name='rest_sety',dtype=tf.float64)
self.test_sety=tf.Variable(initial_value=np.zeros((testn,)),name='test_sety',dtype=tf.int32)
if not os.path.isfile('/home/robita/forgit/neuro-evolution/05/state/tf/indep_pima/input/model.ckpt.meta'):
rxn=self.rest_setx.assign(restx)
ryn=self.rest_sety.assign(resty)
txn=self.test_setx.assign(testx)
tyn=self.test_sety.assign(testy)
var_lis=[self.rest_setx,self.rest_sety,self.test_setx,self.test_sety]
nodelis=[rxn,ryn,txn,tyn]
savo=tf.train.Saver(var_list=var_lis)
with tf.Session() as sess:
sess.run([i for i in nodelis])
print("saving checkpoint")
save_path = savo.save(sess, "/home/robita/forgit/neuro-evolution/05/state/tf/indep_pima/input/model.ckpt")
self.net_err = Network.Neterr(inputdim=self.dimtup[0], outputdim=self.dimtup[1], arr_of_net=self.list_chromo,rest_setx=self.rest_setx,rest_sety=self.rest_sety,test_setx=self.test_setx,test_sety=self.test_sety,rng=self.rng)
self.net_dict={} #dictionary of networks for back-propagation, one for each n_hid
def __init__(self, parent, controller):
self.controller = controller
tk.Frame.__init__(self, parent)
label = tk.Label(self, text="Create New Simulation", font=LARGE_FONT)
label.pack(pady=10, padx=10)
self.networkName = ""
self.networkType = ""
fr_networkName = tk.Frame(self, parent)
fr_networkName.pack(pady=10)
fr_networkType = tk.Frame(self, parent)
fr_networkType.pack(pady=10)
fr_buttons = tk.Frame(self, parent)
fr_buttons.pack(pady=10)
lb_networkName = tk.Label(fr_networkName,
text="Network Name: ",
anchor=tk.W)
self.tb_networkName = ttk.Entry(fr_networkName)
lb_networkType = tk.Label(fr_networkType,
text="Network Type:",
anchor=tk.W)
self.tb_networkType = ttk.Entry(fr_networkType)
bt_createNetwork = ttk.Button(
fr_buttons,
text="Create",
command=lambda: self.saveNetwork(controller))
bt_cancelNetwork = ttk.Button(
fr_buttons,
text="Cancel",
command=lambda: controller.show_frame(StartPage))
lb_networkName.grid(row=0)
self.tb_networkName.grid(row=0, column=2)
lb_networkType.grid(row=0)
self.tb_networkType.grid(row=0, column=2)
bt_createNetwork.grid(row=0)
bt_cancelNetwork.grid(row=0, column=2)
self.nw = nw.Network(self.getNetworkName(), self.getNetworkType())
def __init__(self,checkpoint_path='../checkpoint',logs_path='../logs',BATCH_SIZE=5):
self.net=Network()
self.forward=self.net.vgg #选择需要的网络
self.datasets = None
self.label = None
self.test_data = None
self.test_label = None
self.checkpoint_path = checkpoint_path
self.logs_path = logs_path
self.input_data = tf.compat.v1.placeholder(tf.float32, [None,224,224,3], name = "input_data")#定义输入
self.supervised_label = tf.compat.v1.placeholder(tf.float32, [None, 2], name = "label")#定义标签
self.BATCH_SIZE=BATCH_SIZE
self.STEPS = 10000000 #最大步数
self.LEARNING_RATE_BASE = 0.00001 # 最初学习率
self.LEARNING_RATE_DECAY = 0.99 # 学习率的衰减率
self.LEARNING_RATE_STEP = 1000 # 喂入多少轮BATCH-SIZE以后，更新一次学习率。一般为总样本数量/mini_batch
self.global_step =tf.compat.v1.train.get_or_create_global_step() #步数
self.learning_rate = tf.compat.v1.train.exponential_decay(self.LEARNING_RATE_BASE, self.global_step, self.LEARNING_RATE_STEP, self.LEARNING_RATE_DECAY, staircase=True)#学习率衰减
self.is_training = tf.compat.v1.placeholder(tf.bool, name="is_training")
def init_gui(self):
self.text_edit = QTextEdit()
self.setCentralWidget(self.text_edit)
self.statusBar()
self.network = Network.Network(X_SIZE, Y_SIZE, FUNCTION, MOMENTUM,
INPUT_NEURONS, OUTPUT_NEURONS,
HIDDEN_NEURONS)
self.progress_label = QLabel(self)
self.progress_label.move(20, 120)
self.progress_bar = QProgressBar(self)
self.progress_bar.setGeometry(20, 150, 200, 25)
self.progress_bar.hide()
open_training_file = QAction(QIcon('open.png'), 'Run train File', self)
open_training_file.setShortcut('Ctrl+T')
open_training_file.setStatusTip('Open new File')
open_training_file.triggered.connect(self.load_train_file)
open_start_value_file = QAction(QIcon('open.png'), 'Open start Values',
self)
open_start_value_file.setShortcut('Ctrl+S')
open_start_value_file.setStatusTip('Open new File')
open_start_value_file.triggered.connect(self.loadStartValues)
menu_bar = self.menuBar()
file_menu = menu_bar.addMenu('&File')
file_menu.addAction(open_training_file)
file_menu.addAction(open_start_value_file)
self.evaluate_button = QPushButton('Evaluate', self)
self.evaluate_button.move(20, 50)
self.evaluate_button.clicked.connect(self.evaluate)
self.result = QLabel(self)
self.result.setText("Result: " + str(self.network.result)[:8])
self.result.move(X_SIZE - 100, Y_SIZE - 100)
self.init_grids()
self.setGeometry(300, 300, X_SIZE, Y_SIZE)
self.setWindowTitle('Artificial Neural Network')
self.show()
def test_Two_routes_4_5_compute_shortest_path_with_weight(self):
r = Network.Network(
*["Input/RATP_GTFS_METRO_4", "Input/RATP_GTFS_METRO_5"])
time = datetime.datetime.strptime('20190321 15:25', '%Y%m%d %H:%M')
parcours, duration = r.compute_shortest_path("Château d'Eau",
"Jacques-Bonsergent",
time)
print(parcours, duration)
ref = [(2153, 'transfer', 0), (2208, '4', 1), (2076, 'transfer', 3),
(1898, '5', 5)]
# [("Château d'Eau", 'transfer', 0),
# ("Gare de l'Est (Verdun)", '4', 1),
# ("Gare de l'Est (Verdun)", 'transfer', 3),
# ('Jacques-Bonsergent', '5', 5)]
self.assertEqual(ref, parcours)
self.assertEqual(5, duration)
time = datetime.datetime.strptime('20190321 15:25', '%Y%m%d %H:%M')
parcours, duration = r.compute_shortest_path("Jacques-Bonsergent",
"Porte de Clignancourt",
time)
print(parcours, duration)
ref = [(1898, 'transfer', 0), (2294, 'transfer', 0), (2125, '5', 3),
(2208, 'transfer', 5), (2212, '4', 7), (2110, '4', 9),
(2152, '4', 10), (2535, '4', 11), (2478, '4', 12),
(2420, '4', 14), (1742, 'transfer', 14)]
# [('Jacques-Bonsergent', 'transfer', 0),
# ('Jacques-Bonsergent', 'transfer', 0),
# ("Gare de l'Est (Verdun)", '5', 3),
# ("Gare de l'Est (Verdun)", 'transfer', 5),
# ('Gare du Nord', '4', 7),
# ('Barbès-Rochechouart', '4', 9),
# ('Château Rouge', '4', 10),
# ('Marcadet-Poissonniers', '4', 11),
# ('Simplon', '4', 12),
# ('Porte de Clignancourt', '4', 14),
# ('Porte de Clignancourt', 'transfer', 14)]
self.assertEqual(ref, parcours)
self.assertEqual(14, duration)
def runOnAllStartpoints(self):
'''Runs both algorithms using, in turn, each node at the begining of a regular flow as starting point. Then average the results.'''
for i in range(self.nExp):
self.n = Network(self.n.nNodes, self.n.nFlows, self.n.nChannels,
self.n.eFork, self.n.schedulingMethod)
startpoints = [path[0] for path in self.n.H]
for node in startpoints:
SFSA = self.runSFSA(node)
OBSSA = self.runOBSSA(node)
self.schedulability[i][0] += SFSA[0]
self.nStolenFlows[i][0] += SFSA[1]
self.nStolenFlowsScheduled[i][0] += SFSA[0] * SFSA[1]
self.schedulability[i][1] += OBSSA[0]
self.nStolenFlows[i][1] += OBSSA[1]
self.nStolenFlowsScheduled[i][1] += OBSSA[0] * OBSSA[1]
# if OBSSA[0]<SFSA[0]:
# print(SFSA)
# print(OBSSA)
# print(self.n.intersections)
# for k,v in enumerate(self.n.W):
# print(k, " ", v)
for i in range(self.nExp):
if self.schedulability[i][0] != 0:
self.nStolenFlowsScheduled[i][0] = self.nStolenFlowsScheduled[
i][0] / self.schedulability[i][0]
else:
self.nStolenFlowsScheduled[i][0] = 0
if self.schedulability[i][1] != 0:
self.nStolenFlowsScheduled[i][1] = self.nStolenFlowsScheduled[
i][1] / self.schedulability[i][1]
else:
self.nStolenFlowsScheduled[i][1] = 0
self.nStolenFlowsScheduled = np.true_divide(
self.nStolenFlowsScheduled.sum(0),
(self.nStolenFlowsScheduled != 0).sum(0))
self.schedulability = np.mean(self.schedulability, 0)
self.schedulability /= (len(startpoints)
) #*(self.n.globalPeriod-self.eFlowDeadLine)
self.nStolenFlows = np.mean(self.nStolenFlows, 0)
self.nStolenFlows /= (len(startpoints)
) #*(self.n.globalPeriod-self.eFlowDeadLine)
def __init__(self, parent):
wx.Panel.__init__(self, parent)
sizer = wx.BoxSizer(wx.HORIZONTAL)
text = wx.TextCtrl(self, style = wx.TE_MULTILINE | wx.TE_READONLY)
text.AppendText(u'系统信息：\n\n')
text.AppendText(u'网络信息：\n')
text.AppendText(Network.GetInfoString());
text.Bind(wx.EVT_CHAR, self.OnChar)
sizer.Add(text, 1, wx.EXPAND)
sizer.AddSpacer(20)
button = wx.Button(self, -1, u'关于...')
sizer.Add(button, 0, flag = wx.ALIGN_RIGHT)
self.SetSizer(Util.CreateCenterSizer(sizer, 20))
self.Bind(wx.EVT_BUTTON, self.OnAbout, button)
self.keybuf = ''
def execute_generate_play(nnet_path,
multiplikator=configs.SIMS_FAKTOR,
exponent=configs.SIMS_EXPONENT):
gc.collect()
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
nnet = Network.get_net(configs.FILTERS, configs.HIDDEN_SIZE,
configs.OUT_FILTERS, configs.NUM_ACTIONS,
configs.INPUT_SIZE, None, configs.NUM_RESIDUAL)
nnet.load_weights(nnet_path)
env = MillEnv.MillEnv()
mcts_ = mcts.MonteCarloTreeSearch(
mcts.State(zeros((1, 24)), 0, -env.isPlaying, env))
stmem = mcts_.generatePlay(nnet, multiplikator, exponent)
del mcts_
del env
keras.backend.clear_session()
tf.compat.v1.reset_default_graph()
del nnet
gc.collect()
return stmem
def OnManageNetworkClick(self):
""" action - display network page
"""
if(not self.pm.installRequired()):
try:
self.network
except:
self.network = Network()
try:
self.widgets['nodes']
except:
self.widgets['nodes'] = {}
for v in self.widgets['nodes'].values():
v.grid_forget()
self.widgets['nodes'] = {}
self.listNodes()
self.scheduler.addTask('network_nodes', self.updateNodes, 5)
else:
self.open()
self.pm.addManager()
def selectAccount(accountInfos):
lostRate = []
avgTime = []
for account in accountInfos:
netinfo = Network._runping(account[0])
lostRate.append(netinfo[0])
if len(netinfo) > 1:
avgTime.append(netinfo[1])
else:
avgTime.append(sys.maxsize)
minRate = min(lostRate)
minAvgTime = sys.maxsize
minIndex = -1
for i in range(len(lostRate)):
if lostRate[i] == minRate:
if avgTime[i] < minAvgTime:
minAvgTime = avgTime[i]
minIndex = i
accountInfos[minIndex].append(minAvgTime)
return accountInfos[minIndex]
def On_PluginInit(self):
if not Plugin.IniExists("Settings"):
Plugin.CreateIni("Settings")
ini = Plugin.GetIni("Settings")
ini.AddSetting("Settings", "Command", "/say")
ini.AddSetting("Settings", "Popup time", "10")
ini.AddSetting("Allowed Ranks", "Users", "false")
ini.AddSetting("Allowed Ranks", "Moderators", "true")
ini.AddSetting("Allowed Ranks", "Admins", "true")
ini.Save()
ini = Plugin.GetIni("Settings")
DataStore.Add("BroadCast", "Timer", int(ini.GetSetting("Settings", "Popup time")) * 1000)
DataStore.Add("BroadCast", "Users", ini.GetBoolSetting("Allowed Ranks", "Users"))
DataStore.Add("BroadCast", "Mod", ini.GetBoolSetting("Allowed Ranks", "Moderators"))
DataStore.Add("BroadCast", "Admin", ini.GetBoolSetting("Allowed Ranks", "Admins"))
DataStore.Add("BroadCast", "Command", ini.GetSetting("Settings", "Command").Replace("/", ""))
command = ini.GetSetting("Settings", "Command").Replace("/", "")
Commands.Register(command).setCallback("command")
for Player in Server.ActivePlayers:
CommunityEntity.ServerInstance.ClientRPCEx(Network.SendInfo(Player.basePlayer.net.connection), None, "DestroyUI", Facepunch.ObjectList("broadcastui"))
def run(self):
"""
シミュレーション回数だけシミュレーションを実行する．
"""
try:
os.makedirs('../{}/{}'.format(self.fig_dir, self.simu_dir))
except OSError as exc:
pass
try:
os.makedirs('../{}/{}'.format(self.csv_dir, self.simu_dir))
except OSError as exc:
pass
time_start = time.time()
for n in range(self.try_num):
graph = Network.Topology(self.node, self.site, self.conn, self.prob, self.t_type)
model = Model.Model(graph)
simu = Simulator.Simulator(graph, model, self.lb_max, self.ln_max, self.sig_max, self.sig_div, self.vm_add)
fname = '../{}/{}/{}-割当前.svg'.format(self.fig_dir, self.simu_dir, n + 1)
fname_a = '../{}/{}/{}-割当後.svg'.format(self.fig_dir, self.simu_dir, n + 1)
print ''
print '<{}回目>'.format(n + 1)
graph.generate_images(filename=fname, first=True)
for i in range(self.vm_add):
simu.solve(info=True)
graph.generate_images(filename=fname_a, first=False, costList=simu.x_sig)
print'[Site]',
for k in simu.vm_num:
print '{0:2d}:{1:2d}, '.format(k, simu.vm_num[k]),
print ''
self.make_data(simu, n)
self.make_csv()
print '[Time of simulation] : {}'.format(time.time() - time_start)
def classifier(nn_params, log, exp, train_path, val_path, test_path,
save_logs):
# create model and train it
model = Network.CNN(nn_params)
if nn_params["load_model"] is not None:
with open(nn_params["load_model"], 'rb') as pickle_file:
model2 = pickle.load(pickle_file)
model.init_weights(model2)
model, mean, std = train_model(model, nn_params, log, exp, train_path,
val_path, save_logs)
# test model
X_test, Y_test = read_data(test_path, nn_params, "test")
# apply z score scaling
if nn_params["z_scale"]:
X_test, _, __ = z_scaling(X_test.copy(), mean, std)
test_model(model, nn_params, exp, X_test, Y_test, save_logs, "test")
def train(self,col = -1):
if mdf.empty:
print("Empty dataframe. Data is needed to train. Use import to import data")
else:
if col == -1:
col = int(input("Which column is output data "))
col = int(col)
outdata = mdf.iloc[:,col-1:col]
indata = mdf.drop(mdf.columns[col-1],axis=1)
inTrain, inTest, outTrain, outTest = train_test_split(indata, outdata, test_size=0.3, random_state=101)
#print(inTrain)
#print(inTest)
#print(outTrain)
#print(outTest)
neural = Network(inTrain.values,outTrain.values)
Network.train(neural, 1000)
Network.run(neural, inTest)
def sendCommand(self, nameRoom, equipment, command):
"""Método que envia os comandos para o cômodo
:Param nameRoom: O nome do cômodo
:Type nameRoom: String
:Param equipment: O equipamento
:Type equipment: String
:Param command: O comando a ser executado
:Type command: String
:Return: A requisição Http Post do Cômodo
:Rtype: Requisição Http Post
"""
nameRoom = nameRoom.lower()
infoRoom = self.__searchRoom(nameRoom)
if (infoRoom != False):
ip = infoRoom[0]
port = infoRoom[1]
params = {"equipment": equipment, "command": command}
method = "controlEquipment"
return util.httpPostRequest(ip, port, method, params)
else:
return "Comodo nao existe"
def __init__(self, game, name, dimensions, a_size, trainer, model_path, global_episodes):
self.name = "worker_" + str(name)
self.number = name
self.model_path = model_path
self.trainer = trainer
self.global_episodes = global_episodes
self.increment = self.global_episodes.assign_add(1)
self.episode_rewards = []
self.episode_lengths = []
self.episode_mean_values = []
self.summary_writer = tf.summary.FileWriter("train_" + str(self.number))
self.height, self.width, depth, self.s_size = dimensions
# Create the local copy of the network and the tensorflow op to copy global paramters to local network
self.local_AC = Network(self.height, self.width, depth, self.s_size, a_size, self.name, trainer)
self.update_local_ops = update_target_graph('global', self.name)
self.actions = range(a_size)
# End Doom set-up
self.env = gym.make(game)
def getinfo():
data = []
result = request.form
f = request.files['data_file']
stream = io.StringIO(f.stream.read().decode("UTF8"), newline=None)
data = pd.read_csv(stream)
'''Get user specs from form'''
output = result['output']
output = int(output)
'''Separate input data from output data'''
outdata = data.iloc[:, output - 1:output]
indata = data.drop(data.columns[output - 1], axis=1)
'''Testing purposes to ensure data is placed correctly'''
'''Further separation of daata file'''
#inTrain, inTest, outTrain, outTest = train_test_split(indata, outdata, test_size=0.3, random_state=101)
# print(inTrain)
# print(inTest)
# print(outTrain)
# print(outTest)
inTest = indata.tail(1)
outTest = outdata.tail(1)
inTrain = indata[:-1]
outTrain = outdata[:-1]
'''Train data'''
neural = Network(inTrain.values, outTrain.values)
Network.train(neural, 1000)
outputList = pd.DataFrame(Network.run(neural, inTest))
return render_template("view.html",
tables=[
inTest.to_html(classes='intext'),
outTest.to_html(classes='outTest'),
outputList.to_html(classes='outTest')
],
titles=['na', 'IN', 'OUT', 'OTIS'])
def One_Initialize_Network(Hidden_Neurons: int) -> Network.Neural_Network:
""" This function initializes a single-hidden-layer neural network with a
variable number of neurons in the first layer. Every weight and bias in the
network is initialized to a tensor of ones. This gives the network a
predictable (though still nonlinear) output, which is very useful for
testing. In particular, the network we create should evaluate as follows:
u_NN(x) = n*tanh(x[0] + x[1] + 1) + 1
where n = Hidden_Neurons. """
# Initialize the network.
NN = Network.Neural_Network(Num_Hidden_Layers=1,
Neurons_Per_Layer=Hidden_Neurons,
Input_Dim=2,
Output_Dim=1)
# Manually set the network Weights and Biases to tensors of ones.
torch.nn.init.ones_(NN.Layers[0].weight.data)
torch.nn.init.ones_(NN.Layers[1].weight.data)
torch.nn.init.ones_(NN.Layers[0].bias.data)
torch.nn.init.ones_(NN.Layers[1].bias.data)
return NN
def __init__(self):
# datasets
self.train_dataset = Dataset.UCF101VideoDataset(
'/home/sunhanbo/workspace/C3D_UCF101/Dataset', 'train', 16, False)
self.train_loader = Data.DataLoader(
self.train_dataset,
batch_size=60,
shuffle=True,
drop_last=True,
num_workers=16,
)
self.test_dataset = Dataset.UCF101VideoDataset(
'/home/sunhanbo/workspace/C3D_UCF101/Dataset', 'test', 16, False)
self.test_loader = Data.DataLoader(
self.test_dataset,
batch_size=60,
shuffle=False,
drop_last=False,
num_workers=16,
)
# networks
self.net = Network.C3DNetwork(101)
def snowball_network(network, sample_size, n_neighbors, induced=False):
visited_nodes, visited_edges, nodes_queue, temp_visited = set(), set(
), set(), set()
starting_node = get_random_node(network.nodes)
nodes_queue.add(starting_node)
visited_nodes.update(nodes_queue)
while (len(nodes_queue) > 0) and (len(visited_nodes) <
(sample_size * network.n_nodes)):
for node in nodes_queue:
new_neighbors = network.adj[node].difference(
visited_nodes).difference(temp_visited)
neighbor_limit = min(len(new_neighbors), n_neighbors)
visit_neighbors(neighbor_limit, new_neighbors, visited_edges, node,
temp_visited)
update_visited_nodes(visited_nodes, temp_visited, sample_size,
network.n_nodes, visited_edges)
nodes_queue.clear()
nodes_queue.update(temp_visited)
temp_visited.clear()
nodes = visited_nodes
edges = get_edges(induced, nodes, network.edges, visited_edges)
return Network(nodes, edges)
def __init__(self,
speed=None,
health=None,
max_health=None,
dmg=None,
armor=None,
size=None,
brain=None,
name="Yuval",
location=None,
turns=0):
if speed == None:
speed = attribute()
if health == None:
health = attribute()
if max_health == None:
max_health = attribute()
if dmg == None:
dmg = attribute()
if armor == None:
armor = attribute()
if size == None:
size = attribute()
if location == None:
location = [400, 400]
self.location = location
if brain == None:
brain = [3, 2, 3]
brain1 = Network.network(brain)
self.brain = brain1
self.speed = speed
self.health = health
self.max_health = max_health
self.dmg = dmg
self.armor = armor
self.size = size
self.name = name
self.speed.value = 20
self.turns = turns
def RSNN_param_test(X_train, X_test, y_train, y_test, h_nodes, epochs, lr,
times, threshold, coefficient, type):
"""
Trains a regular 3-layer our NN, and returns the accuracy results
:param X_train: Numpy array/pandas dataframe, data for the keras model.
:param X_test: Numpy array/pandas dataframe, data for the keras model.
:param y_train: Numpy array/pandas dataframe, data for the keras model.
:param y_test: Numpy array/pandas dataframe, data for the keras model.
:param h_nodes: Int, number of nodes in the hidden layer.
:param epochs: Int, number of epochs to train the NN.
:param lr: Float, learning rate for training.
:param times: Integer, number of times to MC sample.
:param threshold: Integer, used as threshold for forming residual to sample from.
:param coefficient: Float, used as the ratio for updating the variance.
:param type: string, select type of loss function.
:return: (training_acc, test_acc), training/testing accuracies
"""
in_dim = X_train.shape[1]
out_dim = y_train.shape[1]
#Initialize the network
np.random.seed(10) # Ensures each network is initialized the same way.
net = Network.Network([in_dim, h_nodes, out_dim],
type=type,
pdw=['gaussian'] * 2,
pdb=['gaussian'] * 2)
net.Learn(X_train,
y_train,
epochs=epochs,
lrate=lr,
times=times,
threshold=threshold,
bootstrap=False,
coefficient=coefficient)
acc_train = net.ClassificationAccuracy(X_train, y_train)
acc_test = net.ClassificationAccuracy(X_test, y_test)
return (acc_train, acc_test)
def check_alternate_titles(self):
"""
Checks up to the top MAX_ALTERNATE_TITLE_SEARCHES regular matches to see if we match an alternate title.
"""
self.results.Sort('score', descending=True)
top_match_counter = 0
for result in self.results:
top_match_counter += 1
if result.score == 100:
return
elif top_match_counter <= MAX_ALTERNATE_TITLE_SEARCHES:
xml = Network.fetch_xml(tvrage.SHOW_INFO_URL % result.id)
if xml:
for aka_xml in xml.xpath("./akas/aka"):
for show_name in self.show_names:
aka_show_name = str(aka_xml.text)
Log("[%s] [%s]" %
(tvrage.sanitize_show_name(show_name), tvrage.sanitize_show_name(aka_show_name)))
if tvrage.sanitize_show_name(show_name) == tvrage.sanitize_show_name(aka_show_name):
Log("Found exact match in alternate title %s" % aka_show_name)
result.score = 100
def main():
root = Tk()
root.title("Social Network")
root.configure(bg="#EAF6F6")
network = Network("social_network.txt")
def on_closing():
network.write_messages("messages.txt")
root.destroy()
network.parse()
network.read_messages("messages.txt")
frame = UserFrame(master=root, network=network)
frame.style()
frame.place()
root.protocol("WM_DELETE_WINDOW", on_closing)
root.mainloop()