def plot_Delta_Y_sum(Y_off_H, Y_el_H, X_ric, F_ric, fontsize=15):
plt.figure()
matplotlib.rc('xtick', labelsize=fontsize - 2)
matplotlib.rc('ytick', labelsize=fontsize - 2)
data = [(Y_off_H, 'Offline', 'red'), (Y_el_H, 'Online', 'blue')]
for Y_H, label, color in data:
Y_avg_orig = load('Y_avg-' + label + '.pkl')
Y_std_orig = load('Y_std-' + label + '.pkl')
Y_avg = Y_avg_orig[0::10] / max(Y_avg_orig)
Y_std = Y_std_orig[0::10] / max(Y_avg_orig)
x = range(len(Y_avg))
plt.plot(x, Y_avg, label=label, color=color)
plot_error(x, Y_avg, Y_std)
plt.legend(loc=1, fontsize=fontsize)
plt.xticks((0, 250, 500, 750, 1000, 1250, 1500, 1750, 2000),
('0', '2500', '5000', '7500', '10000', '12500', '15000',
'17500', '20000'),
fontsize=10)
# Configure plot
plt.ylabel(r'$\Delta Y$', fontsize=fontsize)
plt.xlabel(r'Episode', fontsize=fontsize)
plt.grid(True)
plt.tight_layout(h_pad=0., w_pad=0., pad=2)
plt.savefig('arm_Y.pdf', bbox_inches='tight')
plt.close()
def remoteLoad(openFile):
global username
global password
global hostname
global ip
global files
global dirs
global fileName
global usernameContainer
global passwordContainer
global hostnameContainer
global ipContainer
global filesContainer
global dirsContainer
global fileNameContainer
global crackSecureContainer
global sysColor0Container
global sysColor1Container
global isRemote
global globalUsername
global crackSecure
global sysColor0
global sysColor1
global cwd
usernameContainer = username
passwordContainer = password
hostnameContainer = hostname
ipContainer = ip
filesContainer = files
dirsContainer = dirs
fileNameContainer = fileName
crackSecureContainer = crackSecure
sysColor0Container = sysColor0
sysColor1Container = sysColor1
username = file.load(openFile, 'username')
password = file.load(openFile, 'password')
hostname = file.load(openFile, 'hostname')
ip = file.load(openFile, 'ip')
files = file.load(openFile, 'files')
remoteDirs = file.load(openFile, 'dirs')
fileName = openFile
crackSecure = int(file.load(openFile, 'crackSecure'))
sysColor0 = file.load(openFile, 'sysColor0')
sysColor1 = file.load(openFile, 'sysColor1')
isRemote = True
cwd = '/' # So as to prevent it from carrying across local and remote.
def __init__(self, root, n):
color_map_path = root.root.global_settings['PUZZLE']['COLOR_MAPS'][
'RUBIKS_CUBE']
super().__init__(root, color_map_path, COLOR_MAP)
self.color_map = load(color_map_path)
self.dimension = n
self.gen()
def telnet(ipTry, tryFile="index.html"):
global ip
global globalUsername
global isRemote
global username
found = False
isRemote = True
for elem in file.parseLs('files/computers.txt'):
remoteReset()
errorLog('iter')
remoteLoad('saves/%s/%s' % (globalUsername, elem))
if ip == ipTry:
savFile = 'saves/%s/%s' % (globalUsername, elem)
username = file.load(savFile, 'username')
password = file.load(savFile, 'password')
loginReturn = cracks.autoLogin('remote', savFile, username,
password)
load()
found = True
cdReturns = []
cdReturns.append(inputLoop(0, 'cd var'))
cdReturns.append(inputLoop(0, 'cd www'))
cdReturns.append(inputLoop(0, 'cd html'))
for elem in cdReturns:
if elem == "Operation not permitted; no such directory.":
print(
"The specified file could not be found at this server."
)
remoteReset()
return 3
catReturn = cat(tryFile)
if catReturn[0]:
print(catReturn[1])
remoteReset()
return 0
else:
remoteReset()
print("The specified file could not be found at this server.")
return 1
if found == False:
print("Failed to connect to %s." % ipTry)
remoteReset()
return 2
def update_data(new_data, day):
months = new_data_by_month(new_data)
for month in months:
f = 'data/%s' % month
try:
existing_data = file.load(f)
except FileNotFoundError:
existing_data = []
existing_data.extend(months[month])
file.dump(f, existing_data)
config['processed'].append(day)
file.dump('config.json', config)
def open_config_from_file(self, widget):
file_name = self.open_file_dialog.get_filename()
if (file_name):
start, end, errors = file.load(file_name)
if len(errors.splitlines()) > 3:
self.error_label.set_text(errors)
else:
self.error_label.set_text("")
self.start_matrix = start
self.end_matrix = end
self.load_configuration_matrix(self.start_matrix, 1)
self.load_configuration_matrix(self.end_matrix, 2)
self.configuration_window.show()
def open_config_from_file(self, widget):
file_name = self.open_file_dialog.get_filename()
if (file_name):
start, end, errors = file.load(file_name)
if len(errors.splitlines()) > 3:
self.error_label.set_text(errors)
else:
self.error_label.set_text("")
self.start_matrix = start
self.end_matrix = end
self.load_configuration_matrix(self.start_matrix, 1)
self.load_configuration_matrix(self.end_matrix, 2)
self.configuration_window.show()
class Config:
# Global app conf
__DEVICE_PREFERENSES = CONFIG_DIR + '/device_preferences.json'
__KEYBOARD_MAP = CONFIG_DIR + '/events/keyboard_map.json'
__STANDART_PALETTE = CONFIG_DIR + '/palettes/standart_palette.json'
__KDE_PALETTE = CONFIG_DIR + '/palettes/kde_palette.json'
# Geometry data
__GRID_DATA = CONFIG_DIR + '/geometry/grid.json'
__CUBE_DATA = CONFIG_DIR + '/geometry/cube.json'
__TETRAHEDRON_DATA = CONFIG_DIR + '/geometry/tetrahedron.json'
__POLYHEDRON_DATA_DIR = CONFIG_DIR + '/geometry/polyhedrons/'
# Color data
__RUBIKS_CUBE_COLOR_MAP = CONFIG_DIR + '/maps/rubiks_cube_color_map.json'
__MIRROR_CUBE_COLOR_MAP = CONFIG_DIR + '/maps/mirror_cube_color_map.json'
__PUZZLE_COLOR_MAPS = {
'RUBIKS_CUBE': __RUBIKS_CUBE_COLOR_MAP,
'MIRROR_CUBE': __MIRROR_CUBE_COLOR_MAP
}
__PRIMITIVE_DATA = {
'REGULAR': {
'CUBE': load(__CUBE_DATA),
'GRID': load(__GRID_DATA),
'TETRAHEDRON': load(__TETRAHEDRON_DATA),
},
'POLYHEDRONS': __POLYHEDRON_DATA_DIR
}
__VIEWPORT_SETTINGS = {
'DEVICE': load(__DEVICE_PREFERENSES),
'PALETTES': {
'STD': load(__STANDART_PALETTE),
'KDE': load(__KDE_PALETTE)
}
}
__EVENTS_SETTINGS = {'KEYBOARD': load(__KEYBOARD_MAP)}
__PUZZLE_SETTINGS = {
'PRIMITIVES': __PRIMITIVE_DATA,
'COLOR_MAPS': __PUZZLE_COLOR_MAPS
}
GLOBAL_SETTINGS = {
'VIEWPORT': __VIEWPORT_SETTINGS,
'PUZZLE': __PUZZLE_SETTINGS,
'EVENTS': __EVENTS_SETTINGS
}
def load():
global username
global password
global hostname
global ip
global files
global dirs
global fileName
global crackSecure
global sysColor0
global sysColor1
username = file.load(fileName, 'username')
password = file.load(fileName, 'password')
hostname = file.load(fileName, 'hostname')
ip = file.load(fileName, 'ip')
files = file.load(fileName, 'files')
dirs = file.load(fileName, 'dirs')
crackSecure = int(file.load(fileName, 'crackSecure'))
sysColor0 = file.load(fileName, 'sysColor0')
sysColor1 = file.load(fileName, 'sysColor1')
def returnProbe():
files = file.parseLs("files/computers.txt")
returnList = []
for elem in files:
returnList.append(file.load("defaults/" + elem, 'ip'))
returnStr = ""
elems = len(returnList)
iterations = 0
for elem in returnList:
iterations += 1
if iterations != elems:
returnStr += elem + '\n'
else:
returnStr += elem
return returnStr
def _extract_todo_info(self, extract_history=False):
"""Read todo.pom and extract todo info (timestamp, shortterm tasks&est&pom&sta, sometime todo)"""
line_buffer = file.load(self.settings['path_pom'], 'txt')
line_buffer = [item.rstrip('\n') for item in line_buffer]
todo_info = {}
todo_info['buffers'] = self._extract_todo_tbl_buffers(
line_buffer, extract_history)
todo_info['date'], todo_info['time'] = self._parse_timestamp_header(
todo_info['buffers']['timestamp'])
todo_info['today'] = self._parse_todo_today(
todo_info['buffers']['today'])
todo_info['sometime'] = self._parse_todo_sometime(
todo_info['buffers']['sometime'])
# self.log.info(todo_info['today'])
return todo_info
def _add_tasks2menu(self, tasks):
todo_main_base_menu = file.load(self.settings['path_base_menu'],
'json')
children = []
for task in tasks:
bar = {
"caption":
task,
"children": [{
"caption": "Short break",
"command": "todo_task_cmd",
"id": "todo_menu_short_break",
"args": {
"task": task,
"cmd": "short_break"
}
}, {
"caption": "Long break",
"command": "todo_task_cmd",
"id": "todo_menu_long_break",
"args": {
"task": task,
"cmd": "long_break"
}
}, {
"caption": "Ok",
"command": "todo_task_cmd",
"id": "todo_menu_ok",
"args": {
"task": task,
"cmd": "ok"
}
}]
}
children.append(bar)
tasks_menu = {"caption": "Tasks", 'children': children}
todo_main_base_menu[0]['children'].insert(0, tasks_menu)
file.save(todo_main_base_menu, self.settings['path_menu'], 'json')
return
from containers import Databases from file import load_databases_from_file as load load() print(Databases.databases)
def init():
global config
config = file.load('config.json')
set_yesterday()
return (
reduce(
lambda p, c: ((c[1][0] if request[c[0]] else (1 - c[1][0])) * p)
/ (
(c[1][0] if request[c[0]] else (1 - c[1][0])) * p
+ (c[1][1] if request[c[0]] else (1 - c[1][1])) * (1 - p)
),
enumerate(evidences[idx]),
hypothesis,
)
for idx, hypothesis in enumerate(hypothesises)
)
if __name__ == "__main__":
from file import load
from db import (
process,
evidence_values,
hypothesis_names,
hypothesis_values,
)
data = process(load("data/db.csv"), ["desease", "ph"], ["symptom", "peh", "penh"])
res = expertize(
hypothesis_values(data),
evidence_values(data),
(True, False, True, False, True),
)
print(dict(zip(hypothesis_names(data), res)))
def generate_reports():
global reports
data = []
for f in glob.glob('data/*'):
for report in file.load(f):
reports.append(report)
for g in grouped.groups
}
def hypothesis_names(data):
return [k[0] for k in data]
def hypothesis_values(data):
return [k[1] for k in data]
def evidence_names(data):
return list(dict.fromkeys([v for k in data for v in data[k]]))
def evidence_values(data):
return [[v for v in data[k].values()] for k in data]
if __name__ == "__main__":
from file import load
data = process(load("data/db.csv"), ["desease", "ph"],
["symptom", "peh", "penh"])
print(data)
print(hypothesis_names(data))
print(hypothesis_values(data))
print(evidence_names(data))
print(evidence_values(data))
from stack import stack
import arm_constants as ac
from file import load
from riccati import riccati
from scipy.io import savemat
from arm_constants import P as P_hardcoded
# Pasta com coisas relacionadas à obtenção por
# contagem/maximização de verossimilhança (2017count)
dir = 'count/'
# P.pkl e P_tilde.pkl foram obtidas de
# cerob/MarkovianSimulator/riccati/1000_iter/loop_loop_iteration_0100.mat
# Git: origin/plot c88519f4d18a719f0fd1401096c22b7600762187
# P_hardcoded foi encontrada no código fonte (consigo ser mais específico?)
Ps = (('P', load(dir + 'P.pkl')), ('P_tilde', load(dir + 'P_tilde.pkl')),
('P_hardcoded', P_hardcoded))
for name, P in Ps:
# Calcular F a partir de P no Python
args = {
'T': int(1e6),
'N': ac.N,
'A': ac.A,
'B': ac.B,
'C': ac.C,
'D': ac.D,
'R': P,
'epsilon': 1e-6,
}
[F, _] = riccati(**args)
def process(db, key_name, indicator_name):
def fun(name):
def _inner(x):
return len(list(e for e in x if e == name))
_inner.__name__ = name
return _inner
return (db.groupby(key_name)[indicator_name].aggregate([
fun(g) for g in db[indicator_name].unique()
]).transform(lambda x: x / sum(x), axis=1).reset_index())
if __name__ == "__main__":
from file import load
print(process(load("data/db.csv"), "intensity", "mark"))
