def run_simulation(length_in_months, tax_rate):
rate_after_tax = 1 - tax_rate
income_entries = income.load_entries_from_file()
expense_entries = expense.load_entries_from_file()
months = pd.DataFrame(
columns=["month", "income", "expenses", "net", "cumulative_net"])
months["month"] = months["month"].astype(int)
months["income"] = months["income"].astype(float)
months["expenses"] = months["expenses"].astype(float)
months["net"] = months["net"].astype(float)
months["cumulative_net"] = months["cumulative_net"].astype(float)
for month in range(1, length_in_months + 1):
income_for_month = income.calculate_income_for_month(income_entries,
month)
income_for_month *= rate_after_tax
expenses_for_month = expense.calculate_expenses_for_month(
expense_entries)
months = months.append(pd.DataFrame({
"month": [month],
"income": [income_for_month],
"expenses": [expenses_for_month],
"net": [income_for_month - expenses_for_month]
}), ignore_index=True)
months["cumulative_net"] = months["net"].cumsum()
print(months)
graphing.graph(months)
def add_result(self, result):
graphed = graph(result)
result['local_graphs'] = [graphed]
del result['output']
self.add_result_local(result)
self.zipdir_local(result)
self.add_result_cloud(result)
self.rm_results_local(result)
def creategraph(data, isStatic=True, filterType='sms', graph_directed=True, pid_dict=None):
pid_dict = getuniqueparticipants(data, filterType) if None is pid_dict else pid_dict
graph_obj = graph(is_directed=graph_directed, is_multigraph=filterType == 'all')
if isStatic:
ignore_mtype = filterType != 'all'
links, link_tuple = getlinks(pid_dict, data, ignore_mtype)
graph_obj.addnodes(pid_dict[pr.participant[filterType]].values(), 'P')
graph_obj.addnodes(pid_dict[pr.nparticipant[filterType]].values(), 'NP')
graph_obj.addedges(link_tuple)
return links, link_tuple, graph_obj, pid_dict
else:
start_datetime = dt.datetime.strptime(pr.start_datetime, '%Y-%m-%d %H:%M:%S')
week_dict, link_tuple, week_content = getdynamiclinks(pid_dict,
data, start_datetime)
to_write_edge, to_write_node = graph_obj.exportdynamicgraph(link_tuple, pid_dict)
return to_write_edge, to_write_node, week_dict, pid_dict, week_content
def open_model(self):
name = 'mygraph' #eventually will be from user
current_graph = graphing.graph()
#open a saved file
try:
saved_file = open('data/' + name + '.xml', 'r')
xml_string = saved_file.read()
saved_file.close()
current_graph = gnosis.xml.pickle.loads(xml_string)
except IOError:
pass
return current_graph
def generate_reports():
print '\nGenerating reports for %d team members.' % len(s['members'])
members = s['members']
for member in members:
print "\nReport for %s:" % member
# get case resolves
projects, project_cases = reporting.get_resolved_cases(s['config'], member, today, lastweek)
resolves = len(project_cases)
print 'Resolves: %d' % resolves
activity_projects, activity_cases = reporting.get_case_activity(s['config'], member, today, lastweek)
activity = len(activity_cases)
print 'Activity: %d' % activity
member_repo_list, changeset_list = reporting.get_commits(s['config'], member, today, lastweek)
commits = 0
for item in changeset_list:
for key, value in item.iteritems():
commits += len(value)
print 'Commits: %d' % commits
member.add_overview_data({'date' : datetime.now(),
'resolves' : resolves,
'activity' : activity,
'commits' : commits})
save_dir = os.path.join(s['config']['home'], "reports", member.username)
if not os.path.exists(save_dir):
os.makedirs(save_dir)
graph_file = graphing.graph(member, save_dir)
reporting.report(member, save_dir, graph_file, projects, project_cases, activity_projects, activity_cases, member_repo_list, changeset_list)
s['members'] = members
def calALL():
path = opt.folders
ps = []
ss = []
list_PSNR =[]
list_SSIM =[]
file_list = os.listdir(path)
f = open(path+"average.txt", 'w')
f.write('average (PSNR,SSIM)\n')
f.close()
file_list = sorted(file_list, key = len)
for Npath in file_list:
newPath = path+Npath+'/'
averPSNR = 0
averSSIM = 0
count = 0
if not (search(newPath)):
continue
else:
f = open(newPath+"PSNR.txt", 'w')
f.close()
f = open(newPath+"SSIM.txt", 'w')
f.close()
print("*folder* = "+newPath)
newfile_list = os.listdir(newPath)
list_PSNR =[]
list_SSIM =[]
for i in newfile_list:
if(i[-9:]=='epoch.jpg'):
os.remove(newPath+'epoch.jpg')
continue
if(i[-3:]=='txt' or i[-8:]=='SSIM.jpg' or i[-8:]=='PSNR.jpg'):
continue
img = i
LR = newPath + img
print('open '+ LR)
HR = opt.HR
HR = HR + img
print('open '+HR)
#biimg = cv2.imread(LR)
#biimg = cv2.resize(biimg, None, fx=4, fy=4, interpolation=cv2.INTER_CUBIC)
#cv2.imwrite(opt.HR+'../bicubic/'+i ,biimg)
#LR = opt.HR+'../bicubic/'+i
#print(LR)
try:
one, two = PSNR.cal_PSNRandSSIM(HR, LR)
except:
print('skip')
continue
print(f"{one} is PSNR, {two} is SSIM")
f = open(newPath+"PSNR.txt", 'a')
f.write(img+f" PSNR is {one}\n")
f.close()
f = open(newPath+"SSIM.txt", 'a')
f.write(img+f" SSIM is {two}\n")
f.close()
list_PSNR.append(one)
list_SSIM.append(two)
#well.. im not good at python..
averPSNR += one
averSSIM += two
count +=1
print('=============================')
graphing.graph(list_PSNR, [], newPath,'PSNR',opt.picofname)
graphing.graph(list_SSIM, [], newPath,'SSIM',opt.picofname)
if(count==0):
averPSNR = 0
averSSIM = 0
else:
averPSNR /= count
averSSIM /= count
print("{} is average PSNR, {} is average SSIM".format(averPSNR,averSSIM))
ps.append(averPSNR)
ss.append(averSSIM)
graphing.graph(ps, [], path,'PSNR',opt.X)
graphing.graph(ss, [], path,'SSIM',opt.X)
f = open(path+"average.txt", 'a')
f.write("{} : {} is average PSNR, {} is average SSIM\n".format(Npath,averPSNR,averSSIM))
f.close()
if p[2] > 0:
eta = 9.7
if p[2] < 0:
eta = -9.7
else:
eta = - math.log(math.tan(pangle/2))
eta_extra.append(eta)
if i % 1000 == 0:
print "DONE " + str(i)
print "count: " + str(count)
# Mass
f_m_tw = ROOT.TFile("reconstructed_top_mass_tw.root",'RECREATE')
h_m_tw = ROOT.TH1F("h",'Mass of tw Buckets',150,0,300)
graphing.graph(h_m_tw, f_m_tw, mass_tw, 'Mass (GeV)', 'Frequency', 'reconstructed_top_mass_tw')
f_m_t_ = ROOT.TFile("reconstructed_top_mass_t_.root",'RECREATE')
h_m_t_ = ROOT.TH1F("h",'Mass of t_ Buckets',150,0,300)
graphing.graph(h_m_t_, f_m_t_, mass_t_, 'Mass (GeV)', 'Frequency', 'reconstructed_top_mass_t_')
f_m_t0 = ROOT.TFile("reconstructed_top_mass_t0.root",'RECREATE')
h_m_t0 = ROOT.TH1F("h",'Mass of t0 Buckets',500,0,2000)
graphing.graph(h_m_t0, f_m_t0, mass_t0, 'Mass (GeV)', 'Frequency', 'reconstructed_top_mass_t0')
f_m_t0_z = ROOT.TFile("reconstructed_top_mass_t0_z.root",'RECREATE')
h_m_t0_z = ROOT.TH1F("h",'Mass of t0 Buckets (Zoomed in)',150,0,300)
graphing.graph(h_m_t0_z, f_m_t0_z, mass_t0, 'Mass (GeV)', 'Frequency', 'reconstructed_top_mass_t0_z')
f_m_x = ROOT.TFile("reconstructed_top_mass_x.root",'RECREATE')
h_m_x = ROOT.TH1F("h",'Mass of the Extra Buckets',110,-1,10)
def ae(x_data, y_data):
x_train = np.array(x_data[:int(len(x_data) * TRAINING_PERCENTAGE)])
y_train = np.array(y_data[:int(len(y_data) * TRAINING_PERCENTAGE)])
x_test = np.array(x_data[int(len(x_data) * TRAINING_PERCENTAGE):])
y_test = np.array(y_data[int(len(y_data) * TRAINING_PERCENTAGE):])
x_train = flatten(x_train)
x_test = flatten(x_test)
autoencoder = Sequential()
# Encoder Layers
autoencoder.add(
Dense(len(x_train[0]),
input_dim=len(x_train[0]),
activation=LeakyReLU(alpha=0.3)))
autoencoder.add(Dense(23, activation=LeakyReLU(alpha=0.3)))
autoencoder.add(Dense(11, activation=LeakyReLU(alpha=0.3)))
# Decoder Layers
autoencoder.add(Dense(11, activation=LeakyReLU(alpha=0.3)))
autoencoder.add(Dense(23, activation=LeakyReLU(alpha=0.3)))
autoencoder.add(Dense(len(x_train[0]), activation=LeakyReLU(alpha=0.3)))
autoencoder.compile(optimizer='adam',
loss='mean_squared_error',
metrics=[crps])
history = autoencoder.fit(x_train,
x_train,
epochs=100,
batch_size=128,
validation_data=(x_test, x_test),
verbose=2)
graph(history, to_file='images/ae.png')
inputs = Input(shape=(len(x_train[0]), ))
encoder_layer1 = autoencoder.layers[0](inputs)
encoder_layer2 = autoencoder.layers[1](encoder_layer1)
encoder_layer3 = autoencoder.layers[2](encoder_layer2)
encoder = Model(inputs, encoder_layer3)
encoded_x_train = encoder.predict(x_train, verbose=2)
print(len(encoded_x_train[0]))
print(encoded_x_train.shape)
encoded_x_test = encoder.predict(x_test, verbose=2)
model = Sequential([
Dense(45, input_dim=len(encoded_x_train[0])),
LeakyReLU(alpha=0.3),
Dense(22),
LeakyReLU(alpha=0.3),
Dense(1),
LeakyReLU(alpha=0.3)
])
model.compile(loss='mean_squared_error', optimizer='adam', metrics=[crps])
history = model.fit(encoded_x_train,
y_train,
batch_size=BATCH_SIZE,
epochs=EPOCHS,
validation_data=(encoded_x_test, y_test))
# graph(history, to_file='images/ae-ffnn.png')
#Evaluating the model
scores = model.evaluate(encoded_x_test, y_test)
print(f'CRPS AE: {scores[1]}')
df_sim[comp_arr[a].name] = comp_arr[d].get_df_array()
if run_t != 0:
t_arr.append(run_t)
run_t += dt
def get_vm_dict():
vm_dict = {}
for x in range(len(comp_arr)):
vm_dict[comp_arr[x].name] = comp_arr[x].v_arr
return vm_dict
vm_dict = get_vm_dict()
g1 = gr.graph(start_time=20)
fig1, ax1 = g1.graph_time_vm_allcomps(vm_dict, t_arr)
sns.despine()
fig1.show()
"""
fig_vm, (a1, a2, a3) = plt.subplots(1, 3,sharey=True)
plt.xlabel("Time (s)")
plt.ylabel("Voltage (mV)")
a1.set_title("Comp 1")
a2.set_title("Comp 2")
a3.set_title("Comp 3")
a1.plot(t_arr[45000:-1], comp_1.v_arr[45000:-1])
a2.plot(t_arr[45000:-1], comp_2.v_arr[45000:-1])
a3.plot(t_arr[45000:-1], comp_3.v_arr[45000:-1])
sns.despine()
# quit function
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
quit()
# proxmitiy detection (and transmission)
for index, node in enumerate(myvars.nodes):
for node2 in myvars.nodes[
index:]: # this does not loop thru nodes that already have been checked (so we have no [node1 --> node2], and then [node2 --> node1])
getDistance(node, node2, tick)
if node.infected:
node.checkImmunity(tick)
node.move()
drawWindow(myvars.nodes, myvars.deadNodes)
# data export stuff
if tick % dataLogTicks == 0:
logData()
if myvars.infected == 0:
break
pygame.display.update()
logData()
createCSV(myvars.data)
graphing.graph(myvars.data)
# -*- coding: utf-8 -*- """ Created on Sun Sep 23 21:32:02 2018 @author: ASUS """ import dataclean import graphing import pandas as pd import ml fname='Dataset - Human Resource.csv' threshold=0.5 #Results with probability above this threshold will be labelled as attrition = Yes corrThreshold=0.05 #remove columns below this corr value df=pd.read_csv(fname) leandf, converteddf, cor, info, rawcorr=dataclean.dataCleanse(df) graphs=graphing.graph(leandf,converteddf) model, results = ml.train(converteddf, threshold)
def debited():
print(colored("Starting debited graph","yellow"))
pb = loading()
graph("Debited")
loaded(pb)
def credited():
print(colored("Starting credited graph","yellow"))
pb = loading()
graph("Credited")
loaded(pb)
import logging
import spreadsheet
from parse_arguments import parse_arguments
from read_responses import read_responses
from graphing import graph
from edurate_gensim import gensim_analysis
if __name__ == "__main__":
print("Welcome to Edurate")
print("https://github.com/Edurate/edurate")
logging.info("Analyzes the Google form responses with gensim and " +
"returns the repeated words, graphs, or archives the file")
EDU_ARGS = parse_arguments(sys.argv[1:])
SPREADSHEET_LIST = spreadsheet.read_from_spreadsheet()
DATA = spreadsheet.get_graph_data(SPREADSHEET_LIST)
if EDU_ARGS.graph:
print("Creating Graphs...")
graph(DATA)
spreadsheet.create_csv(SPREADSHEET_LIST)
RESPONSES = read_responses(EDU_ARGS.file)
RESPONSES = spreadsheet.filter_dates(RESPONSES)
RESPONSES = spreadsheet.flip_responses(RESPONSES)
QUESTION_NUMBER = 7
for index, response in enumerate(RESPONSES[8:12]):
gensim_analysis(response, QUESTION_NUMBER, EDU_ARGS.topics)
QUESTION_NUMBER += 1
pt_extra.append(pt)
if pt < 0.001:
if p[2] > 0:
eta = 9.7
if p[2] < 0:
eta = -9.7
else:
eta = -math.log(math.tan(pangle / 2))
eta_extra.append(eta)
if i % 1000 == 0:
print "DONE " + str(i)
# Mass
f_m_tw = ROOT.TFile("reconstructed_top_mass_tw.root", 'RECREATE')
h_m_tw = ROOT.TH1F("h", 'Mass of tw Buckets', 150, 0, 300)
graphing.graph(h_m_tw, f_m_tw, mass_tw, 'Mass (GeV)', 'Frequency',
'reconstructed_top_mass_tw')
f_m_t_ = ROOT.TFile("reconstructed_top_mass_t_.root", 'RECREATE')
h_m_t_ = ROOT.TH1F("h", 'Mass of t_ Buckets', 150, 0, 300)
graphing.graph(h_m_t_, f_m_t_, mass_t_, 'Mass (GeV)', 'Frequency',
'reconstructed_top_mass_t_')
f_m_t0 = ROOT.TFile("reconstructed_top_mass_t0.root", 'RECREATE')
h_m_t0 = ROOT.TH1F("h", 'Mass of t0 Buckets', 150, 0, 300)
graphing.graph(h_m_t0, f_m_t0, mass_t0, 'Mass (GeV)', 'Frequency',
'reconstructed_top_mass_t0')
f_m_x = ROOT.TFile("reconstructed_top_mass_x.root", 'RECREATE')
h_m_x = ROOT.TH1F("h", 'Mass of the Extra Buckets', 110, -1, 10)
graphing.graph(h_m_x, f_m_x, mass_extra, 'Mass (GeV)', 'Frequency',
'reconstructed_top_mass_x')
