def printLEMranks(results_file,LEM_file,fname="LEMranks.txt",use_pldLap=False,plotresults=False,title="11D malaria 40 hr 90 TF, scaling factor 0.05"):
# use_pldLap = False or 0 means use sqrt loss / root
if use_pldLap:
source,target,type_reg,lem_score = fileparsers.parseLEMfile(-1,LEM_file)
else:
source,target,type_reg,sqrtlossdroot_score = fileparsers.parseLEMfile_sqrtlossdroot(2,LEM_file)
totaledges = float(len(source))
results = json.load(open(results_file,'r'))
try:
network_spec_str = results["Network"]
LEMranks = getLEMranks(network_spec_str,totaledges,source,target,type_reg)
print "Mean: {}".format(statistics.mean(LEMranks))
print "Median: {}".format(statistics.median(LEMranks))
print "% stable FCs: {}".format(float(results["StableFCParameterCount"])/float(results["ParameterCount"]))
print "% pattern matches: {}".format(float(results["StableFCMatchesParameterCount"])/float(results["ParameterCount"]))
except:
stats=[]
for R in results:
network_spec_str = R["Network"]
LEMranks = getLEMranks(network_spec_str,totaledges,source,target,type_reg)
stats.append( (statistics.mean(LEMranks),statistics.median(LEMranks),float(R["StableFCMatchesParameterCount"])/float(R["ParameterCount"])) )
with open(fname,'w') as sf:
for s in stats:
sf.write('/'.join([str(t) for t in s])+"\n")
if plotresults:
plotLEMranks(stats,title,use_pldLap)
def indexStats_by_year(year):
area_repo = AreaRepository(recreate_db=False, config=sqlite_config)
indicator_repo = IndicatorRepository(recreate_db=False, config=sqlite_config)
observation_repo = ObservationRepository(recreate_db=False, area_repo=area_repo, indicator_repo=indicator_repo,
config=sqlite_config)
index_indicator = indicator_repo.find_indicators_index()[0]
observations = observation_repo.find_tree_observations(index_indicator.indicator, 'ALL', year, 'INDICATOR')
areas = area_repo.find_countries(order="iso3")
data = {'year': year, 'stats': OrderedDict()}
for region in area_repo.find_regions():
per_region_obs = [o for o in observations if o.value is not None
and o.area.iso3 in [c.iso3 for c in region.countries]]
for indicator_code in sorted(set([o.indicator.indicator for o in observations])):
per_indicator_obs = [o.value for o in per_region_obs if
o.indicator.indicator == indicator_code and o.value is not None]
if region.iso3 not in data['stats']:
data['stats'][region.iso3] = OrderedDict()
data['stats'][region.iso3][indicator_code] = OrderedDict()
data['stats'][region.iso3][indicator_code]['mean'] = statistics.mean(per_indicator_obs)
data['stats'][region.iso3][indicator_code]['median'] = statistics.median(per_indicator_obs)
data['stats'][':::'] = OrderedDict()
for indicator_code in sorted(set([o.indicator.indicator for o in observations])):
per_indicator_obs = [o.value for o in observations if
o.indicator.indicator == indicator_code and o.value is not None]
data['stats'][':::'][indicator_code] = OrderedDict()
data['stats'][':::'][indicator_code]['mean'] = statistics.mean(per_indicator_obs)
data['stats'][':::'][indicator_code]['median'] = statistics.median(per_indicator_obs)
return json_response_ok(request, data)
def getSpeedAfterShock(self, time = 20, startTime = 0, after = 25, absolute = False):
"returns direction that the rat travelled 'after' points after shock"
time = time * 60000
start = self.findStart(startTime)
shocks = [content[0] for content in self.data[start:] if
content[5] == 2 and content[1] < time]
if shocks:
selected = [shocks[0]]
prev = shocks[0]
for shock in shocks[1:]:
if shock - prev > after:
selected.append(shock)
prev = shock
else:
return "NA"
angles = []
cx, cy = self.centerX, self.centerY
for shock in selected:
x1, y1 = self.data[shock][7:9]
if len(self.data) <= shock + after:
break
x2, y2 = self.data[shock + after][7:9]
angle = ((degrees(atan2(x2 - cx, y2 - cy + 0.0000001)) -
degrees(atan2(x1 - cx, y1 - cy + 0.0000001)) + 180) % 360) - 180
angles.append(angle)
if absolute:
return format(median([abs(angle) for angle in angles]), "0.2f")
else:
return format(median(angles), "0.2f")
def parse_life_1_06(pattern):
lines = repr(pattern).split(r'\r\n')
x_vals = []
y_vals = []
board = new_array()
for line in lines[1::]:
if len(line) > 1:
x_vals.append(int(line.split()[0]))
y_vals.append(int(line.split()[1]))
w_padding = (width - len(set(x_vals))) // 2
h_padding = (height - len(set(y_vals))) // 2
if floor(median(x_vals)) < w_padding:
diff = (floor(median(x_vals)) * -1) + w_padding
for x in range(len(x_vals.copy())):
x_vals[x] += diff
if floor(median(y_vals)) < h_padding:
diff = floor((median(y_vals)) * -1) + h_padding
for y in range(len(y_vals.copy())):
y_vals[y] += diff
for i in range(len(x_vals)):
board[y_vals[i]][x_vals[i]] = 1
game(0, load_board=board, rescan=True)
def numerical_col_processing(numeric_column_names, dataset_df):
for col_name in numeric_column_names:
value_list = list(dataset_df[col_name])
value_list.sort()
max_value = dataset_df[col_name].max()
min_value = dataset_df[col_name].min()
first_median = statistics.median(value_list)
break_index = 0
temp_list1 = []
for i in value_list:
if i < first_median:
temp_list1.append(i)
elif i == first_median:
temp_list1.append(i)
break_index = value_list.index(i)
else:
break
second_median = statistics.median(temp_list1)
temp_list2 = []
for j in range(break_index, len(value_list)):
temp_list2.append(value_list[j])
third_median = statistics.median(temp_list2)
bins = [min_value-1, second_median, first_median, third_median, max_value+1]
group_names = [str(min_value)+"-"+str(second_median), str(second_median)+"-"+str(first_median), str(first_median)+"-"+str(third_median), str(third_median)+"-"+str(max_value)]
dataset_df[col_name] = pd.cut(dataset_df[col_name], bins, labels=group_names)
return dataset_df
def get_pivot(a: list):
l = len(a)
if l >= 9:
return statistics.median([a[i * (l // 9)] for i in range(9)])
if l >= 3:
return statistics.median([a[i * (l // 3)] for i in range(3)])
return a[0]
def parse_plaintext(pattern):
lines = repr(pattern).split(r'\r\n')
x_vals = []
y_vals = []
board = new_array()
cell_block_start = [i for i in range(len(lines)) if lines[i][0:1] != '!' and lines[i][0:2] != "'!"][0]
for y in range(cell_block_start, len(lines)):
for x in range(len(lines[y])):
if lines[y][x] == "O":
x_vals.append(x)
y_vals.append(y)
w_padding = (width - len(set(x_vals))) // 2
h_padding = (height - len(set(y_vals))) // 2
if floor(median(x_vals)) < w_padding:
diff = (floor(median(x_vals)) * -1) + w_padding
for x in range(len(x_vals.copy())):
x_vals[x] += diff
if floor(median(y_vals)) < h_padding:
diff = floor((median(y_vals)) * -1) + h_padding
for y in range(len(y_vals.copy())):
y_vals[y] += diff
for i in range(len(x_vals)):
board[y_vals[i]][x_vals[i]] = 1
game(0, load_board=board, rescan=True)
def googlemap_position(request, trackerID):
pk = trackerID.split(":")[0]
current_user = request.user
horsetracker = get_object_or_404(HorseTracker, pk=pk)
horsedata = HorseData.objects.filter(tracker=horsetracker).order_by('-date')
if( horsetracker.user != current_user ):
raise Http404
#convert strings to float, int
latitude = horsedata.values('latitude')
longitude = horsedata.values('longitude')
temperature = horsedata.values('temperature')
latitude_list = [x['latitude'] for x in latitude]
longitude_list = [x['longitude'] for x in longitude]
temperature_list = [x['temperature'] for x in temperature]
latCenter = statistics.median(latitude_list)#6216576
lonCenter = statistics.median(longitude_list)#1717866
#step = 3
points=[ dict(latitude=str(latCenter),
longitude=str(lonCenter),
value2=str(0) )]
counter = 0
for i in range(len(latitude_list)):
points.append( dict(latitude=str(latitude_list[i]), longitude=str(longitude_list[i])))
return render(request, 'googlemap_position.html', {
'horsetracker': horsetracker,
'horsedatas': horsedata,
'points': points })
def find_medians(self):
"""
Find true_median, high_median, low_median.
"""
# find median
self.true_median = statistics.median(self.data_list)
# find low_median, high_median
# If input list is even
if len(self.data_list) % 2 == 0:
low_half = [self.data_list[val] for val in
range(len(self.data_list) // 2 - 1)]
top_half = [self.data_list[val2] for val2 in
range(len(self.data_list) // 2 + 1,
len(self.data_list))]
print(low_half, top_half)
self.low_median = statistics.median(low_half)
self.high_median = statistics.median(top_half)
# If input list is odd
elif len(self.data_list) % 2 != 0:
low_half = [self.data_list[val] for val in
range(len(self.data_list) // 2)]
top_half = [self.data_list[val] for val in
range(len(self.data_list) // 2 + 1,
len(self.data_list))]
print(low_half, top_half, sep='\n')
self.low_median = statistics.median(low_half)
self.high_median = statistics.median(top_half)
return self.true_median, self.low_median, self.high_median
def write_result_avg_rand_planner(problem, params, simulations, file_obj_avg):
# About this simulation
to_write = problem.name
to_write += "\t{}\t{}\t{}".format(params.planner.name, params.model.__name__, params.coc)
# Results
avg_cost = 1.0 * sum([s.get_total_cost() for s in simulations]) /len(simulations)
to_write += '\t' + str(avg_cost)
avg_obs = 1.0 * sum([s.total_observations() for s in simulations])/len(simulations)
to_write += '\t' + str(avg_obs)
avg_msg_sent = 1.0 * sum([s.total_messages_sent() for s in simulations])/len(simulations)
to_write += '\t' + str(avg_msg_sent)
avg_msg_void = 1.0 * sum([s.total_messages_voided() for s in simulations])/len(simulations)
to_write += '\t' + str(avg_msg_void)
avg_steps = 1.0 * sum([s.total_steps() for s in simulations])/len(simulations)
to_write += '\t' + str(avg_steps)
# Median Results
avg_cost = 1.0 * statistics.median([s.get_total_cost() for s in simulations])
to_write += '\t' + str(avg_cost)
avg_obs = 1.0 * statistics.median([s.total_observations() for s in simulations])
to_write += '\t' + str(avg_obs)
avg_msg_sent = 1.0 * statistics.median([s.total_messages_sent() for s in simulations])
to_write += '\t' + str(avg_msg_sent)
avg_msg_void = 1.0 * statistics.median([s.total_messages_voided() for s in simulations])
to_write += '\t' + str(avg_msg_void)
avg_steps = 1.0 * statistics.median([s.total_steps() for s in simulations])
to_write += '\t' + str(avg_steps)
to_write += '\t' + str(len(simulations))
file_obj_avg.write(to_write + '\n')
file_obj_avg.flush()
def addDataToPlt(fig, ax, dates, diff, c = 'c', label="raw", isMultiple=True):
assert len(dates) == len(diff), "Plot and data are of different lenght"
label1 = "average of 3"
label2 = "average of 7"
med3 = [i for i in diff]
med7 = [i for i in diff]
for i in range(3, len(diff) - 4):
if i > 2 and i < len(diff) - 4:
med7[i] = stats.median(diff[i-3:i+3])
if i > 0 and i < len(diff) - 2:
med3[i] = stats.median(diff[i-1:i+2])
marker = "o"
if len(diff) > 200:
marker = "."
if not isMultiple:
if len(diff) > 1 and stats.stdev(diff) > 0.1:
logger.error("Why do you have a high stdev?" + str(stats.stdev(diff)))
marker = "x"
ax.plot_date(dates, diff, c, xdate=True, marker = marker, linestyle="", label=label)
if isMultiple:
ax.plot_date(dates, med3, 'b', xdate=True, marker = ".", linestyle="", label=label1)
ax.plot_date(dates, med7, 'r', xdate=True, marker = ".", linestyle="", label=label2)
ax.xaxis.set_major_locator(matplotlib.dates.HourLocator())
ax.xaxis.set_major_formatter(matplotlib.dates.DateFormatter("%H:00"))
ax.xaxis.set_minor_locator(matplotlib.dates.MinuteLocator())
ax.autoscale_view()
fig.autofmt_xdate()
ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
def stats(responses, last=100):
def t(s):
return ("\t" + s).ljust(20)
def f(s):
return "{:.2f}ms".format(s * 1000)
values = responses
if len(values) < 3:
print("\tNot enough data")
return
if len(values) > last:
print(t("COUNT"), len(values), "(but only using the last {})".format(last))
values = values[-last:]
else:
print(t("COUNT"), len(values))
if any([x["cache"] for x in values]):
hits = len([x for x in values if x["cache"] == "HIT"])
misses = len([x for x in values if x["cache"] == "MISS"])
print(t("HIT RATIO"), "{:.1f}%".format(100 * hits / (hits + misses)))
print(t("AVERAGE (all)"), f(statistics.mean([x["took"] for x in values])))
print(t("MEDIAN (all)"), f(statistics.median([x["took"] for x in values])))
try:
print(
t("AVERAGE (misses)"),
f(statistics.mean([x["took"] for x in values if x["cache"] == "MISS"])),
)
print(
t("MEDIAN (misses)"),
f(
statistics.median(
[x["took"] for x in values if x["cache"] == "MISS"]
)
),
)
print(
t("AVERAGE (hits)"),
f(statistics.mean([x["took"] for x in values if x["cache"] == "HIT"])),
)
print(
t("MEDIAN (hits)"),
f(
statistics.median(
[x["took"] for x in values if x["cache"] == "HIT"]
)
),
)
except statistics.StatisticsError as exc:
print(exc)
else:
hits = len([x for x in values if x["link"]])
misses = len([x for x in values if not x["link"]])
print(t("HIT RATIO"), "{:.1f}%".format(100 * hits / (hits + misses)))
print(t("AVERAGE"), f(statistics.mean([x["took"] for x in values])))
print(t("MEDIAN"), f(statistics.median([x["took"] for x in values])))
with open("cdn-crawler-stats.json", "w") as f:
json.dump(responses, f, indent=3)
def resetPass(customCommand,test=False):
from random import sample as randomize
from random import random
from os.path import exists
# Opens the Adj, Adv, and Noun files as arrays
av = open(sys.path[0]+"/Adv").read().splitlines()
aj = open(sys.path[0]+"/Adj").read().splitlines()
nn = open(sys.path[0]+"/Noun").read().splitlines()
# Just for fun, some statistics!
totalCombos = len(av)*len(aj)*len(nn)
combosFormatted = "{:,}".format(totalCombos)
avLengths=[]
for item in av:
avLengths.append(len(item))
ajLengths=[]
for item in aj:
ajLengths.append(len(item))
nnLengths=[]
for item in nn:
nnLengths.append(len(item))
from statistics import mean,median,mode
print("-"*25+"\n"+
"Total adverbs: "+str(len(av))+"\n"+
"Total adjectives: "+str(len(aj))+"\n"+
"Total nouns: "+str(len(nn))+"\n"+
"Total possible combinations: "+combosFormatted+" (not factoring in numbers)\n"+
"Shortest possible passphrase length: "+str(min(avLengths)+min(ajLengths)+min(nnLengths))+"\n"+
"Longest possible passphrase length: "+str(max(avLengths)+max(ajLengths)+max(nnLengths)+5)+"\n"+
"Mean passphrase length: "+str(int(mean(avLengths)+mean(ajLengths)+mean(nnLengths)+4))+"\n"+
"Median passphrase length: "+str(int(median(avLengths)+median(ajLengths)+median(nnLengths))+4)+"\n"+
"Mode passphrase length: "+str(int(mode(avLengths)+mode(ajLengths)+mode(nnLengths))+4)+"\n"+
"-"*25)
# Randomize the order of the arrays
av = randomize(av,len(av))
aj = randomize(aj,len(aj))
nn = randomize(nn,len(nn))
# Pick a random word from each randomized array
newAdverb = av[int(random()*len(av))].capitalize()
newAdjective = aj[int(random()*len(aj))].capitalize()
newNoun = nn[int(random()*len(nn))].capitalize()
# Possibly add a random number from 1 to 10,000
if maybeNumber():
from math import ceil
number = str(ceil(random()*10000))
else:
number = ''
# Assemble the passphrase
newPassphrase = number+newAdverb+newAdjective+newNoun
#################################################################### Needs attention
print("The new passphrase will be: "+newPassphrase)
print("Total entropy: ~"+str(int(entropy(newPassphrase))))
if customCommand == ' {PASSPHRASE}':
print("Password display command not found. Aborting.")
exit()
if not test:
import RouterPasswording
RouterPasswording.newPassphrase(newPassphrase)
from os import system as execute
execute(customCommand.replace("{password}",newPassphrase).replace("{passphrase}",newPassphrase))
def run(parser, args):
if args.full_tsv:
files = 0
basecalled_files = 0
stats = defaultdict(list)
for fast5 in Fast5File.Fast5FileSet(args.files):
files += 1
fas = fast5.get_fastas_dict()
if len(fas) > 0:
basecalled_files += 1
for category, fa in fas.iteritems():
if fa is not None:
stats[category].append(len(fa.seq))
if category == 'twodirections':
if fast5.is_high_quality():
stats['2D_hq'].append(len(fa.seq))
fast5.close()
print "files\ttotal reads\t%d" % (files)
print "files\ttotal base-called reads\t%d" % (basecalled_files)
for category in sorted(stats.keys()):
sizes = stats[category]
if len(sizes) > 0:
print "%s\ttotal reads\t%d" % (category, len(sizes))
print "%s\ttotal base pairs\t%d" % (category, sum(sizes))
print "%s\tmean\t%.2f" % (category, stat.mean(sizes))
print "%s\tmedian\t%d" % (category, stat.median(sizes))
print "%s\tmin\t%d" % (category, min(sizes))
print "%s\tmax\t%d" % (category, max(sizes))
nxvalues = stat.NX(sizes, [25,50,75])
print "%s\tN25\t%d" % (category, nxvalues[25])
print "%s\tN50\t%d" % (category, nxvalues[50])
print "%s\tN75\t%d" % (category, nxvalues[75])
else:
logger.warning("No valid sequences observed.\n")
else:
sizes = []
for fast5 in Fast5File.Fast5FileSet(args.files, group=args.group):
fas = fast5.get_fastas(args.type)
sizes.extend([len(fa.seq) for fa in fas if fa is not None])
fast5.close()
if len(sizes) > 0:
print "total reads\t%d" % (len(sizes))
print "total base pairs\t%d" % (sum(sizes))
print "mean\t%.2f" % (stat.mean(sizes))
print "median\t%d" % (stat.median(sizes))
print "min\t%d" % (min(sizes))
print "max\t%d" % (max(sizes))
nxvalues = stat.NX(sizes, [25,50,75])
print "N25\t%d" % (nxvalues[25])
print "N50\t%d" % (nxvalues[50])
print "N75\t%d" % (nxvalues[75])
else:
logger.warning("No valid sequences observed.\n")
def indexEvolution_by_year(year):
area_repo = AreaRepository(recreate_db=False, config=sqlite_config)
indicator_repo = IndicatorRepository(recreate_db=False, config=sqlite_config)
observation_repo = ObservationRepository(recreate_db=False, area_repo=area_repo, indicator_repo=indicator_repo,
config=sqlite_config)
index_indicator = indicator_repo.find_indicators_index()[0]
observations = observation_repo.find_tree_observations(index_indicator.indicator, 'ALL', None, 'COMPONENT')
areas = area_repo.find_countries(order="iso3")
data = {'year': year, 'areas': OrderedDict(), 'stats': OrderedDict()}
for area in sorted(areas, key=attrgetter('iso3')):
for obs in sorted([obs for obs in observations if obs.area.iso3 == area.iso3],
key=lambda o: o.indicator.indicator):
if area.iso3 not in data['areas']:
data['areas'][area.iso3] = OrderedDict()
if obs.indicator.indicator not in data['areas'][area.iso3]:
data['areas'][area.iso3][obs.indicator.indicator] = OrderedDict()
if obs.year == int(year):
data['areas'][area.iso3][obs.indicator.indicator]['value'] = obs.value
if obs.indicator.type == 'INDEX':
data['areas'][area.iso3][obs.indicator.indicator]['rank'] = obs.rank
data['areas'][area.iso3][obs.indicator.indicator]['rank_change'] = obs.rank_change
if obs.indicator.type == 'INDEX':
if 'score_evolution' not in data['areas'][area.iso3][obs.indicator.indicator]:
data['areas'][area.iso3][obs.indicator.indicator]['score_evolution'] = []
# data['areas'][area.iso3][obs.indicator.indicator]['value_evolution'] = []
data['areas'][area.iso3][obs.indicator.indicator]['score_evolution'].append(
{'year': obs.year, 'value': obs.value})
# data['areas'][area.iso3][obs.indicator.indicator]['value_evolution'].append(
# {'year': obs.year, 'value': obs.value})
# Clean areas without data that year
for area in list(data['areas'].keys()):
if 'value' not in data['areas'][area]['ODB']:
del data['areas'][area]
for indicator_code in sorted(set([o.indicator.indicator for o in observations])):
per_indicator_obs = [o.value for o in observations if
o.indicator.indicator == indicator_code and o.value is not None]
if indicator_code not in data['stats']:
data['stats'][indicator_code] = OrderedDict()
data['stats'][indicator_code][':::'] = OrderedDict()
data['stats'][indicator_code][':::']['mean'] = statistics.mean(per_indicator_obs)
data['stats'][indicator_code][':::']['median'] = statistics.median(per_indicator_obs)
for region in area_repo.find_regions():
per_region_obs = [o.value for o in observations if
o.indicator.indicator == indicator_code and o.value is not None and o.area.iso3 in [c.iso3
for c
in
region.countries]]
data['stats'][indicator_code][region.iso3] = OrderedDict()
data['stats'][indicator_code][region.iso3]['mean'] = statistics.mean(per_region_obs)
data['stats'][indicator_code][region.iso3]['median'] = statistics.median(per_region_obs)
return json_response_ok(request, data)
def caculation(data):
trt_1 = data[data['trt'] == 1]
trt_0 = data[data['trt'] == 0]
medi = statistics.median(trt_1['y']) - statistics.median(trt_0['y'])
mean = statistics.mean(trt_1['y']) - statistics.mean(trt_0['y'])
peop = len(trt_1) + len(trt_0)
vari = statistics.variance(trt_1['y']) + statistics.variance(trt_0['y'])
z_stat, p_val = stats.ranksums(trt_0['y'], trt_1['y'])
return [medi, mean, peop, p_val]
def median_fn(srs):
a=[x for x in srs.pop()]
if len(a)%2:
srs.push(a[len(a)//2])
else:
if all([isinstance(x, str) for x in a[len(a)//2-1:][:2]]):
med = median(map(ord,a))
srs.push(chr(int(med)))
else:
srs.push(median(a))
def getMedianAverageCenterIndexOfJongmokGroup(jongmokgroup):
coll주식종목Data = pymongo.MongoClient('localhost', 27017).get_database("xadb").get_collection("주식종목Data")
dictdictdictret = {}
listproj = ["PER", "PBR", "EPS", "ROA", "ROE", "EVEBITDA", "SPS","CPS","BPS","PEG"]
#make the project for find_one()
dictproj ={}
for proj in listproj :
dictproj[proj] = 1
dictproj["_id"] = 0
for keygroup in jongmokgroup :
print("making median, average,.. of %s"%keygroup)
listjongmokhan = jongmokgroup[keygroup]
# dictproj = {"PER":1, "PBR":1, "EPS":1, "ROA":1, "ROE":1, "EVEBITDA":1, "SPS":1,"CPS":1,"BPS":1,"PEG":1, "_id":0}
listPER = []
listPBR = []
listEPS = []
listROA = []
listROE = []
listEVEBITDA = []
listSPS = []
listCPS = []
listBPS = []
listPEG = []
for jongmokhan in listjongmokhan :
dictcondi = {'종목명':jongmokhan }
objret = coll주식종목Data.find_one(dictcondi, dictproj)
if objret == None:
continue
listPER.append(objret["PER"])
listPBR.append(objret["PBR"])
listEPS.append(objret["EPS"])
listROA.append(objret["ROA"])
listROE.append(objret["ROE"])
listEVEBITDA.append(objret["EVEBITDA"])
listSPS.append(objret["SPS"])
listCPS.append(objret["CPS"])
listBPS.append(objret["BPS"])
listPEG.append(objret["PEG"])
dictdictdictret[keygroup] = \
{"PER":{"min":min(listPER), "max":max(listPER), "median":stat.median(listPER), "mean":stat.mean(listPER), "stdev":stat.stdev(listPER, stat.mean(listPER))},
"PBR":{"min":min(listPBR), "max":max(listPBR), "median":stat.median(listPBR), "mean":stat.mean(listPBR), "stdev":stat.stdev(listPBR, stat.mean(listPBR))},
"EPS":{"min":min(listEPS), "max":max(listEPS), "median":stat.median(listEPS), "mean":stat.mean(listEPS), "stdev":stat.stdev(listEPS, stat.mean(listEPS))},
"ROA":{"min":min(listROA), "max":max(listROA), "median":stat.median(listROA), "mean":stat.mean(listROA), "stdev":stat.stdev(listROA, stat.mean(listROA))},
"ROE":{"min":min(listROE), "max":max(listROE), "median":stat.median(listROE), "mean":stat.mean(listROE), "stdev":stat.stdev(listROE, stat.mean(listROE))},
"EVEBITDA":{"min":min(listEVEBITDA), "max":max(listEVEBITDA), "median":stat.median(listEVEBITDA), "mean":stat.mean(listEVEBITDA), "stdev":stat.stdev(listEVEBITDA, stat.mean(listEVEBITDA))},
"SPS":{"min":min(listSPS), "max":max(listSPS), "median":stat.median(listSPS), "mean":stat.mean(listSPS), "stdev":stat.stdev(listSPS, stat.mean(listSPS))},
"CPS":{"min":min(listCPS), "max":max(listCPS), "median":stat.median(listCPS), "mean":stat.mean(listCPS), "stdev":stat.stdev(listCPS, stat.mean(listCPS))},
"BPS":{"min":min(listBPS), "max":max(listBPS), "median":stat.median(listBPS), "mean":stat.mean(listBPS), "stdev":stat.stdev(listBPS, stat.mean(listBPS))},
"PEG":{"min":min(listPEG), "max":max(listPEG), "median":stat.median(listPEG), "mean":stat.mean(listPEG), "stdev":stat.stdev(listPEG, stat.mean(listPEG))}
}
return dictdictdictret, listproj, ["min", "max", "median", "mean", "stdev"]
def grid_detect(rt):
global inter_count
avg_w = statistics.median([s[1][0] for s in rt])
avg_h = statistics.median([s[1][1] for s in rt])
merp={}
for r in rt: # n
coll = place_rect(r,avg_w*3,avg_h*3, merp)
if coll is not None:
return coll
#print(inter_count)
return None
def store_data(filename, results, iters):
import statistics
results_sorted = sorted(results)
file = open(filename, 'w+')
for f in results_sorted:
file.write('-' * 20 + '\n')
file.write(f + '\n')
file.write('Iters: ' + str(statistics.median(iters[f])) + '\n')
file.write(str(statistics.median(results[f]))+ '\n')
file.write('-' * 20+ '\n')
file.close()
def on_frame(self, controller):
frame = controller.frame()
previous = controller.frame(1) #The previous frame
for hand in frame.hands:
handType = "Left Hand" if hand.is_left else "Right Hand"
linear_hand_movement = hand.translation(previous)
LocationGlobalRelativeLeap=linear_hand_movement
#print handType + " Hand ID: " + str(hand.id) + " Palm Position: " + str(hand.palm_position)
normal = hand.palm_normal
direction = hand.direction
print LocationGlobalRelativeLeap.x
print LocationGlobalRelativeLeap.y
print LocationGlobalRelativeLeap.z
print ""
global x
global y
global z
x=float(LocationGlobalRelativeLeap.x)
xData.append(x)
z=float(LocationGlobalRelativeLeap.y)
zData.append(z)
y=float(LocationGlobalRelativeLeap.z)
yData.append(y)
x=statistics.median(xData)
y=statistics.median(yData)
z=statistics.median(zData)
if abs(x)>abs(y) and abs(x)>abs(z):
x=x
y=0
z=0
elif abs(y)>abs(x) and abs(y)>abs(z):
y=y
x=0
z=0
elif abs(z)>abs(x) and abs(z)>abs(y):
z=z
x=0
y=0
else:
x=0
y=0
z=0
return x
return y
return z
print x, y, z
def detect_breaks(self):
_,thr = cv2.threshold(self.gray,214,255,cv2.THRESH_BINARY)
_,con,_ = cv2.findContours(thr,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
squares=[c for c in con if self._contour_is_square(c) and cv2.contourArea(c)>=16]
if not squares:
return ([],[])
a=statistics.median(cv2.contourArea(c) for c in squares)
p=statistics.median(cv2.arcLength(c,True) for c in squares)
blanks=[c for c in con if abs(cv2.contourArea(c)-a)<.1*a and abs(cv2.arcLength(c,True)-p)<.05*p]
dist=int(p/8)
yc = sorted({c[0,1] for s in blanks for c in s})
xc = sorted({c[0,0] for s in blanks for c in s})
return (self._squares_to_breaks(yc,dist),self._squares_to_breaks(xc,dist))
def without_outliers(iterator):
#
# Discard major outliers
# (Explanation from: http://www.wikihow.com/Calculate-Outliers)
#
numbers = [i for i in iterator if i > 0]
q2 = statistics.median(numbers)
q1 = statistics.median(n for n in numbers if n < q2)
q3 = statistics.median(n for n in numbers if n > q2)
interquartile = q3 - q1
inner_offset = interquartile * 1.5 # inner fence; use 3.0 for outer fence
lower_fence, higher_fence = q1 - inner_offset, q3 + inner_offset
return [n for n in numbers if lower_fence <= d <= higher_fence]
def write_result_by_sim_params(sim_params, problem_params, simulations, file_obj):
# Planner Model CoC
to_write = "{}\t{}\t{}".format(sim_params.planner.name, sim_params.model.__name__, sim_params.coc)
# Problem Params: boardx, y, num_soil, num_rocks, rand_range, a_prob
for p in problem_params.get_params():
to_write += '\t{}'.format(p)
# Avg Cost
avg_cost = sum([sim.get_total_cost() for sim in simulations])/len(simulations)
to_write += '\t' + str(avg_cost)
# Median Cost
md_cost = statistics.median([sim.get_total_cost() for sim in simulations])
to_write += '\t' + str(md_cost)
# Num Problems Avged
to_write += '\t' + str(len(simulations))
# Other misc: average observations made; avg messages sent; avg steps take; useful for comparing board-sizes
avg_obs = 1.0 * sum([s.total_observations() for s in simulations])/len(simulations)
to_write += '\t' + str(avg_obs)
avg_msg_sent = 1.0 * sum([s.total_messages_sent() for s in simulations])/len(simulations)
to_write += '\t' + str(avg_msg_sent)
avg_msg_void = 1.0 * sum([s.total_messages_voided() for s in simulations])/len(simulations)
to_write += '\t' + str(avg_msg_void)
avg_steps = 1.0 * sum([s.total_steps() for s in simulations])/len(simulations)
to_write += '\t' + str(avg_steps)
# Other misc: medians
# Other misc: average observations made; avg messages sent; avg steps take; useful for comparing board-sizes
avg_obs = 1.0 * statistics.median([s.total_observations() for s in simulations])
to_write += '\t' + str(avg_obs)
avg_msg_sent = 1.0 * statistics.median([s.total_messages_sent() for s in simulations])
to_write += '\t' + str(avg_msg_sent)
avg_msg_void = 1.0 * statistics.median([s.total_messages_voided() for s in simulations])
to_write += '\t' + str(avg_msg_void)
avg_steps = 1.0 * statistics.median([s.total_steps() for s in simulations])
to_write += '\t' + str(avg_steps)
file_obj.write(to_write + '\n')
file_obj.flush()
def get_sensor_data(self):
Tools.log("Buffer:" + str(self.sensor_buffer))
try:
sensor_data = {"sensors": {}, "recordTimestamp": {}}
sensor_data["sensors"]["flow"] = sum(self.sensor_buffer["flow"])
sensor_data["sensors"]["sound"] = statistics.median(self.sensor_buffer["sound"])
sensor_data["sensors"]["ultrasonic"] = statistics.median(self.sensor_buffer["ultrasonic"])
sensor_data["sensors"]["temp"] = statistics.mean(self.sensor_buffer["temp"])
sensor_data["sensors"]["humidity"] = statistics.mean(self.sensor_buffer["humidity"])
sensor_data["recordTimestamp"] = Tools.now_int_epoch()
Tools.log("Data to send:" + str(sensor_data))
GLOBALS["errorCount"] -= 0.5
except Exception, e:
Tools.log("Error caculating data: %s" % str(e), 1)
def write_profile(profile_f, dependents, profile, batch_size):
profile_f.write("Extracting {0} values:\n".format(len(dependents)))
for dependent in dependents:
profile_f.write("* `{0}`\n".format(dependent))
profile_f.write("\n".format(batch_size))
profile_f.write("Batch size: {0}\n\n".format(batch_size))
table = tabulate(
[('batch_extractions', len(profile['per_batch_duration'])),
('total_time', round(sum(profile['per_batch_duration']), 3)),
('min_time', round(min(profile['per_batch_duration']), 3)),
('max_time', round(max(profile['per_batch_duration']), 3)),
('mean_time', round(mean(profile['per_batch_duration']), 3)),
('median_time', round(median(profile['per_batch_duration']), 3))],
headers=["stat", "value"],
tablefmt="pipe"
)
profile_f.write(table + "\n\n")
del profile['per_batch_duration']
feature_profiles = []
datasource_profiles = []
misc_profiles = []
for dependent_name, durations in profile.items():
row = (dependent_name.replace("<", "\<").replace(">", "\>"),
len(durations),
round(min(durations), 3),
round(max(durations), 3),
round(mean(durations), 3),
round(median(durations), 3))
if "feature." in dependent_name:
feature_profiles.append(row)
elif "datasource." in dependent_name:
datasource_profiles.append(row)
else:
misc_profiles.append(row)
if len(feature_profiles) > 0:
profile_f.write("# Features\n")
write_dependent_profiles(profile_f, feature_profiles)
if len(datasource_profiles) > 0:
profile_f.write("# Datasources\n")
write_dependent_profiles(profile_f, datasource_profiles)
if len(misc_profiles) > 0:
profile_f.write("# Misc\n")
write_dependent_profiles(profile_f, misc_profiles)
def filter_outliers(data, stdev_factor=2.5):
#stdev_factor - how many stdevs from the median is still legit
if not data: #empty
return data
med = statistics.median(data)
#filter extreme outliers
error = [abs(x-med) for x in data]
max_error = statistics.median(error)*5 #5 seems like enough
data = [x for x in data if abs(x-med) < max_error]
#filter outliers
if len(data) > 1: #statistics.stdev only works for two or more elements
stdev = statistics.stdev(data)
return [v for v in data if abs(med-v) < stdev_factor*stdev]
else:
return data
def cleanup(G, descript, algo_directed, algo_simple):
'''
GRAPH Cleaning: Sometimes the graphs need to be cleaned for certain type of algorithms.
The idea here is that we are trying to best match the data to what the algorithm can do.
We start with specific matches and work our way to more general.
'''
#first we check if algo and data have same directedness and type.
if G.is_directed() == algo_directed and G.is_simple() == algo_simple:
print("\t[Info - ", descript, "] - No graph cleaning required directed: ", algo_directed, " simple: ", algo_simple)
weight_attr = "weight" if G.is_weighted() else None
return G, weight_attr
collapsed = False
directed_graph = G.is_directed()
if algo_directed and not G.is_directed():
print("\t[Info - ", descript, "] - Warning: Passing undirected graph to directed algo")
#otherwise we need to make some mods to the graph, so we will copy it then make the mods
G_copy = G.copy()
#if the graph is directed and algo is not directed
if G.is_directed() and not algo_directed:
#can't collapse on weight without first making sure the edges are weighted
#In this case, we just give each edge a weight of 1
if not G_copy.is_weighted():
G_copy.es()['weight'] = 1
#here we make the actual conversion
G_copy.to_undirected(combine_edges={'weight':sum})
print('\t[Info - ',descript,'] Converting graph to undirected (summing edge weights)')
collapsed = True
#if the algo is simple but the data is not, then we have to make the data simple
if algo_simple and not G.is_simple():
#can't collapse on weight without first making sure the edges are weighted
if not G.is_weighted():
G_copy.es()['weight'] = 1
G_copy.simplify(combine_edges={'weight':sum})
print('\t[Info - ',descript,'] Collapsed multigraph edges (summing edge weights)')
collapsed = True
if collapsed == True:
weights = G_copy.es()['weight']
#print("MEDIAN: ", statistics.median(weights), " MAX: ", max(weights))
threshold = statistics.median(weights)
orig_edge_len = G_copy.ecount()
edges = G_copy.es.select(weight_lt=threshold)
G_copy.delete_edges(edges)
print("\t[Info - ", descript,"] Pruned ", len(edges)," of ",orig_edge_len," edges less than weight of ", threshold)
#if the graph is collapsed, I think it becomes undirected
directed_graph = False
#we could do this outside the function, but it makes it cleaner this way
weights_attr = "weight" if G_copy.is_weighted() else None
return G_copy, weights_attr
def async_update(self):
"""Get the latest data and updates the states."""
if self._max_age is not None:
self._purge_old()
if not self.is_binary:
try: # require only one data point
self.mean = round(statistics.mean(self.states), 2)
self.median = round(statistics.median(self.states), 2)
except statistics.StatisticsError as err:
_LOGGER.error(err)
self.mean = self.median = STATE_UNKNOWN
try: # require at least two data points
self.stdev = round(statistics.stdev(self.states), 2)
self.variance = round(statistics.variance(self.states), 2)
except statistics.StatisticsError as err:
_LOGGER.error(err)
self.stdev = self.variance = STATE_UNKNOWN
if self.states:
self.count = len(self.states)
self.total = round(sum(self.states), 2)
self.min = min(self.states)
self.max = max(self.states)
self.change = self.states[-1] - self.states[0]
self.average_change = self.change
if len(self.states) > 1:
self.average_change /= len(self.states) - 1
if self._max_age is not None:
self.max_age = max(self.ages)
self.min_age = min(self.ages)
else:
self.min = self.max = self.total = STATE_UNKNOWN
self.average_change = self.change = STATE_UNKNOWN
def print_stats(l): # noqa: C901
try:
print("\tMean: {}".format(mean(l)))
except StatisticsError as e:
print("\tMean: {}".format(str(e)))
try:
print("\tMedian: {}".format(median(l)))
except StatisticsError as e:
print("\tMedian: {}".format(str(e)))
try:
print("\tMode: {}".format(mode(l)))
except StatisticsError as e:
print("\tMode: {}".format(str(e)))
try:
print("\tMax: {}".format(max(l)))
except StatisticsError as e:
print("\tMax: {}".format(str(e)))
try:
print("\tMin: {}".format(min(l)))
except StatisticsError as e:
print("\tMin: {}".format(str(e)))
if went_in_progress(jDetails):
prgDate = jrn.created_on
#print("Went in progress: " + str(prgDate))
break
leadTime = endDate - crtDate
#print("Lead time " + str(leadTime))
leadList.append(leadTime.days)
if prgDate:
cycTime = endDate - prgDate
#print("Cycle time: " + str(cycTime))
cycleList.append(cycTime.days)
meanCycTime = statistics.mean(cycleList)
medianCycTime = statistics.median(cycleList)
meanLeadTime = statistics.mean(leadList)
medianLeadTime = statistics.median(leadList)
print("Mean cycle time: " + str(meanCycTime))
print("Median cycle time: " + str(medianCycTime))
print("Minimum cycle time: " + str(min(cycleList)))
print("Maximum cycle time: " + str(max(cycleList)))
print("Mean lead time: " + str(meanLeadTime))
print("Median lead time: " + str(medianLeadTime))
print("Minimum lead time: " + str(min(leadList)))
print("Maximum lead time: " + str(max(leadList)))
print("Amount of tickets: " + str(len(u_tickets)))
# this formatter will label the colorbar with the correct target names
formatter = plt.FuncFormatter(lambda i, *args: iris.target_names[int(i)])
plt.figure(figsize=(5, 4))
plt.scatter(iris.data[:, x_index], iris.data[:, y_index], c=iris.target)
plt.colorbar(ticks=[0, 1, 2], format=formatter)
plt.xlabel(iris.feature_names[x_index])
plt.ylabel(iris.feature_names[y_index])
plt.tight_layout()
plt.show()
# Medidas
import statistics
from scipy import stats as st
media = statistics.mean(x)
media2 = sum(x) / len(x)
mediana = statistics.median(x)
amplitude = max(x) - min(x)
variancia = statistics.variance(x)
desvio_padrao = statistics.stdev(x)
coeficente_variacao = st.variation(x)
# Quartil
q1 = np.quantile(x, 0.25)
q2 = np.quantile(x, 0.50)
q3 = np.quantile(x, 0.75)
# Boxplot
plt.title('Boxplot')
plt.boxplot(x, vert=False)
plt.show()
import statistics
t = int(input())
for _ in range(t):
n = int(input())
arr = list(map(int, input().split()))
b = [arr[0], arr[1], arr[2]]
while len(arr) != 2:
arr.remove(statistics.median(b))
if len(arr) == 2:
break
b = [arr[0], arr[1], arr[2]]
print(arr[0], arr[1])
def loop(self):
num_reqs = 0
bad_calls = 0
start = time.time()
res_time = []
# Print some bullshit
print("Testing {0}".format(self.uri))
print(
"{0} seconds between requests with a maximum of {1} loops.".format(
self.sleep, self.limit))
if not self.asyncr:
print("Running in non-asyncronous request mode.\n")
if self.asyncr:
print("Running in asyncronous mode.\n")
while True:
try:
if not self.asyncr:
num_reqs += 1
# fire off the request
try:
response_timer_init = time.time()
req = requests.get(self.uri)
response_timer_quit = (time.time() -
response_timer_init)
res_time.append(response_timer_quit)
# return request
if req.status_code != requests.codes.ok:
bad_calls += 1
print(".", end=" ", flush=True)
# Back off if requested by the --sleep option
if int(self.sleep) > 0:
time.sleep(int(self.sleep))
# Kill after the number of loops has been exceeded.
if int(self.limit) > 0:
if int(num_reqs) == int(self.limit):
raise ValueError
except requests.exceptions.ConnectionError:
print(
"Cannot find a website listening at {0} on port {1}. Aborting."
.format(self.uri, "0"))
break
if self.asyncr:
try:
raise NotImplementedError
except NotImplementedError:
print(
"Sorry. Async mode hasn't been implemented yet. Bad dev! No biscuit!"
)
sys.exit(1)
except (KeyboardInterrupt, ValueError):
print("\n\nReceived interrupt. Quitting.")
# Post analysis
end = (time.time() - start)
print(
"Made {0} requests to {1} in {2} seconds with {3} bad status codes\n"
.format(num_reqs, self.uri, end, bad_calls))
# Some stats
print("Statistics:")
print("===========")
print("{0:<22}: {1:<18} seconds".format(
"Average response time", statistics.mean(res_time)))
print("{0:<22}: {1:<18} seconds".format(
"Median response time", statistics.median(res_time)))
print("{0:<22}: {1:<18} seconds".format(
"Fastest response time", min(res_time)))
print("{0:<22}: {1:<18} seconds\n".format(
"Slowest response time", max(res_time)))
# Show headers if the option has been set
if self.headers:
headers.Headers(self.uri).lookup()
# Show DNS info if the option has been set
if self.dnsinfo:
dnskit.DNS(self.uri).lookup()
# Show IP info if the option has been set
if self.ipinfo:
ipinfo.IPInfo(self.uri).lookup()
print("")
sys.exit(0)
'''
Created on May 22, 2018
@author: berag
'''
if __name__ == '__main__':
pass
import statistics as st
print(st.mean([1, 2, 5, 9, 4, 3])) #4
print(st.median([1, 2, 5, 4])) #3.0
print(11 // 2) #5
print(11.0 // 2) #5.0
print(.1 + .1 + .1) # Not .3 its 0.30000000000000004
# https://docs.python.org/3/tutorial/floatingpoint.html
print(1 / 10) #0.1
print("I think you\'re Super Hero")
#print("String" / 2) #TypeError: unsupported operand type(s) for /: 'str' and 'int'
def full_comparision(dataset_names,
all_datasets,
showplot=False,
random_seed=None,
new_header=True,
xerr=0,
yerr=0.1,
save_models=True):
res_df = pd.DataFrame()
returned_models = dict()
figures = []
for dataset_name in dataset_names:
problem_type, downsample_size, max_rules, realkd_reg, max_col_attr, rulefit_reg,\
test_size, repeats, pos_class, opt_max_rules = \
all_datasets[dataset_name]
(min_Cs, max_Cs, no_Cs) = rulefit_reg
(greedy_reg, opt_reg) = realkd_reg
rulefit_aucs_test = []
rulefit_aucs_train = []
realkd_greedy_aucs_test = []
realkd_greedy_aucs_train = []
realkd_optimal_aucs_test = []
realkd_optimal_aucs_train = []
seeds = []
for rep in range(repeats):
random_seed = generate_random_seed() if (
(random_seed is None) or (repeats != 1)) else random_seed
seeds.append(random_seed)
rulefit_fixed = {
'dataset_name': dataset_name,
'model_class': 'rulefit',
'objective': 'classify' if problem_type == 'c' else 'regress',
'metrics': ['roc_auc'] if problem_type == 'c' else ['r2'],
'downsample_size': downsample_size,
'seed': random_seed,
'test_size': test_size,
'pos_class': pos_class
}
realkd_fixed = {
'dataset_name': dataset_name,
'model_class': 'realkd',
'objective': 'logistic' if problem_type == 'c' else 'squared',
'metrics': ['roc_auc'] if problem_type == 'c' else ['r2'],
'downsample_size': downsample_size,
'seed': random_seed,
'test_size': test_size,
'pos_class': pos_class
}
realkd_greedy_params = {
'max_rules': max_rules,
'reg': greedy_reg,
'max_col_attr': max_col_attr,
'method': 'greedy',
'offset_rule': False
}
realkd_opt_params = {
'max_rules':
max_rules if opt_max_rules is None else opt_max_rules,
'reg': opt_reg,
'max_col_attr': max_col_attr,
'method': 'bestboundfirst',
'offset_rule': False
}
Cs_lst = np.linspace(min_Cs, max_Cs, no_Cs, endpoint=True)
Cs_lst = [np.array([Cs_lst[i]]) for i in range(len(Cs_lst))]
rulefit_params_lst = [{
'Cs': Cs,
'random_state': random_seed
} for Cs in Cs_lst]
(rulefit_x_test, rulefit_y_test), (rulefit_x_train, rulefit_y_train), rulefit_time,\
rulefit_rule_length, best_rulefit = \
rulefit_sweep(rulefit_fixed, rulefit_params_lst, max_rules)
rulefit_auc_test = np.trapz(rulefit_y_test, rulefit_x_test) / (
max(rulefit_x_test) - min(rulefit_x_test)
) # + int(problem_type == 'c'))
rulefit_auc_train = np.trapz(rulefit_y_train, rulefit_x_train) / (
max(rulefit_x_train) - min(rulefit_x_train)
) # + int(problem_type == 'c'))
rulefit_aucs_test.append(rulefit_auc_test)
rulefit_aucs_train.append(rulefit_auc_train)
best_rulefit_rules = best_rulefit.get_rules()
best_rulefit_rules = best_rulefit_rules[
best_rulefit_rules.coef != 0].sort_values("support",
ascending=False)
for idx, rule in best_rulefit_rules.iterrows():
print(('+' if rule['coef'] > 0 else '') + str(rule['coef']) +
' if ' + rule['rule'])
for i in range(len(rulefit_x_test)):
print(rulefit_x_test[i], rulefit_y_test[i])
print(rulefit_auc_test)
greedy_exp = Experiment(**realkd_fixed,
params=realkd_greedy_params)
realkd_greedy_df, greedy_model = greedy_exp.run()
greedy_rule_length = sum(greedy_exp.results['rule_lengths']) / len(
greedy_exp.results['rule_lengths'])
len_vs_perf_greedy_test = greedy_exp.results[
realkd_fixed['metrics'][0] + '_length_vs_perf' +
'_test'][int(problem_type == 'r'):]
len_vs_perf_greedy_train = greedy_exp.results[
realkd_fixed['metrics'][0] + '_length_vs_perf' +
'_train'][int(problem_type == 'r'):]
print(len_vs_perf_greedy_test)
realkd_greedy_auc_test = np.trapz(
len_vs_perf_greedy_test.values,
len_vs_perf_greedy_test.index) / (max_rules -
int(problem_type == 'r'))
realkd_greedy_auc_train = np.trapz(
len_vs_perf_greedy_train.values,
len_vs_perf_greedy_train.index) / (max_rules -
int(problem_type == 'r'))
realkd_greedy_aucs_test.append(realkd_greedy_auc_test)
realkd_greedy_aucs_train.append(realkd_greedy_auc_train)
print(realkd_greedy_auc_test)
opt_exp = Experiment(**realkd_fixed, params=realkd_opt_params)
realkd_opt_df, opt_model = opt_exp.run()
len_vs_perf_opt_test = opt_exp.results[realkd_fixed['metrics'][0] +
'_length_vs_perf' +
'_test'][int(
problem_type == 'r'):]
len_vs_perf_opt_train = opt_exp.results[realkd_fixed['metrics'][0]
+ '_length_vs_perf' +
'_train'][int(
problem_type == 'r'):]
while len_vs_perf_opt_test.index[-1] < max_rules:
len_vs_perf_opt_test.loc[len_vs_perf_opt_test.index[-1] +
1] = len_vs_perf_opt_test.values[-1]
len_vs_perf_opt_train.loc[len_vs_perf_opt_train.index[-1] +
1] = len_vs_perf_opt_train.values[-1]
print(len_vs_perf_opt_test)
realkd_opt_auc_test = np.trapz(
len_vs_perf_opt_test.values, len_vs_perf_opt_test.index) / (
max_rules - int(problem_type == 'r'))
realkd_opt_auc_train = np.trapz(
len_vs_perf_opt_train.values, len_vs_perf_opt_train.index) / (
max_rules - int(problem_type == 'r'))
realkd_optimal_aucs_test.append(realkd_opt_auc_test)
realkd_optimal_aucs_train.append(realkd_opt_auc_train)
print(realkd_opt_auc_test)
opt_rule_length = sum(opt_exp.results['rule_lengths']) / len(
opt_exp.results['rule_lengths'])
plt.errorbar(rulefit_x_test,
rulefit_y_test,
xerr=[xerr for x in rulefit_x_test],
yerr=[yerr for y in rulefit_y_test],
fmt='+',
ecolor='b',
label='rulefit')
plt.plot(rulefit_x_test, rulefit_y_test, 'b-')
plt.errorbar(len_vs_perf_greedy_test.index,
len_vs_perf_greedy_test.values,
xerr=[xerr for x in len_vs_perf_greedy_test],
yerr=[yerr for y in len_vs_perf_greedy_test],
fmt='+',
ecolor='r',
label='realkd_greedy')
plt.plot(len_vs_perf_greedy_test.index,
len_vs_perf_greedy_test.values, 'r-')
plt.errorbar(len_vs_perf_opt_test.index,
len_vs_perf_opt_test.values,
xerr=[xerr for x in len_vs_perf_opt_test],
yerr=[yerr for y in len_vs_perf_opt_test],
fmt='+',
ecolor='g',
label='realkd_opt')
plt.plot(len_vs_perf_opt_test.index, len_vs_perf_opt_test.values,
'g-')
plt.xlabel('number of rules')
plt.ylabel('roc_auc' if problem_type == 'c' else 'r2')
plt.title(dataset_name)
plt.legend()
if save_models:
to_save = [(None, realkd_fixed),
(opt_model, realkd_opt_params),
(greedy_model, realkd_greedy_params),
(None, rulefit_fixed),
(best_rulefit, {
'params': rulefit_params_lst
})]
save_dir = save_three_models(dataset_name, random_seed,
to_save)
plt.savefig(
os.path.join(save_dir, 'comparison_plot' + str(rep)))
if showplot:
plt.show()
res_dict = {
'dataset':
dataset_name,
'problem_type':
problem_type,
'no_feat':
int(realkd_opt_df['no_feat']),
'no_rows':
int(realkd_opt_df['no_rows']),
'max_rules':
max_rules,
'rulefit_auc_test':
rulefit_auc_test,
'rulefit_auc_train':
rulefit_auc_train,
'rulefit_reg':
rulefit_reg,
'rulefit_time':
rulefit_time,
'rulefit_rule_length':
rulefit_rule_length,
'greedy_auc_test':
realkd_greedy_auc_test,
'greedy_auc_train':
realkd_greedy_auc_train,
'greedy_reg':
greedy_reg,
'greedy_time':
greedy_exp.fit_time,
'greedy_rule_length':
greedy_rule_length,
'opt_auc_test':
realkd_opt_auc_test,
'opt_auc_train':
realkd_opt_auc_train,
'opt_reg':
opt_reg,
'opt_max_rules':
opt_max_rules,
'opt_time':
opt_exp.fit_time,
'opt_rule_length':
opt_rule_length,
'random_seed':
random_seed,
'model_dir':
save_dir if save_models else None,
'rulefit_len_v_perf_test': [rulefit_x_test, rulefit_y_test],
'rulefit_len_v_perf_train': [rulefit_x_train, rulefit_y_train],
'greedy_len_v_perf_test': [
len_vs_perf_greedy_test.index,
len_vs_perf_greedy_test.values
],
'greedy_len_v_perf_train': [
len_vs_perf_greedy_train.index,
len_vs_perf_greedy_train.values
],
'opt_len_v_perf_test':
[len_vs_perf_opt_test.index, len_vs_perf_opt_test.values],
'opt_len_v_perf_train':
[len_vs_perf_opt_train.index, len_vs_perf_opt_train.values]
}
fieldnames_all_runs = res_dict.keys()
with open('new_results_table.csv',
'a') as f: #datasets_perf_all_runs
all_res_csv_writer = DictWriter(f,
fieldnames=fieldnames_all_runs)
if new_header:
all_res_csv_writer.writeheader()
new_header = False
all_res_csv_writer.writerow(res_dict)
dataset_results = pd.Series({
'dataset':
dataset_name,
'problem_type':
problem_type,
'no_feat':
int(realkd_opt_df['no_feat']),
'no_rows':
int(realkd_opt_df['no_rows']),
'rulefit_auc_test':
median(rulefit_aucs_test),
'rulefit_auc_train':
median(rulefit_aucs_train),
'rulefit_reg':
rulefit_reg,
'realkd_greedy_auc_test':
median(realkd_greedy_aucs_test),
'realkd_greedy_auc_train':
median(realkd_greedy_aucs_train),
'greedy_reg':
greedy_reg,
'realkd_optimal_auc_test':
median(realkd_optimal_aucs_test),
'realkd_optimal_auc_train':
median(realkd_optimal_aucs_train),
'optimal_reg':
opt_reg,
'random_seeds':
seeds
})
print(dataset_results)
# res_df = res_df.append(dataset_results, ignore_index=True)
returned_models[dataset_name] = {
'rulefit': best_rulefit,
'greedy': greedy_model,
'optimal': opt_model
}
'''
fieldnames = res_df.columns
with open('datasets_perf.csv', 'w') as f:
csv_writer = DictWriter(f, fieldnames=fieldnames)
csv_writer.writeheader()
for idx, row in res_df.iterrows():
csv_writer.writerow(row.to_dict())
'''
return returned_models
def rulefit_sweep(fixed_params, variable_lst, max_rules):
test_res_vect = []
train_res_vect = []
best_rulefit = None
best_rulefit_score = None
fit_times = []
max_fitted_rules = 0
rule_lengths = []
for params in variable_lst:
print(params)
fixed_params['params'] = params
metric = fixed_params['metrics'][0]
exp = Experiment(**fixed_params)
res, model = exp.run()
rule_lengths += exp.results['rule_lengths']
if (best_rulefit == None) or (
(exp.results[metric + '_test'][1] > best_rulefit_score) and
(exp.results[metric + '_test'][0] <= max_rules)):
best_rulefit = model
best_rulefit_score = exp.results[metric + '_test'][1]
no_rules = exp.results[metric + '_test'][0]
if no_rules > max_fitted_rules:
max_fitted_rules = no_rules
fit_times.append((no_rules, exp.fit_time))
print(exp.results[metric + '_test'], exp.results[metric + '_train'])
test_res_vect.append(exp.results[metric + '_test'])
train_res_vect.append(exp.results[metric + '_train'])
average_rule_length = sum(rule_lengths) / len(rule_lengths)
fit_times.sort()
filtered_fit_times = list(
filter(lambda item: item[0] == max_fitted_rules, fit_times))
fit_times = [item[1] for item in filtered_fit_times]
average_fit_time = sum(fit_times) / len(fit_times)
test_res_vect = list(
filter(lambda item: item[0] <= max_rules, test_res_vect))
train_res_vect = list(
filter(lambda item: item[0] <= max_rules, train_res_vect))
if fixed_params['objective'] == 'regress':
test_res_vect = list(filter(lambda item: item[0] > 0, test_res_vect))
train_res_vect = list(filter(lambda item: item[0] > 0, train_res_vect))
test_res_vect.sort(key=lambda item: item[0])
train_res_vect.sort(key=lambda item: item[0])
x, y = zip(*test_res_vect)
x2, y2 = zip(*train_res_vect)
x, x2 = list(x), list(x2)
y, y2 = list(y), list(y2)
xy_dict, xy_dict2 = dict(), dict()
for i in range(len(x)):
x_key = str(x[i])
if x_key in xy_dict:
xy_dict[x_key].append(y[i])
else:
xy_dict[x_key] = [y[i]]
x_key = str(x2[i])
if x_key in xy_dict2:
xy_dict2[x_key].append(y2[i])
else:
xy_dict2[x_key] = [y2[i]]
x_keys = xy_dict.keys()
x_keys2 = xy_dict2.keys()
x, x2 = [], []
y, y2 = [], []
for key in x_keys:
x.append(int(key))
y.append(median(xy_dict[key]))
for key in x_keys2:
x2.append(int(key))
y2.append(median(xy_dict2[key]))
while x[-1] < max_rules:
x.append(x[-1] + 1)
y.append(y[-1])
while x2[-1] < max_rules:
x2.append(x2[-1] + 1)
y2.append(y2[-1])
return (x, y), (x2,
y2), average_fit_time, average_rule_length, best_rulefit
Est3 = abs3.T[248:253, ] Est4 = abs4.T[248:253, ] Est0CUA = Est0**2 Est1CUA = Est1**2 Est2CUA = Est2**2 Est3CUA = Est3**2 Est4CUA = Est4**2 NewEst0 = (sum(Est0CUA) / 5)**(1 / 2) NewEst1 = (sum(Est1CUA) / 5)**(1 / 2) NewEst2 = (sum(Est2CUA) / 5)**(1 / 2) NewEst3 = (sum(Est3CUA) / 5)**(1 / 2) NewEst4 = (sum(Est4CUA) / 5)**(1 / 2) Esp0 = stats.median(NewEst0) Esp1 = stats.median(NewEst1) Esp2 = stats.median(NewEst2) Esp3 = stats.median(NewEst3) Esp4 = stats.median(NewEst4) Sesgo0 = Esp0 - a0 Var0 = stats.variance(NewEst0) Sesgo1 = Esp1 - a0 Var1 = stats.variance(NewEst1) Sesgo2 = Esp2 - a0 Var2 = stats.variance(NewEst2) Sesgo3 = Esp3 - a0
def _salary_calculator(self):
#----------------------------------------------------------------------
# Return appropriate salary group by salary value
#----------------------------------------------------------------------
def _get_salary_group(salary):
return {
salary < 20000: 'Менее 20000',
20000 <= salary < 30000: '20000-30000',
30000 <= salary < 40000: '30000-40000',
40000 <= salary < 50000: '40000-50000',
50000 <= salary < 60000: '50000-60000',
60000 <= salary < 70000: '60000-70000',
70000 <= salary < 90000: '70000-90000',
90000 <= salary: 'Более 90000'
}[True]
sum = total = 0
salary_all = []
regions = [region[0] for region in self.regions]
region_salary_dict = {
'average_salary': 0,
'median_salary': 0,
'modal_salary': 0,
'sum': 0,
'total': 0,
'salary_all': [],
}
self.salaries_by_region = {
region: region_salary_dict
for region in regions
}
for vacancy in self.vacancies:
region = vacancy.get('area').get('name')
if vacancy.get('salary'):
salary = dict(vacancy['salary'])
if salary.get('currency') == 'RUR':
if salary.get('gross'):
if salary.get('from'):
salary['from'] = salary['from'] * 0.87
if salary.get('to'):
salary['to'] = salary['to'] * 0.87
if salary.get('from'):
self.salaries_by_region[region]['sum'] += salary.get(
'from')
self.salaries_by_region[region]['total'] += 1
self.salaries_by_region[region]['salary_all'].append(
salary.get('from'))
self.salary_groups[_get_salary_group(
int(salary.get('from')))] += 1
salary_all.append(salary.get('from'))
sum += salary.get('from')
total += 1
if salary.get('to'):
self.salaries_by_region[region]['sum'] += salary.get(
'to')
self.salaries_by_region[region]['total'] += 1
self.salaries_by_region[region]['salary_all'].append(
salary.get('to'))
self.salary_groups[_get_salary_group(
int(salary.get('to')))] += 1
salary_all.append(salary.get('to'))
sum += salary.get('to')
total += 1
# Calculate median salary
self.median_salary = statistics.median(salary_all)
# Calculate average salary
if total > 0:
self.average_salary = round(sum / total)
for region in regions:
self.salaries_by_region[region]['median_salary'] = \
statistics.median(self.salaries_by_region[region]['salary_all'])
if self.salaries_by_region[region]['total'] > 0:
self.salaries_by_region[region]['average_salary'] = \
round(self.salaries_by_region[region]['sum'] \
/ self.salaries_by_region[region]['total'])
# Calculate modal salary
for group, salary in self.salary_groups.items():
if salary == max(self.salary_groups.values()):
self.modal_salary = group
self.salaries = [('Средняя', self.average_salary),
('Медиана', self.median_salary),
('Модальная', self.modal_salary)]
if y_h_neg[j - 1] != y_target[j - 1]:
Ein[1, j] = Ein[1, j - 1] + 1
else:
Ein[1, j] = Ein[1, j - 1] - 1
Ein = Ein / data_size
index = np.where(Ein == np.amin(Ein))
g_multi = []
for i in range(len(index[0])):
if index[0][i] == 0:
s = 1
else:
s = -1
theta = thetaList[index[1][i]]
g_multi.append(s + theta)
g_min = np.where(g_multi == np.amin(g_multi))
theta = thetaList[index[1][g_min]]
if index[0][g_min] == 0:
# s = 1
Eout = (1 - 2 * Tau) * (abs(theta) / 2) + Tau
else:
# s = -1
Eout = (1 - 2 * Tau) * (1 - abs(theta) / 2) + Tau
ans.append(Eout - np.amin(Ein))
t += 1
mean = sum(ans) / repeatTimes
median = stat.median(ans)
print("The mean is", mean)
print("The median is", median)
def history_stats(parse_samples,
start=None,
verbose=False,
context=None,
history=None):
"""Fetch, parse, and compute ping and usage stats.
Note:
See module level docs regarding brackets in field names.
Args:
parse_samples (int): Number of samples to process, or -1 to parse all
available samples.
start (int): Optional starting counter value to be applied to the
history data. See `history_bulk_data` documentation for more
details on how this parameter is used.
verbose (bool): Optionally produce verbose output.
context (ChannelContext): Optionally provide a channel for reuse
across repeated calls.
history: Optionally provide the history data to use instead of fetching
it, from a prior call to `get_history`.
Returns:
A tuple with 6 dicts, mapping general data names, ping drop stat
names, ping drop run length stat names, ping latency stat names,
loaded ping latency stat names, and bandwidth usage stat names to
their respective values, in that order.
Note:
Additional dicts may be added to this tuple in the future with
additional data groups, so it not recommended for the caller to
assume exactly 6 elements.
Raises:
GrpcError: Failed getting history info from the Starlink user
terminal.
"""
if history is None:
try:
history = get_history(context)
except grpc.RpcError as e:
raise GrpcError(e)
sample_range, parsed_samples, current = _compute_sample_range(
history, parse_samples, start=start, verbose=verbose)
tot = 0.0
count_full_drop = 0
count_unsched = 0
total_unsched_drop = 0.0
count_full_unsched = 0
count_obstruct = 0
total_obstruct_drop = 0.0
count_full_obstruct = 0
second_runs = [0] * 60
minute_runs = [0] * 60
run_length = 0
init_run_length = None
usage_down = 0.0
usage_up = 0.0
rtt_full = []
rtt_all = []
rtt_buckets = [[] for _ in range(15)]
for i in sample_range:
d = history.pop_ping_drop_rate[i]
if d >= 1:
# just in case...
d = 1
count_full_drop += 1
run_length += 1
elif run_length > 0:
if init_run_length is None:
init_run_length = run_length
else:
if run_length <= 60:
second_runs[run_length - 1] += run_length
else:
minute_runs[min((run_length - 1) // 60 - 1,
59)] += run_length
run_length = 0
elif init_run_length is None:
init_run_length = 0
tot += d
down = history.downlink_throughput_bps[i]
usage_down += down
up = history.uplink_throughput_bps[i]
usage_up += up
rtt = history.pop_ping_latency_ms[i]
# note that "full" here means the opposite of ping drop full
if d == 0.0:
rtt_full.append(rtt)
if down + up > 500000:
rtt_buckets[min(14, int(math.log2(
(down + up) / 500000)))].append(rtt)
else:
rtt_buckets[0].append(rtt)
if d < 1.0:
rtt_all.append((rtt, 1.0 - d))
# If the entire sample set is one big drop run, it will be both initial
# fragment (continued from prior sample range) and final one (continued
# to next sample range), but to avoid double-reporting, just call it
# the initial run.
if init_run_length is None:
init_run_length = run_length
run_length = 0
def weighted_mean_and_quantiles(data, n):
if not data:
return None, [None] * (n + 1)
total_weight = sum(x[1] for x in data)
result = []
items = iter(data)
value, accum_weight = next(items)
accum_value = value * accum_weight
for boundary in (total_weight * x / n for x in range(n)):
while accum_weight < boundary:
try:
value, weight = next(items)
accum_value += value * weight
accum_weight += weight
except StopIteration:
# shouldn't happen, but in case of float precision weirdness...
break
result.append(value)
result.append(data[-1][0])
accum_value += sum(x[0] for x in items)
return accum_value / total_weight, result
bucket_samples = []
bucket_min = []
bucket_median = []
bucket_max = []
for bucket in rtt_buckets:
if bucket:
bucket_samples.append(len(bucket))
bucket_min.append(min(bucket))
bucket_median.append(statistics.median(bucket))
bucket_max.append(max(bucket))
else:
bucket_samples.append(0)
bucket_min.append(None)
bucket_median.append(None)
bucket_max.append(None)
rtt_all.sort(key=lambda x: x[0])
wmean_all, wdeciles_all = weighted_mean_and_quantiles(rtt_all, 10)
rtt_full.sort()
mean_full, deciles_full = weighted_mean_and_quantiles(
tuple((x, 1.0) for x in rtt_full), 10)
return {
"samples": parsed_samples,
"end_counter": current,
}, {
"total_ping_drop": tot,
"count_full_ping_drop": count_full_drop,
"count_obstructed": count_obstruct,
"total_obstructed_ping_drop": total_obstruct_drop,
"count_full_obstructed_ping_drop": count_full_obstruct,
"count_unscheduled": count_unsched,
"total_unscheduled_ping_drop": total_unsched_drop,
"count_full_unscheduled_ping_drop": count_full_unsched,
}, {
"init_run_fragment": init_run_length,
"final_run_fragment": run_length,
"run_seconds[1,]": second_runs,
"run_minutes[1,]": minute_runs,
}, {
"mean_all_ping_latency":
wmean_all,
"deciles_all_ping_latency[]":
wdeciles_all,
"mean_full_ping_latency":
mean_full,
"deciles_full_ping_latency[]":
deciles_full,
"stdev_full_ping_latency":
statistics.pstdev(rtt_full) if rtt_full else None,
}, {
"load_bucket_samples[]": bucket_samples,
"load_bucket_min_latency[]": bucket_min,
"load_bucket_median_latency[]": bucket_median,
"load_bucket_max_latency[]": bucket_max,
}, {
"download_usage": int(round(usage_down / 8)),
"upload_usage": int(round(usage_up / 8)),
}
while True: #落下判定
altitude_b = []
altitude_a = []
drop_synthetic_acc = []
for i in range(0, 5):
altitude_b.append(press.altitude_cal())
drop_synthetic_acc.append(acc.synthetic_acc_cal())
for j in range(0, 5):
altitude_a.append(press.altitude_cal())
acc_cnt = 0
alt_cnt = 0
while (acc_cnt < 5):
if (statistics.median(drop_synthetic_acc) >= DROP_ACCELERATION):
acc_cnt = acc_cnt + 1
else:
pass
while (alt_cnt < 5):
if (statistics.median(altitude_a) - statistics.median(altitude_b) < 0):
alt_cnt = alt_cnt + 1
else:
pass
if (acc_cnt == 4 or alt_cnt == 4):
t1 = time.time()
break
time.sleep(1 / SAMPLING_RATE)
def main():
tip_algoritm = '1'
tip_nivel = 1
adancime = 2
Joc.JMAX = "0"
Joc.JMIN = "x"
N = 9 # linii
M = 10 # coloane
(tip_algoritm, tip_nivel, adancime, N, M) = get_input()
# initializare tabla
Joc.NR_LINII = int(N)
Joc.NR_COLOANE = int(M)
tabla_curenta = Joc()
nr_mut_calc = 0
nr_mut_util = 0
print("Tabla initiala")
print(str(tabla_curenta))
lista_timpi = []
# creare stare initiala
stare_curenta = Stare(tabla_curenta, 'x', adancime)
# setari interf grafica
time1_tot = int(round(time.time() * 1000))
pygame.init()
pygame.display.set_caption("Gabriel Cirstea x si 0")
# dimensiunea ferestrei in pixeli
ecran = pygame.display.set_mode(size=(M * 81 - 1, N * 81 -
1)) # Nrc*100+Nrc-1, Nrl*100+Nrl-1
# de_mutat = False
patratele = deseneaza_grid(ecran, tabla_curenta.matr, N, M)
selected_piece = None
while True:
if (stare_curenta.j_curent == Joc.JMIN):
# muta jucatorul
# preiau timpul in milisecunde de dinainte de mutare
t_inainte = int(round(time.time() * 1000))
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos() # coordonatele clickului
for np in range(len(patratele)):
if patratele[np].collidepoint(pos):
linie = np // M
coloana = np % M
###############################
if stare_curenta.tabla_joc.matr[np] == Joc.JMIN:
selected_piece = np
patratele = deseneaza_grid(ecran, stare_curenta.tabla_joc.matr,\
N, M, np)
if stare_curenta.tabla_joc.matr[np] == Joc.GOL:
if linie * M + coloana == stare_curenta.tabla_joc.Removed:
continue
if selected_piece:
stare_curenta.tabla_joc.salt_piesa(
selected_piece, np, Joc.JMAX)
stare_curenta.tabla_joc.matr[np] = Joc.JMIN
nr_mut_util += 1
# afisarea starii jocului in urma mutarii utilizatorului
print("\nTabla dupa mutarea jucatorului")
print(str(stare_curenta))
# preiau timpul in milisecunde de dupa mutare
t_dupa = int(round(time.time() * 1000))
print("Utilizatorul a \"gandit\" timp de " +
str(t_dupa - t_inainte) +
" milisecunde.")
patratele = deseneaza_grid(
ecran, stare_curenta.tabla_joc.matr, N, M)
# S-a realizat o mutare. Schimb jucatorul cu cel opus
stare_curenta.j_curent = stare_curenta.jucator_opus(
)
# --------------------------------
else: # jucatorul e JMAX (calculatorul)
# Mutare calculator
t_inainte = int(round(time.time() * 1000))
if tip_algoritm == '1':
stare_actualizata = min_max(stare_curenta)
else: # tip_algoritm==2
stare_actualizata = alpha_beta(-500, 500, stare_curenta)
stare_curenta.tabla_joc = stare_actualizata.stare_aleasa.tabla_joc
nr_mut_calc += 1
print("Tabla dupa mutarea calculatorului")
print(str(stare_curenta))
patratele = deseneaza_grid(ecran, stare_curenta.tabla_joc.matr, N,
M)
# preiau timpul in milisecunde de dupa mutare
t_dupa = int(round(time.time() * 1000))
print("Calculatorul a \"gandit\" timp de " +
str(t_dupa - t_inainte) + " milisecunde.")
lista_timpi.append(t_dupa - t_inainte)
# S-a realizat o mutare. Schimb jucatorul cu cel opus
stare_curenta.j_curent = stare_curenta.jucator_opus()
# testez daca jocul a ajuns intr-o stare finala
# si afisez un mesaj corespunzator in caz ca da
if (afis_daca_final(stare_curenta)):
break
print("Timpul minim al calculatorului este ", min(lista_timpi),
" milisecunde.")
print("Timpul maxim al calculatorului este ", max(lista_timpi),
" milisecunde.")
print("Media calculatorului este ", statistics.mean(lista_timpi),
" milisecunde.")
print("Mediana calculatorului este ", statistics.median(lista_timpi),
" milisecunde.")
print("Numar mutari utilizator: ", nr_mut_util)
print("Numar mutari calculator: ", nr_mut_calc)
time2_tot = int(round(time.time() * 1000))
print("Jocul a durat in total " + str(time2_tot - time1_tot) +
" milisecunde.")
if 'SameSite' in lines:
same_site_num += 1
if 'Strict' in lines:
strict_num += 1
if 'None' in lines:
none_in_lines_num += 1
if 'path' in lines:
total_path += 1
if 'path=/' in lines:
path_to_none_num += 1
cookielist.append(cookie_num)
cookielistfinal.append(cookielist[m] - cookielist[m - 1])
maximum = max(cookielistfinal)
minimum = min(
cookielistfinal) ## down here is how I got the max, min , and Median
cookie_med = median(cookielistfinal)
m += 1
print(
str(cookie_num) + ' total number of cookies' + '\n' + 'mean of cookies ' +
str(cookie_num / m))
print(str(secure_num) + ' number of secure cookies')
print(str(http_only_num) + ' number of HTTP only')
print(str(same_site_num) + ' number of SameSite')
print(str(lax_num) + ' number of lax cookies')
print(str(strict_num) + ' number of strict samesite')
print(str(none_in_lines_num) + ' number of none samesite')
print(str(total_path) + ' number of paths')
print(
str(path_to_none_num - total_path) +
' total number of paths that had var other than "/"')
print(
import statistics
# Print each value name for how they will appear below in order (for the user)
print("Mean,", "Median,", "Mode,", "Min,", "Max")
# First number line
nums1 = [33, 5, 453, 21, 67, 657, 3425, 65, 21, 33, 44, 634, 543, 2345, 697]
# Call the mean, median and mode using the statistics module from the first number line
mean = statistics.mean(nums1)
median = statistics.median(nums1)
mode = statistics.mode(nums1)
# Print results for line 1
print(mean, ",", median, ",", mode, ",", min(nums1), ",", max(nums1))
# Second number line
nums2 = [65, 53, 485, 65, 453, 7895, 24, 65, 531, 24, 755, 342, 32, 1, 65, 99]
# Call the mean, median and mode using the statistics module from the second number line
mean = statistics.mean(nums2)
median = statistics.median(nums2)
mode = statistics.mode(nums2)
# Print results for line 2
print(mean, ",", median, ",", mode, ",", min(nums2), ",", max(nums2))
# Third number line
nums3 = [5435, 234, 398, 398, 534, 234, 65, 78, 66, 534, 456, 234, 54, 534, 56, 34, 77]
# Call the mean, median and mode using the statistics module from the third number line
mean = statistics.mean(nums3)
median = statistics.median(nums3)
mode = statistics.mode(nums3)
# Print results for line 3
print(mean, ",", median, ",", mode, ",", min(nums3), ",", max(nums3))
def set_features_snp(dictionary): '''setta i valori delle features in base alle info estratte dai vcf''' for variante in dictionary.keys(): features=Features() varc_array=dictionary.get(variante) vett_BQ=[] vett_DP=[] vett_MQ0=[] index=0 for varcall in varc_array: if varcall is not "": vett_BQ=vett_BQ+[varcall.QB] vett_DP=vett_DP+[varcall.DP] if index == 0: features.GT_Freebayes=varc_array[0].GT features.QB_Freebayes=float(varc_array[0].QB) features.AF_Freebayes=float(varc_array[0].AF) features.CallFreebayes=varc_array[0].Call features.STRBIAS_Freebayes=varc_array[0].StrandBias elif index == 1: features.GT_Vardict=varc_array[1].GT features.QB_Vardict=float(varc_array[1].QB) features.MQ_Vardict=varc_array[1].MQ features.AF_Vardict=float(varc_array[1].AF) features.CallVardict=varc_array[1].Call features.STRBIAS_Vardict=varc_array[1].StrandBias elif index == 2: features.GT_Platypus=varc_array[2].GT features.AF_Platypus=float(varc_array[2].AF) features.CallPlatypus=varc_array[2].Call features.STRBIAS_Platypus=varc_array[2].StrandBias elif index == 3: features.GT_Gatk=varc_array[3].GT features.AF_Gatk=float(varc_array[3].AF) features.CallGatk=varc_array[3].Call features.MQ0_Gatk=float(varc_array[3].MQ0) features.MQ0F_Gatk=float(varc_array[3].MQ0F) features.MQRankSum_Gatk=varc_array[3].MQRankSum features.BQRankSum_Gatk=varc_array[3].BQRankSum features.StrBiasFS_Gatk=varc_array[3].StrBiasFS index = index + 1 vett_MQ0=[features.MQ0_Gatk] vett_MQ0F=[features.MQ0F_Gatk] vett_AF_media=[features.AF_Freebayes,features.AF_Vardict,features.AF_Platypus,features.AF_Gatk] vett_STRB_media=[features.STRBIAS_Freebayes,features.STRBIAS_Vardict,features.STRBIAS_Platypus,features.StrBiasFS_Gatk] AF_med=0 MQ0_med=0 MQ0F_med=0 SB_media=0 nDP=0 nMBQ=0 i=0 v=[] for dp in vett_DP: if dp and dp is not '': nDP= float(nDP)+float(dp) v=v+[float(dp)] i=i+1 try: features.DP=float(nDP)/float(i) features.DP_median= statistics.median(v) except: features.DP='.' try: features.DP_norm_median= float(features.DP_median)/float(opts.expectedMeanDP) except: features.DP_norm_median='.' i=0 v=[] for bq in vett_BQ: if bq is not '.': nMBQ= float(nMBQ)+float(bq) v=v+[float(bq)] i=i+1 try: features.BQ_media=float(nMBQ)/float(i) features.BQ_median= statistics.median(v) except: features.BQ_media='.' i=0 v=[] for strb in vett_STRB_media: if strb is not '.': SB_media=float(SB_media) + float(strb) v=v+[float(strb)] i=i+1 try: features.STRBIAS_media= float(SB_media)/float(i) features.STRBIAS_median= statistics.median(v) except: features.STRBIAS_media='.' i=0 v=[] for af in vett_AF_media: if af is not '.' and af is not '0': AF_med=float(AF_med) + float(af) v=v+[float(af)] i=i+1 try: features.AF_media= float(AF_med)/float(i) features.AF_median= statistics.median(v) except: features.AF_media='.' i=0 v=[] for mq in vett_MQ0: if mq is not '.': MQ0_med=float(MQ0_med) + float(mq) v=v+[float(mq)] i=i+1 try: features.MQ0_media= float(MQ0_med)/float(i) features.MQ0_median= statistics.median(v) except: features.MQ0_media='.' try: features.MQ0_norm_median= features.MQ0_median/float(opts.expectedMeanDP) except: features.MQ0_norm_median='.' i=0 v=[] for mqf in vett_MQ0F: if mqf is not '.': MQ0F_med=float(MQ0F_med) + float(mqf) v=v+[float(mqf)] i=i+1 try: features.MQ0F_media= float(MQ0_med)/float(i) features.MQ0F_median= statistics.median(v) except: features.MQ0F_media='.' dictionary[variante]= varc_array + [features]
def makeModel(self, halfData, checks=None):
model = QtGui.QStandardItemModel(len(halfData), 7)
model.setHorizontalHeaderLabels([
'Depth', 'Elongation', 'Pressure', 'Temperature', 'Density',
'Fluid type', ''
])
densities = [0]
types = ['']
for row in range(len(halfData)):
for col in range(7):
if col in range(4):
item = QtGui.QStandardItem(str(halfData[row][col]))
elif col == 4:
if row != 0:
ro = round(
(halfData[row][2] - halfData[row - 1][2]) /
(halfData[row][0] - halfData[row][1] -
halfData[row - 1][0] + halfData[row - 1][1]) * 10,
3)
densities.append(ro)
item = QtGui.QStandardItem(str(ro))
elif col == 5:
if row != 0:
if ro < 0.7:
item = QtGui.QStandardItem("Gas")
elif 0.7 < ro < 0.98:
item = QtGui.QStandardItem("Oil")
else:
item = QtGui.QStandardItem("Water")
types.append(item.text())
elif col == 6:
if row != 0:
item = QtGui.QStandardItem()
item.setCheckable(True)
item.setTextAlignment(QtCore.Qt.AlignCenter)
model.setItem(row, col, item)
numDots = round(len(halfData) / 3) + 1
calcList = densities[-numDots:]
typesList = types[-numDots:]
refType = None
if typesList[-1] == typesList[-2] and 0.7 < calcList[
-1] < 1.25 and 0.7 < calcList[-2] < 1.25:
refType = typesList[-1]
elif typesList[-1] != typesList[-2] and 0.7 < calcList[
-1] < 1.25 and 0.7 < calcList[-2] < 1.25:
if typesList[-2] == typesList[-3] and 0.7 < calcList[
-2] < 1.25 and 0.7 < calcList[-3] < 1.25:
refType = typesList[-2]
elif typesList[-2] != typesList[-3] and 0.7 < calcList[
-2] < 1.25 and 0.7 < calcList[-3] < 1.25:
if typesList[-3] == typesList[-4] and 0.7 < calcList[
-3] < 1.25 and 0.7 < calcList[-4] < 1.25:
refType = typesList[-3]
else:
maxNum = 0
typesSet = set(typesList)
for fluidType in typesSet:
num = typesList.count(fluidType)
if num > maxNum or (num == maxNum
and refType == "Gas"):
maxNum = num
refType = fluidType
else:
maxNum = 0
typesSet = set(typesList)
for fluidType in typesSet:
num = typesList.count(fluidType)
if num > maxNum or (num == maxNum and refType == "Gas"):
maxNum = num
refType = fluidType
if refType == "Water":
target = 1.16
calcList = [ro for ro in calcList if ro >= 0.98]
elif refType == "Oil":
target = 0.88
calcList = [ro for ro in calcList if 0.7 < ro < 0.98]
else:
target = 0.5
calcList = [ro for ro in calcList if 0.01 <= ro < 0.7]
if len(calcList) % 2 == 0:
medianRo2 = median(calcList)
indicator = False
for i in range(len(calcList) - 1):
if calcList[i] < medianRo2 < calcList[i + 1]:
medianRo1 = calcList[i]
medianRo3 = calcList[i + 1]
indicator = True
if i == len(calcList) - 2 and indicator == False:
medianRo1 = medianRo2
medianRo3 = medianRo2
cond1 = (max(target, medianRo1) - min(target, medianRo1)) / max(
target, medianRo1)
cond2 = (max(target, medianRo2) - min(target, medianRo2)) / max(
target, medianRo2)
cond3 = (max(target, medianRo3) - min(target, medianRo3)) / max(
target, medianRo3)
if cond1 == min(cond1, cond2, cond3):
medianRo = medianRo1
elif cond2 == min(cond1, cond2, cond3):
medianRo = medianRo2
else:
medianRo = medianRo3
else:
medianRo = median(calcList)
finalRo = []
altFinalRo = []
for row in range(len(halfData) - numDots, len(halfData)):
m1 = max(float(model.index(row, 4).data()), medianRo)
m2 = min(float(model.index(row, 4).data()), medianRo)
if model.index(row, 5).data(
) == refType and (m1 - m2) / m1 < 0.08 and checks is None:
model.item(row, 6).setCheckState(2)
finalRo.append(float(model.item(row, 4).text()))
else:
altFinalRo.append(float(model.item(row, 4).text()))
if checks is not None:
for row in range(len(checks)):
if checks[row]:
model.item(row, 6).setCheckState(2)
try:
meanRo = mean(finalRo)
except:
meanRo = mean(altFinalRo)
if 0.8 > meanRo or 1.2 < meanRo or 0.8 > meanRo or 1.2 < meanRo:
self.warning = True
mtmeterAbsDepth = float(model.item(
len(halfData) - 1, 0).text()) - float(
model.item(len(halfData) - 1, 1).text())
vdpAbsDepth = self.vdp - self.vdpElong
delta = vdpAbsDepth - mtmeterAbsDepth
ppl = round(
float(model.item(len(halfData) - 1, 2).text()) +
delta * meanRo / 10, 3)
# lengthToReturn = len(finalRo)
# if lengthToReturn == 0: lengthToReturn = len(altFinalRo)
return model, round(meanRo, 3), ppl, refType, len(finalRo)
print('List:', length)
#min & max
print('Minimum:', length[0])
print('Maximum:', length[-1])
#mean
summ = 0
for s in length:
summ += s
Mean = summ / len(length)
print('Total length:', summ)
print('Mean:', Mean)
#median
print('Median:', statistics.median(length))
#N50
summ2 = 0
for value in length:
summ2 += value
if summ2 > summ / 2:
print('N50:', value)
break
log2nd=np.log2(nd_)
log2nd_=[x for x,y in zip(log2nd,type_l)if y=='BQC']
ax0.scatter(seq0BQC,log2nd_,s=2,color='r',label='BQC')
log2nd_=[x for x,y in zip(log2nd,type_l)if y=='TQC']
ax0.scatter(seq0TQC,log2nd_,s=2,color='b',label='TQC')
log2nd_=[x for x,y in zip(log2nd,type_l)if y=='SAMPLE']
ax0.scatter(seq0sam,log2nd_,s=2,color='k',alpha=.2)
ax0.legend()
q1,q3=np.quantile([x for x in log2nd if np.isfinite(x)],[.1,.9])
ub=q3+max(1,q3-q1)
lb=q1-max(1,q3-q1)
ax0.set_ylim(lb-.5,ub+.5)
nd=[math.log2(x) for x,y in zip(nd_,type_l) if x>0 and y!='TQC']
if corr0:
allmed=(statistics.median(nd)if nd else 0)
else:
allmed=0
adj_dat0=[]
for adj0,cp0,cp1 in zip(adj0_l,[0]+change_pt,change_pt+[len(batch_l)]):
seq1=seq0[cp0:cp1]
adj0_=[x for x,y in zip(adj0,type_l[cp0:cp1]) if np.isfinite(x) and y!='TQC']
if corr0:
adjmed=(statistics.median(adj0_) if adj0_ else 0)
else:
adjmed=0
nd1=[(x-adjmed+allmed if y!='TQC' else tqcy) for y,x,tqcy in zip(type_l[cp0:cp1],adj0,np.log2(nd_[cp0:cp1]))]
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
label = tk.Label(self, text="Visalizer", font=LARGE_FONT)
label.pack(pady=10, padx=10)
button1 = ttk.Button(self,
text="Go back to Homepage",
command=lambda: controller.show_frame(StartPage))
button1.pack()
fig = Figure(figsize=(5, 4), dpi=100)
fig_2d = Figure(figsize=(6, 1), dpi=50)
canvas = FigureCanvasTkAgg(fig, self)
canvas.draw()
canvas.get_tk_widget().pack(side=tk.RIGHT, fill=tk.BOTH, expand=False)
# toolbar = NavigationToolbar2Tk(canvas, self)
# toolbar.update()
# canvas._tkcanvas.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)
canvas_2d = FigureCanvasTkAgg(fig_2d, self)
canvas_2d.draw()
canvas_2d.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
toolbar = NavigationToolbar2Tk(canvas_2d, self)
toolbar.update()
canvas_2d._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
median = statistics.median(retro_master)
standard_deviation = statistics.stdev(retro_master)
median_label = tk.Label(self,
text="Median of full Sign:{}".format(median),
font=LARGE_FONT)
median_label.pack(pady=10, padx=10)
if median > 0.7:
classification_status = 'Good Sign No change neeed'
if median < 0.69:
classification_status = 'Poor Sign as per retro Standards, Please consided changing the sign'
sd_label = tk.Label(
self,
text="Standard Deviation of full:{}".format(standard_deviation),
font=LARGE_FONT)
sd_label.pack(pady=10, padx=10)
classification_label = tk.Label(
self,
text="Classification Status {}".format(classification_status),
font=LARGE_FONT)
classification_label.pack(pady=10, padx=10)
ax1 = fig.add_subplot(111, projection='3d')
print(type(ax1))
ax2 = fig_2d.add_subplot(111)
print(type(ax2))
if len(x3_great_point) > 0:
#color the point green
ax1.bar3d(x3_great_point,
y3_great_point,
z3_great_point,
dx,
dy,
dz_great_point,
color='g')
else:
pass
if len(x3_average_point) > 0:
#color the point y
ax1.bar3d(x3_average_point,
y3_average_point,
z3_average_point,
dx,
dy,
dz_average_point,
color='y')
else:
pass
if len(x3_above_average_point) > 0:
#color the point orange
ax1.bar3d(x3_above_average_point,
y3_above_average_point,
z3_above_average,
dx,
dy,
dz_above_average_point,
color='m')
else:
pass
if len(x3_very_poor) > 0:
#color the point orange
ax1.bar3d(x3_very_poor,
y3_very_poor,
z3_very_poor,
dx,
dy,
dz_very_poor,
color='r')
else:
pass
if (len(x3_great_point) > 0):
button3 = ttk.Button(self,
text="Only Good Points",
command=lambda: [
ax1.clear(),
ax1.bar3d(x3_great_point,
y3_great_point,
z3_great_point,
dx,
dy,
dz_great_point,
color='g')
])
button3.pack()
if (len(x3_very_poor) > 0):
button4 = ttk.Button(self,
text="Only Poor Points",
command=lambda: [
ax1.clear(),
ax1.bar3d(x3_very_poor,
y3_very_poor,
z3_very_poor,
dx,
dy,
dz_very_poor,
color='r')
])
button4.pack()
if (len(x3_above_average_point) > 0):
button5 = ttk.Button(self,
text="Only Above averge points",
command=lambda: [
ax1.clear(),
ax1.bar3d(x3_above_average_point,
y3_above_average_point,
z3_above_average,
dx,
dy,
dz_above_average_point,
color='m')
])
button5.pack()
if (len(x3_average_point) > 0):
button6 = ttk.Button(self,
text="Only average point",
command=lambda: [
ax1.clear(),
ax1.bar3d(x3_average_point,
y3_average_point,
z3_average_point,
dx,
dy,
dz_average_point,
color='b')
])
button6.pack()
if (len(retro_master) > 0):
print(len(retro_master))
button7 = ttk.Button(
self,
text="Histograms",
command=lambda: [
ax2.hist(dz_very_poor, bins, histtype='bar', color='r'),
ax2.hist(dz_great_point, bins, histtype='bar', color='g'),
ax2.hist(dz_average_point, bins, histtype='bar', color='y'
),
ax2.hist(dz_above_average_point,
bins,
histtype='bar',
color='m')
])
button7.pack()
a = 0
bin_value_to_show_points = tk.Entry(self)
bin_value_to_show_points.pack()
button_to_plot_entered_value = ttk.Button(
self,
text="Plot points below entered value",
command=lambda: [
updated_graph_points(df1.loc[
(df1['Retro'] <= float(bin_value_to_show_points.get()))])
])
button_to_plot_entered_value.pack()
ax1.set_xlabel('x')
ax1.set_ylabel('y')
ax1.set_zlabel('retro')
ax1.set_zlim3d(0, 1)
n = int(input()) l = list(map(int, input.split()))[:n] from statistics import median q1 = median(l) ql1 = l[:q1] q2 = median(ql1) ql2 = l[q1:] q3 = median(ql2) print(q1) print(q2) print(q3)
def getPeriodicity(self,
time=20,
startTime=0,
minSpeed=10,
skip=12,
smooth=2,
minTime=9,
forGraph=False):
"""returns periodicity, which is computed as a median time between two consecutive
moments when a rat was mobile - times where its speed was higher than minSpeed
... additionally only periods more than minTime seconds are counted in a result
... this parameter is probably useful only in cases where a rat is moving and learned
the task properly
// minTime may be a list of values
"""
time = time * 60000
start = self.findStart(startTime)
result = []
if type(minTime) != list:
minTime = [minTime]
moves = []
for minT in minTime:
t0 = startTime * 60000
x0, y0 = self.data[start][7:9]
minT *= 1000
speeds = deque()
prev = False
periods = []
for content in self.data[start + skip::skip]:
if content[1] > time:
break
x1, y1 = content[7:9]
t1 = content[1]
speeds.append((sqrt(
((x1 - x0)**2 + (y1 - y0)**2)) / self.trackerResolution) /
((t1 - t0) / 1000))
if len(speeds) == smooth:
if sum(speeds) / len(speeds) > minSpeed:
if t0 - prev > minT and prev:
periods.append(t0 - prev)
if forGraph:
moves.append((prev, t0))
prev = t1
speeds.popleft()
x0, y0, t0 = x1, y1, t1
if len(periods) > 1:
periodicity = format((median(periods) / 1000), "0.2f")
else:
periodicity = "NA"
result.append(periodicity)
if forGraph:
return moves
return "|".join(map(str, result))
a1 = int(input('insira: '))
a2 = int(input('insira: '))
a3 = int(input('insira: '))
a4 = int(input('insira: '))
a5 = int(input('insira: '))
a6 = int(input('insira: '))
a7 = int(input('insira: '))
a8 = int(input('insira: '))
a9 = int(input('insira: '))
a10 = int(input('insira: '))
a11 = int(input('1-Média, 2-mediana, 3-variância ou 4-desvio padrão. Qual sua escolha? '))
if(a11==1):
print(st.mean([a1,a2,a3,a4,a5,a6,a7,a8,a9,10]))
elif(a11==2):
print(st.median([a1,a2,a3,a4,a5,a6,a7,a8,a9,10]))
elif(a11==3):
print(st.variance([a1,a2,a3,a4,a5,a6,a7,a8,a9,10]))
elif(a11==4):
print(st.stdev([a1,a2,a3,a4,a5,a6,a7,a8,a9,10]))
#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#
ATIVIDADE DIA- 20/04/21
#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#
a = list ()
for a1 in range(0,10):
a.append (float(input('digite: ')))
print(f'os números selecionados foram {a}')
print('os números selecionados foram {}'.format(a))
b = int(input('escolha uma opção: 1-Média, 2-mediana, 3-variância ou 4-desvio. Qual sua escolha? '))
#/usr/bin/python3
#
#Class
print("=" * 100)
print("10.6 Mathematics")
print("=" * 100)
#math
import math
print(math.pi)
print(math.pow(math.cos(1), 2) + math.pow(math.sin(1), 2))
print(math.log(1024, 2))
#random
import random
print(random.choice([1, 2, 3, 4, 5]))
print(random.random())
print(random.randrange(10))
#statistics
import statistics
data = [1, 5, 2.65, 55.2, 46.2, 12]
print(statistics.mean(data))
print(statistics.median(data))
print(statistics.variance(data))
import statistics
import math
file = open('timedif', 'r')
strdeltas = file.readlines()
deltas = list()
total = 0
medianvalue = 0
meanvalue = 0
stderrvalue = 0
stddevvalue = 0
for delta in strdeltas:
deltas.append(int(delta.rstrip()))
total = sum(deltas)
items = len(deltas)
meanvalue = statistics.mean(deltas)
medianvalue = statistics.median(deltas)
stddevvalue = statistics.stdev(deltas)
stderrvalue = stddevvalue / math.sqrt(items)
print("SUM OF ALL DELTAS: ", total)
print("NUMBER OF DELTAS: ", items)
print("MEAN: ", meanvalue)
print("MEDIAN: ", medianvalue)
print("STD ERR: ", stderrvalue)
print("STD DEV: ", stddevvalue)
y = y.astype(int)
for a in range(0, 434):
for b in range(0, 16):
if ('y' in X[a][b]):
X[a][b] = 1
elif ('n' in X[a][b]):
X[a][b] = 0
medians = []
for x in range(0, 16):
acceptable = []
for z in range(0, 434):
if ((X[z][x] == 1) or (X[z][x] == 0)):
acceptable.append(X[z][x])
med = median(acceptable)
medians.append(int(med))
for c in range(0, 434):
for d in range(0, 16):
if ((X[c][d] != 1) and (X[c][d] != 0)):
X[c][d] = medians[d]
X = X.astype(int)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
from sklearn.svm import SVC
classifier = SVC(kernel='linear')
classifier.fit(X_train, y_train)
import math
print(math.cos(math.pi / 4))
print(math.log(1024, 2))
# Módulo random
import random
print(random.choice(['manzana', 'pera', 'banana']))
print(random.sample(range(100), 10)) # elección sin reemplazo
print(random.random()) # un float al azar
print(random.randrange(6)) # un entero al azar tomado de range(6)
# Módulo statistics
import statistics
datos = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5]
print(statistics.mean(datos))
print(statistics.median(datos))
print(statistics.variance(datos))
# Acceso a Internet
"""
from urllib.request import urlopen
with urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl') as response:
for line in response:
line = line.decode('utf-8') # Decoding the binary data to text.
if 'EST' in line or 'EDT' in line: # look for Eastern timer
print(line)
import smtplib
server = smtplib.SMTP('localhost')
server.sendmail('*****@*****.**', '*****@*****.**',
"\"\"To: [email protected]
f.write(bytes(white_precision.to_string(), "utf-8"))
y_pred = np.rint(y_pred).astype(int)
f.write(b"\n")
rang = range(min(min(y_pred), min(y_test)), max(max(y_pred), max(y_test)) + 1)
CM = pd.DataFrame(confusion_matrix(y_test, y_pred), index=rang, columns=rang)
f.write(bytes(CM.to_string(), "utf-8"))
f.write(b"\n")
f.write(b"================================\n")
f.write(b"Median sampling\n")
f.write(b"================================\n")
counter = str(Counter(y_train))
f.write(bytes(counter, "utf-8"))
f.write(b"\n")
median = int(statistics.median(Counter(y_train).values()))
sm = SMOTE(sampling_strategy={
min(y_test): median,
max(y_test): median
},
random_state=24,
k_neighbors=2)
Augmented_X_white, Augmented_Y_white = sm.fit_resample(X_train, y_train)
counter = str(Counter(Augmented_Y_white))
f.write(bytes(counter, "utf-8"))
f.write(b"\n")
clf.fit(Augmented_X_white, Augmented_Y_white)
y_pred = clf.predict(X_test)
white_precision = pd.DataFrame(index=white_class,
columns=["T=0.5 (%)", "T=1.0 (%)"])
def execute(self):
self.log.debug("Executing bot: %s" % self.name)
tolerance = self.config["external_price_tolerance"]
spread = self.config["spread_percent"]
min_balance = self.config["min_balance"]
min_order_size = self.config["min_order_size"]
quote = self.quote_symbol
base = self.base_symbol
## Only load external prices if requires by the bot!
## and update only every maxAgePriceSec seconds
maxAgePriceSec = self.config["maxAgePriceSec"]
if (datetime.utcnow() -
exchanges.lastupdate).total_seconds() > maxAgePriceSec:
log.info("updating price from exchanges")
exchanges.getAllPrices()
# FIXME add weights
true_price_per_btsx = statistics.median(
self.exchanges.price_inbtsx[self.quote_symbol])
median = self.client.get_median(self.quote_symbol)
new_price_per_btsx = true_price_per_btsx
if median > new_price_per_btsx:
new_price_per_btsx = median * MEDIAN_EDGE_MULTIPLE
## Cancel open orders if necessary
canceled = []
quote_freed = 0 # freed funds from closing open orders
base_freed = 0
result = self.client.get_asks_out_of_range(
self.name, quote, base, new_price_per_btsx * (1 + spread),
tolerance)
canceled.extend(result[0])
base_freed += result[1]
result = self.client.get_bids_less_than(self.name, quote, base, median)
canceled.extend(result[0])
quote_freed += result[1]
result = self.client.get_bids_out_of_range(self.name, quote, base,
new_price_per_btsx,
tolerance)
canceled.extend(result[0])
quote_freed += result[1]
asset_balance = self.client.get_balance(self.name, quote) + quote_freed
btsx_balance = self.client.get_balance(self.name, base) + base_freed
available_btsx_balance = btsx_balance - min_balance
available_asset_buy_quantity = (asset_balance /
new_price_per_btsx) - min_balance
if len(canceled) > 0:
self.log.info("Canceling orders: ")
self.log.info("- freeing up %.5f %s" % (quote_freed, quote))
self.log.info("- freeing up %.5f %s" % (base_freed, base))
new_orders = []
if available_asset_buy_quantity > min_order_size:
self.log.info("Submitting a bid...")
new_orders.append([
"bid_order",
[
self.name, available_asset_buy_quantity, base,
new_price_per_btsx, self.quote_symbol
]
])
else:
self.log.info("Skipping bid - %s balance of %.5f is too low" %
(self.quote_symbol, available_asset_buy_quantity))
if available_btsx_balance > min_order_size:
self.log.info("submitting an ask...")
new_orders.append([
"ask_order",
[
self.name, available_btsx_balance, base,
new_price_per_btsx * (1 + spread), self.quote_symbol
]
])
else:
self.log.info("Skipping ask - %s balance of %.5f is too low" %
(self.base_symbol, available_btsx_balance))
for o in new_orders:
self.log.info("new order %s: %s" % (o[0], o[1]))
if len(canceled) > 0 or len(new_orders) > 0:
self.log.info("Committing orders.")
trx = self.client.request("wallet_market_batch_update",
[canceled, new_orders, True]).json()
import statistics as stat
n = int(input())
arr1 = []
arr2 = []
for i in range(n):
list1, list2 = list(map(int, input().split()))
arr1.append(list1)
arr2.append(list2)
mid1 = stat.median(arr1)
mid2 = stat.median(arr2)
sum1 = 0
sum2 = 0
for i in range(n):
sum1 = sum1 + abs(arr1[i] - mid1)
sum2 = sum2 + abs(arr2[i] - mid2)
ans = int(min(sum1, sum2))
print(ans)
