def _addOne(self, _data_struct: DataStruct):
index_value = _data_struct.index()[0]
self.buf.append(_data_struct.getColumn(self.use_key)[0])
if len(self.data) > self.period:
const_std = statistics.pstdev(self.buf[-self.period:])
self.dynamic_n *= const_std / self.prev_std
self.dynamic_n = max(self.min_n, self.dynamic_n)
self.dynamic_n = min(self.max_n, self.dynamic_n)
tmp_n = int(round(self.dynamic_n))
mean = statistics.mean(self.buf[-tmp_n:])
std = statistics.pstdev(self.buf[-tmp_n:])
self.data.addRow(
[index_value, mean + self.rate * std,
mean, mean - self.rate * std],
self.keys
)
self.prev_std = const_std
else:
if len(self.data) == self.period:
self.prev_std = statistics.pstdev(self.buf)
self.data.addRow(
[index_value, None, None, None],
self.keys
)
def output(nums, filesize, filetypec, filetypes, filetime):
fsum = sum(filesize)
print(('%s. %s' % (', '.join('%d %s' % vals for vals in filter(_ig1, zip(nums, ('files', 'directories', 'links', 'mount points', 'errors')))), '%s data.' % sizeof_fmt(fsum))).lstrip('. '))
if not filesize:
return
if len(filesize) > 2:
favg = fsum / len(filesize)
stdev = statistics.pstdev(filesize, favg)
print('File size: max %s, mean %s, median %s, stdev %s' % tuple(map(sizeof_fmt, (max(filesize), favg, statistics.median(filesize), stdev))))
print(' µ+σ (68%): ' + sizeof_fmt(favg + stdev) +
', µ+2σ (95%): ' + sizeof_fmt(favg + stdev * 2))
print('Modification time:')
print(' min ' + time.strftime('%Y-%m-%d %H:%M:%S %Z', time.localtime(min(filetime))))
print(' max ' + time.strftime('%Y-%m-%d %H:%M:%S %Z', time.localtime(max(filetime))))
tavg = statistics.mean(filetime)
print(' mean ' + time.strftime('%Y-%m-%d %H:%M:%S %Z', time.localtime(tavg)))
print(' median ' + time.strftime('%Y-%m-%d %H:%M:%S %Z', time.localtime(statistics.median(filetime))))
print(' stdev ' + timestring(statistics.pstdev(filetime, tavg)))
print('File type by number:')
mcomm = filetypec.most_common(5)
count = sum(filetypec.values())
print('\n'.join(' % 6s: %.2f%%' % (k or '<N/A>', v/count*100) for k, v in mcomm))
print(' Others: %.2f%%' % ((count - sum(v for k, v in mcomm)) / count * 100))
print('File type by size:')
mcomm = filetypes.most_common(5)
count = sum(filetypes.values())
print('\n'.join(' % 6s: %.2f%%' % (k or '<N/A>', v/count*100) for k, v in mcomm))
print(' Others: %.2f%%' % ((count - sum(v for k, v in mcomm)) / count * 100))
def insertNormalizedModelInDB(idUser, idString, keystroke, isTest = False):
insertNormalizedRecord = replaceIfIsTest("INSERT INTO `mdl_user#isTest_keystroke_normalized`(`id_user`, `id_string`) VALUES (%s, %s)", isTest);
updateNormalizedRecord = replaceIfIsTest("UPDATE `mdl_user#isTest_keystroke_normalized` ", isTest);
executeSqlInDB(insertNormalizedRecord, (idUser, idString));
keyDimensionsExtractor = KeystrokeDimensionsExtractor(keystroke);
#extracting dimensions
timePressed = keyDimensionsExtractor.getTimePressed();
#geting avarage and standardDeviation
timePressedAverage = statistics.mean(timePressed);
timePressedstandardDeviation = statistics.pstdev(timePressed);
latencies = keyDimensionsExtractor.getLatencies();
latenciesAverage = statistics.mean(latencies);
latenciesStandardDeviation = statistics.pstdev(latencies);
dbModel = {
'id_user': idUser,
'id_string': idString,
'press_average': timePressedAverage,
'latency_avarage': latenciesAverage,
'press_standard_deviation': timePressedstandardDeviation,
'latency_standard_deviation': latenciesStandardDeviation,
}
#update in table created before
updateNormalizedRecord = updateNormalizedRecord + (" SET `press_average`= %(press_average)s,`latency_avarage`= %(latency_avarage)s, `press_standard_deviation`= %(press_standard_deviation)s,`latency_standard_deviation`= %(latency_standard_deviation)s "
" WHERE `id_user`= %(id_user)s AND `id_string`= %(id_string)s");
executeSqlInDB(updateNormalizedRecord, dbModel);
def nutritionfacts(self):
# print keys
svgdata = ""
frame_x = self.width * self.bins + 100 - 90
frame_y = (self.graphheight + 700) // 2 + 25 - self.graphheight
for i, s in enumerate([l for l in self.points if l[2]]):
mu = "μ = —"
sigma = "σ = —"
if len(s[0]) != 0:
xmean = stat.mean([t[0] for t in s[0]])
xsigma = stat.pstdev([t[0] for t in s[0]], xmean)
ymean = stat.mean([t[1] for t in s[0]])
ysigma = stat.pstdev([t[1] for t in s[0]], ymean)
mu = "μ = (" + str(round(xmean, 4)) + ", " + str(round(ymean, 4)) + ")"
sigma = "σ = (" + str(round(xsigma, 4)) + ", " + str(round(ysigma, 4)) + ")"
line_y = frame_y + i * 65
svgdata += circle(frame_x - 4, line_y + 3, 2, s[1])
svgdata += circle(frame_x + 4, line_y + 4, 2, s[1])
svgdata += circle(frame_x - 1, line_y + 10, 2, s[1])
svgdata += text(frame_x + 20, line_y + 10, s[2], align=-1, color=s[1], font="Neue Frutiger 65")
svgdata += text(frame_x + 28, line_y + 25, "n = " + str(len(s[0])), align=-1, color=s[1])
svgdata += text(frame_x + 28, line_y + 40, mu, align=-1, color=s[1])
svgdata += text(frame_x + 28, line_y + 55, sigma, align=-1, color=s[1])
self._frostbyte(svgdata)
def morpheme_stdev(trie: MorphemeTrie, reverse_trie: MorphemeTrie) -> (float, float, float):
trie_mpr, reverse_trie_mpr = (list(trie.morphemes_per_word()),
list(reverse_trie.morphemes_per_word()))
stdev_trie = pstdev(trie_mpr)
stdev_reverse_trie = pstdev(reverse_trie_mpr)
stdev_combined = pstdev(trie_mpr + reverse_trie_mpr)
return stdev_trie, stdev_reverse_trie, stdev_combined
def normalize_geojson(js_data): pols = [] subs = [] for js in js_data: pols.append(js.get_avg_polarity()) subs.append(js.get_avg_subjectivity()) max_pol = max(pols) min_pol = min(pols) max_sub = max(subs) min_sub = min(subs) old_range_pol = (max_pol - min_pol) old_range_sub = (max_sub - min_sub) for js in js_data: sub = (js.mAvgSubjectivity - min_sub) / old_range_sub sub -= .5 sub *= 1.25 sub += stats.pstdev(subs)/2 sub += .5 sub = max(0, sub) sub = min(1, sub) js.mAvgSubjectivity = sub pol = (js.mAvgPolarity - min_pol) / old_range_pol pol -= .5 pol *= 1.25 pol += stats.pstdev(pols)/2 pol += .5 pol = max(0, pol) pol = min(1, pol) js.mAvgPolarity = pol return js_data
def sd_extreme_ex (a,b,c,d,e):
normal_sd = pstdev([a,b,c,d,e])
min_sd = 1000000000
max_sd = 0
val1 = 0
val2 = 0
val3 = 0
val4 = 0
val5 = 0
for i in list(range(0,11)):#31
for j in list(range(0,11)):
for k in list(range(0,11)):
for p in list(range(0,11)):
for q in list(range(0,11)):
val1 = a - i*0.1
val2 = b - j*0.1
val3 = c - k*0.1
val4 = d - p*0.1
val5 = e - q*0.1
sd = pstdev([val1,val2,val3,val4,val5])
if (sd>=max_sd):
max_sd = sd
if (sd<=min_sd):
min_sd = sd
#print('.',end="",flush=True)
print(max_sd-normal_sd)
print(min_sd-normal_sd)
def pearson(A, B):
M = len(A)
assert M == len(B)
A_mean = statistics.mean(A)
A_stdev = statistics.pstdev(A)
B_mean = statistics.mean(B)
B_stdev = statistics.pstdev(B)
cross_mean = sum(A[i] * B[i] for i in range(M)) / M
return (cross_mean - A_mean * B_mean) / (A_stdev * B_stdev)
def calculate_mean(TE_program):
my_directory = sys.argv[1]
files=''
items = []
for results_file in os.listdir(my_directory):
match = re.findall("(FAMILY_TFPN_ALL*)",results_file)
if len(match) >0:
print "yes"
print results_file
files+=str(" {results_file}".format(**locals()))
TPR_fam={}
FDR_fam={}
TPR_fam = defaultdict(list)
FDR_fam = defaultdict(list)
fam_found = {}
#get rid of leading space...next tiem append space after file:
files= files[1:]
files_to_test = files.split(' ')
for sim_file in files_to_test:
OPEN_SIM_FILE = open(sim_file, "r")
for line in OPEN_SIM_FILE:
if re.search(TE_program,line):
line = line.rstrip('\n')
items= re.split("[\t]",line) # WILL NEED TO CHANGE THESE
M1 = items[0]
fam = items[1]
TPR = items[5]
FDR = items[6]
if TPR !="NA":
TPR_fam[fam].append(TPR)
fam_found[fam] = 0
FDR_fam[fam].append(FDR)
for key in FDR_fam.keys():
print key
print FDR_fam[key]
for key in sorted(all_families.keys()):
if key in fam_found.keys():
TPR_fam[key] = map(float, TPR_fam[key]) #convert strings in list to integers
mean_TPR = statistics.mean(TPR_fam[key])
standard_deviation_TPR = statistics.pstdev(TPR_fam[key])
else:
mean_TPR = "NA"
standard_deviation_TPR = "NA"
FDR_fam[key] = map(float, FDR_fam[key])
print key
print FDR_fam[key]
mean_FDR = statistics.mean(FDR_fam[key])
standard_deviation_FDR = statistics.pstdev(FDR_fam[key])
print "The mean_TPR is {mean_TPR}".format(**locals())
print "The standard deviation TPR is {standard_deviation_TPR}".format(**locals())
OUT.write ("{M1}\t{key}\t{mean_TPR}\t{mean_FDR}\t{standard_deviation_TPR}\t{standard_deviation_FDR}\n".format(**locals()))
def eliminate_sd(alphabet,v): new_alphabet = [] for i in alphabet: sd_min = pstdev(i[0])-0.5 sd_max = pstdev(i[0])+0.5 #if intersect(v-1,v,sd_min,sd_max): if intersect(v*0.5-0.5,v*0.5,sd_min,sd_max): new_alphabet.append(i) #print(new_alphabet) return (new_alphabet)
def printOverTime(label, this_acc_over_time, this_conf_over_time):
print('\n\n' + str(label))
for numEvents in this_acc_over_time:
accMean = st.mean(this_acc_over_time[numEvents])
accStd = st.pstdev(this_acc_over_time[numEvents])
confMean = st.mean(this_conf_over_time[numEvents])
confStd = st.pstdev(this_conf_over_time[numEvents])
print(str(numEvents) + '\t' + str(accMean) + '\t' + str(accStd) + '\t' + str(confMean) + '\t' + str(confStd))
def get_meanCV(file):
CSV_file = pandas.read_csv(file)
expt_samples = len(CSV_file)
DNAs = 7
replicates = expt_samples/DNAs
if "A13" in CSV_file["Well"].values:
plate_map = Container(None, _CONTAINER_TYPES['384-pcr'])
else:
plate_map = Container(None, _CONTAINER_TYPES['96-pcr'])
start = 0
replicate_locs = []
for i in range (0,DNAs-1):
loc = [plate_map.humanize(s) for s in range(start, start + replicates)]
replicate_locs.append(loc)
start += replicates
DNA_Ct = []
for h in replicate_locs:
for x in h:
Replicate_Ct_DNA = []
data_source = open(file)
replicate_locations = h
for line in data_source:
split_line=line.split(',')
wellID=split_line[0]
Ct=split_line[3]
for w in replicate_locations:
if w == wellID:
try:
Replicate_Ct_DNA.append(float(Ct))
except:
Replicate_Ct_DNA.append(0.0)
DNA_Ct.append(Replicate_Ct_DNA)
percentageCV = []
for n in DNA_Ct:
try:
percentageCV.append(((stats.pstdev(n)/stats.mean(n))*100))
except ZeroDivisionError as err:
percentageCV.append(0.0)
meanCV = stats.mean(percentageCV)
for n in DNA_Ct:
line = []
line.append(stats.mean(n))
line.append(stats.pstdev(n))
mean_SD.append(line)
writer = csv.writer(open('./output/mean_SD.csv', 'w'))
writer.writerows(mean_SD)
return meanCV
def __init__(self, data_list):
# Null values are counted as 0
list_total = []
# Without null values
list = []
self.total_filled = 0
self.total_not_filled = 0
self.quintilesX = []
self.quintilesY = []
for data in data_list:
if data != "":
list_total.append(int(data))
list.append(int(data))
self.total_filled += 1
else:
list_total.append(0)
self.total_not_filled += 1
if list != []:
self.mean = round(mean(list), 2)
self.standard_deviation = round(pstdev(list, self.mean), 2)
minimum = min(list)
maximum = max(list)
quintile_length = math.floor((maximum - minimum + 1) / 5)
# First 4 quintiles
first = minimum
for i in range(1, 5):
second = first + quintile_length
quintile_x = "[" + str(first) + ", " + str(second) + ")"
self.quintilesX.append(quintile_x)
quintile_y = 0
for num in list:
if (first <= num) and (num < second):
quintile_y += 1
self.quintilesY.append(quintile_y)
first = second
# Last quintile
self.quintilesX.append("[" + str(first) + ", " + str(maximum) + "]")
quintile_y = 0
for num in list:
if (first <= num) and (num <= maximum):
quintile_y += 1
self.quintilesY.append(quintile_y)
else:
self.mean = 0
self.standard_deviation = 0
self.total_mean = round(mean(list_total), 2)
self.total_standard_deviation = round(pstdev(list_total, self.total_mean), 2)
def calculate_feature_statistics(self, series_key='series'):
for key in self.sound_files[0].analysis[series_key]:
self.feature_statistics[key] = {
'min': None,
'max': None,
'mean': None,
'standard_deviation': None
}
for feature in self.feature_statistics:
series = []
for sf in self.sound_files:
if isinstance(sf.analysis[series_key][feature][0], list):
series += Standardizer.join_lists(sf.analysis[series_key][feature])
else:
series += sf.analysis[series_key][feature]
if len(series) == 0:
continue
self.feature_statistics[feature]['min'] = min(series)
self.feature_statistics[feature]['max'] = max(series)
self.feature_statistics[feature]['mean'] = statistics.mean(series)
self.feature_statistics[feature]['standard_deviation'] = statistics.pstdev(series)
return self.feature_statistics
def _stat(nums, prefix, spec='aimsd'):
"""Compute general statistics for a given list of numbers.
:param nums: a list of numbers
:type nums: int or float
:param prefix: string prefix to append to dict keys returned
:type prefix: str
:param spec: features to compute, a=max, i=min, m=mean,
s=stdev, d=median, e=entropy
:type spec: str
:return: dictionary of features computed
:rtype: dict
"""
if not nums:
return {}
d = {}
if 'a' in spec:
d[prefix + '_largest'] = max(nums)
if 'i' in spec:
d[prefix + '_smallest'] = min(nums)
if 'm' in spec:
d[prefix + '_mean'] = statistics.mean(nums)
if 's' in spec:
d[prefix + '_sd'] = statistics.pstdev(nums)
if 'd' in spec:
d[prefix + '_median'] = statistics.median(nums)
if 'e' in spec:
d[prefix + '_entropy'] = 0.0
for val in nums:
if val <= 0.0:
continue
d[prefix + '_entropy'] += val * math.log(val, 2)
d[prefix + '_entropy'] = -d[prefix + '_entropy']
return d
def print_score_dist(comments):
# Print the distribution of scores.
# The min, max, mean, median, std-dev.
# Return the statistics in a hash.
scores = [c['score'] for c in comments]
min_score = min(scores)
max_score = max(scores)
mean_score = statistics.mean(scores)
median_score = statistics.median(scores)
pstdev_score = statistics.pstdev(scores)
print("Comment score distribution")
print("==========================")
print("Min: {}, Max: {}".format(min_score, max_score))
print("Mean: {:.4f}, Median: {}".format(mean_score, median_score))
print("Population stdev: {:.4f}".format(pstdev_score))
print()
#TODO: Show chart here.
return {
'min': min_score,
'max': max_score,
'mean': mean_score,
'median': median_score,
'pstdev': pstdev_score,
}
def statistics_for_time_points(time_points: list, header: str) -> str:
time_in_seconds = [t.total_seconds() for t in time_points]
mean_time = time.strftime("%H:%M", time.gmtime(st.mean(time_in_seconds)))
median_time = time.strftime("%H:%M", time.gmtime(st.median(time_in_seconds)))
std_deviation = time.strftime("%H:%M", time.gmtime(st.pstdev(time_in_seconds)))
try:
mode_time = time.strftime("%H:%M", time.gmtime(st.mode(time_in_seconds)))
except st.StatisticsError:
mode_time = "-"
min_time = time.strftime("%H:%M", time.gmtime(min(time_in_seconds)))
max_time = time.strftime("%H:%M", time.gmtime(max(time_in_seconds)))
value_width = 5
key_width = len(header) - value_width
row_format = "\n{{:<{key_width}}}{{:>{value_width}}}".format(key_width=key_width, value_width=value_width)
delimiter = "\n" + "-" * len(header)
stats_string = header
stats_string += delimiter
stats_string += row_format.format("Mean:", mean_time)
stats_string += row_format.format("Median:", median_time)
stats_string += row_format.format("Standard deviation:", std_deviation)
stats_string += row_format.format("Mode:", mode_time)
stats_string += row_format.format("Earliest:", min_time)
stats_string += row_format.format("Latest:", max_time)
stats_string += delimiter
stats_string += "\n{} values".format(len(time_in_seconds))
return stats_string
def main():
rain_prob = 0.3
rain_distribution = {"mu": 35, "sigma": 5}
sunny_distribution = {"mu": 50, "sigma": 8}
avg_earnings = []
sigma_up = []
sigma_down = []
h_w = []
r = range(20,100)
it = 1000
for x in r:
earnings_arr = []
for i in range(it):
earnings_arr.append(canillita(rain_prob, x, rain_distribution, sunny_distribution))
avg = sum(earnings_arr)/it
sigma = statistics.pstdev(earnings_arr)
h_w.append((2 * sigma)/math.sqrt(it))
sigma_up.append(avg + h_w[-1])
sigma_down.append(avg - h_w[-1])
avg_earnings.append(avg)
print(str(avg) + '\n')
best_avg = max(avg_earnings)
best_index = avg_earnings.index(best_avg)
print('Best:')
print('Earnings: ' + str(best_avg))
print('Qty: ' + str(best_index + min(r)))
print('Half width: ' + str(h_w[best_index]))
mp.plot(r, avg_earnings, r, sigma_down, r, sigma_up)
mp.show()
def __calcTCPStatVals(self, UP, DN):
if UP:
upMean = mean(UP)
upStDev = pstdev(UP)
else:
upMean = -1
upStDev = -1
if DN:
dnMean = mean(DN)
dnStDev = pstdev(DN)
else:
dnMean = -1
dnStDev = -1
#END IF/ELSEs
return [upMean, upStDev, (upMean-upStDev),
dnMean, dnStDev, (dnMean-dnStDev)]
def get_morpheme_occurrence(trie: MorphemeTrie, reverse_trie: MorphemeTrie) -> (float,):
"""calculates data on how often each morpheme occurs in the corpus"""
morphemes_ltr = Counter(chain.from_iterable(trie.morphemes))
morphemes_rtl = Counter(chain.from_iterable(reverse_trie.morphemes))
morpheme_occurrences_ltr = morphemes_ltr.values()
morpheme_occurrences_rtl = morphemes_rtl.values()
mean_occurrence_ltr = mean(morpheme_occurrences_ltr)
mean_occurrence_rtl = mean(morpheme_occurrences_rtl)
stdev_morphemes_ltr = pstdev(morpheme_occurrences_ltr, mu=mean_occurrence_ltr)
stdev_morphemes_rtl = pstdev(morpheme_occurrences_rtl, mu=mean_occurrence_rtl)
occurrence_data = ((mean_occurrence_ltr, mean_occurrence_rtl),
(stdev_morphemes_ltr, stdev_morphemes_rtl))
return occurrence_data
def con_test(stat_list, player, stat_name): # Computes actual data points from data given via consist_test
if stat_list:
con_stat = (mean(stat_list), pvariance(stat_list), pstdev(stat_list))
return con_stat
else:
print('NO DATA FOR: '+player+', '+stat_name)
return 0
def plot(data_name):
data = {}
# Load the data
with open(data_name + '.csv', 'r') as csvfile:
reader = csv.reader(csvfile)
for row in reader:
for i in range(0,len(row)):
data.setdefault(i,[])
data[i].append(float(row[i]))
# Compute means
means = []
for (t,values) in data.items():
m = statistics.mean(values)
d = statistics.pstdev(values)
means.append(m)
# Bag the results
x = [int(round(x)) for x in numpy.logspace(0.1, 3, num=10, endpoint=True)]
y = []
for index_x in range(0, len(x)):
start = x[index_x-1]-1 if index_x > 0 else 0
end = x[index_x]
y.append(statistics.mean(means[start:end]))
# Plot
f = interp1d(x, y, kind='cubic')
fig = plt.figure(figsize=(10, 5))
plt.xscale('log')
plt.xlabel('Number of entries in the journal')
plt.ylabel('Response time in seconds')
plt.plot(x, y)
plt.plot(x, y, 'ro')
plt.savefig(data_name + '.png',dpi=150)
def _addOne(self, _data_struct: DataStruct):
index_value = _data_struct.index()[0]
self.buf.append(_data_struct.getColumn(self.use_key)[0])
self.data.addDict({
self.idx_key: index_value,
self.ret_key: statistics.pstdev(self.buf),
})
def log_tests(no_of_tests):
global apicall
print("Tests will finish around:", time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time() + no_of_tests*6)))
results = run_test(no_of_tests)
for i, res in enumerate(results):
res_mean = mean(res)
res_pstdev = pstdev(res, res_mean)
over_one_sec = 0
timeout = 0
fname = "result" + str(i) + ".csv"
with open(fname, "w+") as f:
for r in res:
print(i, r)
f.write(str(r) + "\n")
if r > 0.5:
over_one_sec += 1
if r == -1.0:
timeout += 1
#Remove all timeouts/errors (-1.0)
res = list(filter(lambda x: x >= 0, res))
fname2 = "result-summary.csv"
with open(fname2, "a") as f2:
f2.write(apicall[i] + "; " + str(len(res)) + "; " + str(res_mean) + "; " + str(res_pstdev) + "; " + str(over_one_sec) + "; " + str(max(res)) + "; " + str(timeout) + "\n")
def stats_helper(list):
"""
https://docs.python.org/3/library/statistics.html#statistics.pvariance
:param list:
:return:
"""
mean = statistics.mean(list)
mode = None
try:
mode = statistics.mode(list)
except statistics.StatisticsError:
# no unique mode
pass
return {
'mean': mean,
'variance': statistics.pvariance(list, mu=mean),
'standard_deviation': statistics.pstdev(list, mu=mean),
'median': statistics.median(list),
'median_low': statistics.median_low(list),
'median_high': statistics.median_high(list),
'median_grouped': statistics.median_grouped(list),
'mode': mode
}
def RunSeason(self):
import time
print "Simulating approx. " + str(self.finaltotal) + " games."
print "Mean " + str(2 * self.finaltotal / self.nplayers) + " games per player."
print "Standard deviation " + str(pstdev([P.ngames for P in self.liveplayers]))
start_time = time.clock()
while len(self.liveplayers) >= 2:
self.PlayAGame()
barlength = 38
blocks = barlength * self.totalgames / self.finaltotal
percent = 100*self.totalgames / self.finaltotal
text = "\rPercent: [{0}] {1}%".format( "=" * blocks + " " * (barlength - blocks), percent)
sys.stdout.write(text)
sys.stdout.flush()
end_time = time.clock()
elapsed_time = end_time - start_time
self.histogram = [len(R) for R in self.deadranks]
print "\n" + str(self.totalgames) + " games simulated in " + str(elapsed_time) + " seconds (" + str(self.totalgames / elapsed_time) + " games per second)."
def print_stats(times, nodes):
print("Nodes:")
for node in nodes:
print(" {}:{}:{}".format(node['address'], node['port'], node['job_slots']))
pprint(times)
stats = dict((key, dict(mean=statistics.mean(data), stdev=statistics.pstdev(data))) for key, data in times.items())
pprint(stats)
def calc_mean_std(self):
'''
Using power rankings data, calculates the mean and std for each team.
Returns a dict of tuples in the form {Team1: (mean, std)}
'''
mean_std_dict = {team: (statistics.mean(self.pr_data[team]), statistics.pstdev(self.pr_data[team])) for team in self.pr_data}
return mean_std_dict
def concept_to_concept_threshold_char(concept,name):
#print "Concept_to_Concept ", name
conList = []
docs = [(name + concept)]
for x in range(0,len(concept)):
docs.append((name+concept[0:x]))
tfidf_matrix = tfidf_vectorizer.fit_transform(docs)
matrix = cosine_similarity(tfidf_matrix[0:1], tfidf_matrix)
#print matrix
for row in matrix:
for x in row[1:]:
conList.append(x)
mean = statistics.mean(conList)
stdev = statistics.pstdev(conList)
thld = 1 - (Num_Deviations * stdev)
#print abs(mean_confidence_interval(mean,stdev))
#thld1 = thld - abs(mean_confidence_interval(mean,stdev))
#if thld == 1:
#return
#print statistics.pstdev(conList)
#print thld
#out = [thld,thld1]
#wr.writerow(out)
return thld
def calculate_daily_stats(daily_ret):
'''
For a simulation of 1-day returns, calculate mean and std dev
'''
return {
"mean": stats.mean(daily_ret),
"standard deviation": stats.pstdev(daily_ret)
}
num = statistics.median_low(a) print(num) a = [1, 2, 3, 4, 5] num = statistics.median_high(a) print(num) a = [1, 2, 3, 4] num = statistics.median_grouped(a) print(num) a = [1, 2, 3, 4, 5, 4] num = statistics.mode(a) print(num) a = [1, 2, 3, 4, 5, 1] num = statistics.mode(a) print(num) a = [1, 2, 3, 4] num = statistics.stdev(a) print(num) a = [1, 2, 3, 4] num = statistics.pvariance(a) print(num) a = [1, 2, 3, 4] num = statistics.pstdev(a) print(num)
conferences2[1] = scaler1.fit_transform(conferences2[1])
conferences2[1] = [round(x[0]) for x in conferences2[1]]
scaler2 = MinMaxScaler((0, 18))
participants2[1] = [[x] for x in participants[1]]
participants2[1] = scaler2.fit_transform(participants2[1])
participants2[1] = [round(x[0]) for x in participants2[1]]
xformatter = mdates.DateFormatter('%H:%M', tz=timezone(timedelta(hours=9)))
part_per_conf = []
for i in range(len(conferences[1])):
if int(participants[1][i]) != 0:
part_per_conf.append(conferences[1][i] / participants[1][i])
avg = statistics.mean(part_per_conf)
std = statistics.pstdev(part_per_conf)
last_conf_id = 0
stagnant_conf_num = 0
conferences_time = {}
active_conferences = []
for i, n in enumerate(conferences2[1]):
if len(active_conferences) < n:
stagnant_conf_num = 0
curr_total_participants = 0
for ac in active_conferences:
for p in ac['participants']:
curr_total_participants += p['num']
expected_total_participants = participants2[1][i]
approx_part_per_conf = (expected_total_participants -
curr_total_participants) / (
def test_node_load_consistent_time(tconf, change_checkpoint_freq,
disable_node_monitor_config, looper,
txnPoolNodeSet, tdirWithPoolTxns,
allPluginsPath, poolTxnStewardData, capsys):
# One of the reason memory grows is because spylog grows
client, wallet = buildPoolClientAndWallet(poolTxnStewardData,
tdirWithPoolTxns,
clientClass=TestClient)
looper.add(client)
looper.run(client.ensureConnectedToNodes())
client_batches = 300
txns_per_batch = 25
time_log = []
warm_up_batches = 10
tolerance_factor = 2
print_detailed_memory_usage = False
from pympler import tracker
tr = tracker.SummaryTracker()
node_methods_to_capture = [
TestNode.executeBatch, TestNode.recordAndPropagate,
TestNode.domainDynamicValidation, TestNode.domainRequestApplication
]
times = {
n.name: {meth.__name__: []
for meth in node_methods_to_capture}
for n in txnPoolNodeSet
}
for node in txnPoolNodeSet:
for meth in node_methods_to_capture:
meth_name = meth.__name__
patched = timeit(getattr(node, meth_name),
times[node.name][meth_name])
setattr(node, meth_name, patched)
for i in range(client_batches):
s = perf_counter()
sendReqsToNodesAndVerifySuffReplies(looper,
wallet,
client,
txns_per_batch,
override_timeout_limit=True)
t = perf_counter() - s
with capsys.disabled():
print('{} executed {} client txns in {:.2f} seconds'.format(
i + 1, txns_per_batch, t))
print('--------Memory Usage details start')
for node in txnPoolNodeSet:
# print(sys.getsizeof(node))
print('---Node {}-----'.format(node))
# print('Requests {}'.format(asizeof.asizeof(node.requests, detail=1)))
print(
get_memory_usage(node,
print_detailed_memory_usage,
get_only_non_empty=True))
for r in node.replicas:
print('---Replica {}-----'.format(r))
print(
get_memory_usage(r,
print_detailed_memory_usage,
get_only_non_empty=True))
# if i % 3 == 0:
# tr.print_diff()
print('--------Memory Usage details end')
for node in txnPoolNodeSet:
for meth in node_methods_to_capture:
ts = times[node.name][meth.__name__]
print('{} {} {} {}'.format(node, meth.__name__, mean(ts),
ts))
if len(time_log) >= warm_up_batches:
m = mean(time_log)
sd = tolerance_factor * pstdev(time_log)
assert m > t or abs(t - m) <= sd, '{} {}'.format(abs(t - m), sd)
time_log.append(t)
# Since client checks inbox for sufficient replies, clear inbox so that
# it takes constant time to check replies for each batch
client.inBox.clear()
client.txnLog.reset()
idadeordenada = sorted(df['AgeAtHeartAttack'].tolist())
idadeMedia = df['AgeAtHeartAttack'].mean()
idadeModa = df['AgeAtHeartAttack'].mode()
idadeMediana = statistics.median(idade)
idadePontoMedio = (idadeordenada[0] +
idadeordenada[len(idadeordenada) - 1]) / 2
print("Média de pessoas que sofreram de ataques cardíacos no estudo")
print("Média = " + str(idadeMedia))
print("Moda = " + str(idadeModa[0]))
print("Mediana = " + str(idadeMediana))
print("Ponto Médio = " + str(idadePontoMedio))
idadeAmplitude = idadeordenada[len(idadeordenada) - 1] - idadeordenada[0]
idadeDesvioPadrao = statistics.pstdev(idade)
idadeVariancia = statistics.pvariance(idade)
idadeCoeficienteVariacao = (idadeDesvioPadrao / idadeMedia) * 100
print("\nMedidas de dispersão da idade dos pacientes registrados")
print("Amplitude = " + str(idadeAmplitude))
print("Desvio Padrão = " + str(idadeDesvioPadrao))
print("Variância = " + str(idadeVariancia))
print("Coeficiente de Variação = " + str(round(idadeCoeficienteVariacao, 2)) +
"%\n")
idade = df['AgeAtHeartAttack']
idade_descri = idade.describe()
q1 = idade_descri['25%']
mediana = idade_descri['50%']
def testStdev(self, stdev):
if stat.pstdev(self.List) == stdev:
return True
else:
return False
for r in all_records:
d = r.date
d = d.split('-')
d = '/'.join(d[1:])
m = r.tmin
if measure == 'avg':
m = r.tavg
elif measure == 'max':
m = r.tmax
temps_by_date[d].append(float(m))
all_stat_results = []
StatResults = namedtuple('StatResults', 'date avg stdev temp_to_use')
for d, temps in temps_by_date.items():
avg = statistics.mean(temps)
stdev = statistics.pstdev(temps)
temp_to_use = int(round(avg + stdev_multiplier * stdev))
avg = int(round(avg))
stdev = round(stdev, 1)
stat_results = StatResults(d, avg, stdev, temp_to_use)
all_stat_results.append(stat_results)
x = []
y = []
for sr in all_stat_results:
month, day = sr.date.split('/')
month = int(month)
day = int(day)
m = sr.temp_to_use
x.append(m)
y.append(get_distance_from_mid_jan(month, day))
def main():
ExcelFileName = "Data.xlsx"
workbook = xlsxwriter.Workbook(ExcelFileName)
worksheet = workbook.add_worksheet()
HorizAlign = workbook.add_format()
HorizAlign.set_align('center')
LastRowAvailable = 0
worksheet.write(LastRowAvailable, 0, "Cycle")
worksheet.write(LastRowAvailable, 1, "Stats")
for Class in range(Classes):
worksheet.write(LastRowAvailable, 2 + Class, "R" + str(Class))
LastRowAvailable += 1
for root, dirs, files in os.walk(
'C:\Taima_Furuyama\Mestrado_UNIFESP\Programacao\Python\Simulacoes\TestesEstatisticos\ENVELOPE'
):
SourceFiles = [_ for _ in files if _.endswith('.xlsx')]
NumberOfFiles = len(SourceFiles)
print(NumberOfFiles)
PercentArray = [[[None for i in range(NumberOfFiles)]
for x in range(Classes)] for y in range(Cycles)]
for xlsfile in SourceFiles:
SourceFile = xlrd.open_workbook(os.path.join(root, xlsfile))
SourceSheet = SourceFile.sheet_by_index(0)
for Cycle in range(Cycles): #Ciclos
for Class in range(Classes): #Classes R
RParticles = SourceSheet.cell_value(rowx=Cycle + 1,
colx=Class + 8)
CycleTotal = SourceSheet.cell_value(rowx=Cycle + 1, colx=1)
Percent = (RParticles / CycleTotal) * 100
PercentArray[Cycle][Class].pop(0)
PercentArray[Cycle][Class].append(Percent)
# print(PercentArray[9][10][0])
# print(len(PercentArray[9][10]))
MeanArray = [[None for x in range(Classes)] for y in range(Cycles)]
MedianArray = [[None for x in range(Classes)] for y in range(Cycles)]
StdDevArray = [[None for x in range(Classes)] for y in range(Cycles)]
MinArray = [[None for x in range(Classes)] for y in range(Cycles)]
MaxArray = [[None for x in range(Classes)] for y in range(Cycles)]
VarArray = [[None for x in range(Classes)] for y in range(Cycles)]
# print(MeanArray)
# these 2 FOR LOOPS calculate the statistical parameters
for Cycle in range(Cycles):
for Class in range(Classes):
MeanArray[Cycle].pop(0)
Mean = statistics.mean(PercentArray[Cycle][Class])
MeanArray[Cycle].append(Mean)
MedianArray[Cycle].pop(0)
Median = statistics.median(PercentArray[Cycle][Class])
MedianArray[Cycle].append(Median)
StdDevArray[Cycle].pop(0)
StdDev = statistics.pstdev(PercentArray[Cycle][Class])
StdDevArray[Cycle].append(StdDev)
MinArray[Cycle].pop(0)
Min = min(PercentArray[Cycle][Class])
MinArray[Cycle].append(Min)
MaxArray[Cycle].pop(0)
Max = max(PercentArray[Cycle][Class])
MaxArray[Cycle].append(Max)
VarArray[Cycle].pop(0)
Var = statistics.pvariance(PercentArray[Cycle][Class])
VarArray[Cycle].append(Var)
# print(MeanArray)
# print(MedianArray)
# print(StdDevArray)
# print(MinArray)
# print(MaxArray)
# these 2 FOR LOOPS write the data to a Excel file
for Cycle in range(Cycles):
worksheet.write(LastRowAvailable, 0, Cycle)
for Class in range(Classes):
worksheet.write(LastRowAvailable, 1, "Mean")
worksheet.write(LastRowAvailable + 1, 1, "Median")
worksheet.write(LastRowAvailable + 2, 1, "StdDev")
worksheet.write(LastRowAvailable + 3, 1, "Min")
worksheet.write(LastRowAvailable + 4, 1, "Max")
worksheet.write(LastRowAvailable + 5, 1, "Var")
worksheet.write(LastRowAvailable, Class + 2,
MeanArray[Cycle][Class])
worksheet.write(LastRowAvailable + 1, Class + 2,
MedianArray[Cycle][Class])
worksheet.write(LastRowAvailable + 2, Class + 2,
StdDevArray[Cycle][Class])
worksheet.write(LastRowAvailable + 3, Class + 2,
MinArray[Cycle][Class])
worksheet.write(LastRowAvailable + 4, Class + 2,
MaxArray[Cycle][Class])
worksheet.write(LastRowAvailable + 5, Class + 2,
VarArray[Cycle][Class])
LastRowAvailable += 6
workbook.close()
def updatePopStdDev(self, index):
self.updatePopList()
self.popStdDevs[index] = statistics.pstdev(self.populationLists[index])
urlformat = "https://www.basketball-reference.com/leagues/NBA_{0}_games-{1}.html".format(year, month)
urllist.append(urlformat)
pointdifferentials = []
for u in urllist:
url = u
html = urlopen(url)
soup = BeautifulSoup(html, features='html.parser')
visitor = soup.findAll('td', {'data-stat': 'visitor_pts'})
home = soup.findAll('td', {'data-stat': 'home_pts'})
convertText(visitor)
convertText(home)
for a in range(len(visitor)):
pointdifferentials.append(abs(visitor[a]-home[a]))
#print(pointdifferentials)
average_pointdifferential = average(pointdifferentials)
population_deviation = stat.pstdev(pointdifferentials)
#print(population_deviation)
print("Teams this season won their games by an average of", str(average_pointdifferential), "points.")
#This is the section for the statistics for a team that season.
team = input('Enter team abbreviation (e.g. ATL for Atlanta Hawks): ')
teamurl = 'https://www.basketball-reference.com/teams/{0}/{1}_games.html'.format(team, year)
html = urlopen(teamurl)
soup = BeautifulSoup(html, features='html.parser')
regseason = soup.findAll('div', {'id': 'all_games'})
for games in regseason:
selfscore = games.find_all('td', {'data-stat': 'pts'})
oppscore = games.find_all('td', {'data-stat': 'opp_pts'})
selfscores = []
oppscores = []
for score1, score2 in zip(selfscore, oppscore):
selfscores.append(int(score1.text))
names = [
'NB', 'KNN', 'SVC', 'RF', 'LR', 'LSTM_onFly', 'LSTM_Pre', 'LSTM_Bi', 'GRU'
]
accuMean = []
f1Mean = []
precisionMean = []
recallMean = []
accuSD = []
f1SD = []
precisionSD = []
recallSD = []
for i in range(accuDF.shape[1]):
accuSD.append(st.pstdev(accuDF.iloc[:, i]))
f1SD.append(st.pstdev(f1DF.iloc[:, i]))
precisionSD.append(st.pstdev(precDF.iloc[:, i]))
recallSD.append(st.pstdev(recDF.iloc[:, i]))
accuMean.append(st.mean(accuDF.iloc[:, i]))
f1Mean.append(st.mean(f1DF.iloc[:, i]))
precisionMean.append(st.mean(precDF.iloc[:, i]))
recallMean.append(st.mean(recDF.iloc[:, i]))
df_metric100 = pd.DataFrame({
'Accuracy_Mean': accuMean,
'Accuracy_SD': accuSD,
'Precision_Mean': precisionMean,
'Precision_SD': precisionSD,
'Recall_Mean': recallMean,
import statistics
import codecs
import ast
# initializing list
test_list = [11.43, 0.0, 3.21]
print('sum:', sum(test_list))
average = round(sum(test_list) / len(test_list), 2)
res = round(statistics.pstdev(test_list), 2)
print(str(average) + '$\pm$' + str(res))
'''
67.93/3.31
'''
def compute(test_list):
average = round(sum(test_list) / len(test_list), 2)
res = round(statistics.pstdev(test_list), 2)
# print(str(average)+'$'+"\\"+'pm$'+str(res))
return str(average) + '$\\pm$' + str(res)
def extract(flag):
filenames = [
'log.nobase.entail.v2.' + flag + '.seed.42.txt',
'log.nobase.entail.v2.' + flag + '.seed.16.txt',
'log.nobase.entail.v2.' + flag + '.seed.32.txt'
]
result_lists = []
if Nb_Simulation == 1 :
print('Montant disponible au départ = ' , MiseDepart , ' €')
print(' Après ' + str(i) + ' lancé(s) vous disposez de : ' + str(round(Prime,2))+'€' )
fig = plt.figure(0)
fig.canvas.set_window_title('Jeu Pile ou Face')
plt.axis([0, Nb_Lance, 0, PrimeMax+MiseDepart])
plt.plot(ListeLance,ListePrime )
plt.title("Evolution des gains")
plt.xlabel('Nb Lancé(s)'+ ' (Après ' + str(i) + ' lancé(s) vous disposez de : ' + str(round(Prime,2))+'€)' )
plt.ylabel('Montant en € - (Montant initial = ' + str(MiseDepart) + '€)')
fig.show()
elif Nb_Simulation > 1 :
if mean(ListeGains)>0:
TxtMoyenne = 'gain'+ ' est de : ' + str(round(mean(ListeGains),2))+'€'
else :
TxtMoyenne = 'perte'+ ' est de : ' + str(round(mean(ListeGains),2)*-1)+'€'
print(' Après ' + str(j) + ' simulation(s) de '+str(i)+ ' lancé(s) avec un montant initial de ' \
+ str(MiseDepart) + ' € : '+ ' en Moyenne votre ' + TxtMoyenne + ' avec un Ecart-type de : ' \
+ str(round(pstdev(ListeGains),2))+'€' )
'''
Commentaires :
# en faisant comme ci-dessous, tu te permets de lancer ton programme plusieurs fois
'''
stoch_process(3,5) #3 simulations , 5 lancés
stoch_process(2,8) #2 simulations , 8 lancés
def stdev_percent(numbers):
return 100 * pstdev(numbers) / mean(numbers)
def desvio(execution_times):
return str(sts.pstdev(execution_times))
def main():
section = 'default'
secrets = configparser.RawConfigParser()
secrets.read('./secrets.ini')
config = {
"apiKey": secrets.get(section, 'firebase_api_key'),
"authDomain": secrets.get(section, 'firebase_auth_domain'),
"databaseURL": secrets.get(section, 'firebase_database_url'),
"storageBucket": secrets.get(section, 'firebase_storage_bucket')
}
firebase = pyrebase.initialize_app(config)
firebase_user = secrets.get(section, 'firebase_user')
firebase_pass = secrets.get(section, 'firebase_pass')
auth = firebase.auth()
user = auth.sign_in_with_email_and_password(firebase_user, firebase_pass)
db = firebase.database()
count = 0
detector_avg = 0
detector_std = 0
accel_vals = []
detected_count = 0
state = 0
det = get_detector(1, DETECTOR_THRESHOLD)
try:
while True:
d = det()
detector_count = d[0]
accel_avg = get_value(RANDOM_ACCEL_MIN, RANDOM_ACCEL_MAX)
accel_vals.append(accel_avg)
if accel_avg > ACCEL_THRESHOLD:
detected_count += 1
# end of interval reached
if detector_count == DETECTOR_THRESHOLD:
# calculate STD and AVG
detector_avg = int(statistics.mean(accel_vals))
detector_std = int(statistics.pstdev(accel_vals))
if ((detected_count >= DETECTED_THRESHOLD)
and ((detector_std > DETECTOR_STD_THRESHOLD_1) or
((detector_std > DETECTOR_STD_THRESHOLD_2) and
(detector_avg < DETECTOR_AVG_THRESHOLD)))):
state = 1
else:
state = 0
accel_vals = []
# send to Firebase
feed(db, user, accel_avg, detector_count, detected_count,
detector_std, detector_avg, state)
if detector_count == DETECTOR_THRESHOLD:
detected_count = 0
count += 1
time.sleep(5)
except KeyboardInterrupt:
print("\nAnd we are done. Data sets sent: {}".format(count))
def main():
bar_colors = [
colors.cnames['hotpink'], colors.cnames['deepskyblue'],
colors.cnames['cornflowerblue']
]
bar_labels = ['optimized', 'fixed1', 'fixed2']
fig = plt.figure(figsize=(30, 10), dpi=220)
plt.subplots_adjust(wspace=0.4)
plt.rcParams['font.family'] = 'arial'
rc('font', weight='bold')
# 左のグラフの描画
plt.subplot(1, 3, 1)
method_num = 3
user_num = 2
raw_data = [[[] for i in range(user_num)] for j in range(method_num)]
data = [[] for i in range(method_num)]
yerr = [[] for i in range(method_num)]
with open('experiment_data.csv', 'r') as f:
reader = csv.reader(f)
next(reader)
for row in reader:
for i in range(method_num):
for j in range(user_num):
raw_data[i][j].append(row[8 + i + j * method_num])
for i in range(method_num):
for q in raw_data[i]:
q_data = [int(x) for x in q]
data[i].append(statistics.mean(q_data))
yerr[i].append(
statistics.pstdev(q_data) / math.sqrt(len(q_data)))
x = np.arange(user_num)
bar_width = 0.2
plt.grid(which='major', axis='y', color='black', linestyle='--', alpha=0.3)
plt.tick_params(bottom=False)
for i in range(method_num):
plt.bar(x + i * bar_width,
data[i],
color=bar_colors[i],
width=bar_width,
yerr=yerr[i],
capsize=6,
label=bar_labels[i],
align='center')
plt.ylim([50, 90])
plt.gca().yaxis.set_major_formatter(FormatStrFormatter('%.2f'))
plt.ylabel('Mean accuracy rate [%]', fontsize=44, weight='bold')
plt.yticks([50.00, 60.00, 70.00, 80.00, 90.00], fontsize=44)
plt.xlabel('(a)', fontsize=44, weight='bold')
plt.xticks(x + bar_width, ['main user', 'bystander'], fontsize=44)
plt.legend(bbox_to_anchor=(0.6, 1.2),
loc='upper left',
borderaxespad=0,
fontsize=44,
ncol=3)
# 中央のグラフの描画
plt.subplot(1, 3, 2)
raw_data = [[] for i in range(method_num)]
with open('experiment_data.csv', 'r') as f:
reader = csv.reader(f)
next(reader)
for row in reader:
for i in range(method_num):
raw_data[i].append(int(row[14 + i]) / 1000)
data = []
yerr = []
for i in range(method_num):
data.append(statistics.mean(raw_data[i]))
yerr.append(
statistics.pstdev(raw_data[i]) / math.sqrt(len(raw_data[i])))
x = np.arange(method_num)
bar_width = 1.0
plt.grid(which='major', axis='y', color='black', linestyle='--', alpha=0.3)
plt.tick_params(bottom=False)
plt.bar(x,
data,
color=bar_colors,
width=bar_width,
yerr=yerr,
capsize=6,
align='center')
plt.ylim([130, 180])
plt.gca().yaxis.set_major_formatter(FormatStrFormatter('%d'))
plt.ylabel('Mean time [s]', fontsize=44, weight='bold')
plt.yticks([130, 140, 150, 160, 170, 180], fontsize=44)
dummy = ['a'] * method_num
plt.xlim([-3, 5])
plt.xlabel('(b)', fontsize=44, weight='bold')
plt.xticks(x, dummy, fontsize=44, color=colors.cnames['white'])
# 右のグラフの描画
plt.subplot(1, 3, 3)
raw_data = [[] for i in range(method_num)]
with open('experiment_data.csv', 'r') as f:
reader = csv.reader(f)
next(reader)
for row in reader:
for i in range(method_num):
raw_data[i].append(int(row[17 + i]))
data = []
yerr = []
for i in range(method_num):
data.append(statistics.mean(raw_data[i]))
yerr.append(
statistics.pstdev(raw_data[i]) / math.sqrt(len(raw_data[i])))
plt.grid(which='major', axis='y', color='black', linestyle='--', alpha=0.3)
plt.tick_params(bottom=False)
plt.bar(x,
data,
color=bar_colors,
width=bar_width,
yerr=yerr,
capsize=6,
align='center')
plt.ylim([10, 50])
plt.gca().yaxis.set_major_formatter(FormatStrFormatter('%d'))
plt.ylabel('Mean # of item selections', fontsize=44, weight='bold')
plt.yticks([10, 20, 30, 40, 50], fontsize=44)
plt.xlim([-3, 5])
plt.xlabel('(c)', fontsize=44, weight='bold')
plt.xticks(x, dummy, fontsize=44, color=colors.cnames['white'])
add_asterisk(0, 2, x, bar_width, data, yerr)
add_asterisk(1, 2, x, bar_width, data, yerr)
output_file_name = 'task_variables_result.eps'
plt.savefig(output_file_name, bbox_inches='tight', pad_inches=0.2)
# latexでのずれを防ぐため，一度pdfにしてepsに戻すスクリプトを実行
subprocess.run(['./epsbound.sh', output_file_name])
def calculate_std(param):
user_list = list(param["elements"])
std_value = float(pstdev(user_list))
return {"std": round(std_value, 3)}
# of the two median([50, 52, 53]) ### 52 median([51, 50, 52, 53]) ### 51.5 # mode - item that occurs most often >>> mode([51, 50, 52, 53, 51, 51]) 51 # Standard Deviation - divides by N-1 stdev([51, 50, 52, 53, 51, 51]) ### 1.0327955589886444 # Population Standard Deviation - divides by N pstdev([51, 50, 52, 53, 51, 51]) ### 0.9428090415820634 # See Transcripts for explanation of difference between Population Std Dev and # Std dev # list concatenation s = [10, 20, 30] t = [40, 50, 60] u = s + t u ### [10, 20, 30, 40, 50, 60] numpy would do an element by element addition # Slicing - first two items u[:2] ### [10, 20]
def algoritmo(self):
"""if self.RNI.getint(0) == 1:
logging.info("Numero de RE")
isContinue = True
elif self.RVR.getint(0) == 1:
logging.info("Desviacion")
else:
print(self.RVR.info)
isContinue = False
print("sin sistema de paro")"""
paro = 1
menores = []
if self.isReady:
_individuos = int(self.txtNumIndividuos.get())
_origen = int(self.txtOrigen.get())
_ciudades = self.ciudades
_repeticiones = int(self.txtRepeticiones.get())
_mejorGrafica = [-1]
_ciudadesText = self.txtNumCiudades.get()
logging.info("Iniciando Algoritmo...")
start_time = time()
Poblacion = []
for i in range(_individuos):
Poblacion.append(Funciones.individuo(_ciudades, _origen))
for ind in range(_individuos):
print("Individuo ", (ind + 1), ": ", Poblacion[ind])
Fitness = Funciones.evaluar(Poblacion, len(Poblacion), _ciudades, self.listaCiudades)
secuencia = 1
limite = _repeticiones
res = 'x'
isContinue = True
while isContinue:
logging.info("Repeticion " + str(secuencia))
PosPadres = Funciones.torneo(_individuos, Fitness)
logging.info("Posiciones padres: " + str(PosPadres))
_probCruce = float(self.txtProbCruce.get())
_probMut = 1 / _ciudades
Hijos = []
if round(random.random(), 3) <= _probCruce:
Hijos = Funciones.cruce(Poblacion, PosPadres, _ciudades)
else:
for i in range(2):
Hijos.append(Poblacion[PosPadres[i]])
if round(random.random(), 3) <= _probMut:
Funciones.mutacion(Hijos, _ciudades)
logging.debug("MUTACION AQUI")
FitnessHijos = Funciones.evaluar(Hijos, len(Hijos), _ciudades, self.listaCiudades)
Mejores = Funciones.seleccionDirecta(Poblacion, PosPadres, Fitness, Hijos, FitnessHijos)
Funciones.remplazo(Poblacion, PosPadres, Fitness, Mejores)
# TODO: Mejor de todos
# if secuencia >= limite:
# Hilo_respuesta = threading.Thread(name="HRespuesta", target=self.respuesta())
# Hilo_respuesta.start()
# res = self.resp
# logging.debug("respuesta " + str(res))
# if res is True:
# limite += _repeticiones
# res = 'x'
# elif res is not 'x':
# isContinue = False
_mejor = Funciones.mejor(Poblacion, Fitness)
if _ciudadesText == 'test':
if _mejor[0] is 14:
isContinue = False
if _mejorGrafica[0] is not _mejor[0]:
_mejorGrafica = _mejor
Grafica.grafica(1, _mejorGrafica[1], _mejorGrafica[0], secuencia, self.listaCiudades,
(_ciudades + 1), 15)
menores.append(_mejor[0])
if len(menores) > 10000:
if paro == 1:
if menores.count(_mejor[0]) >= 1000:
isContinue = False
print(menores.count((_mejor[0])))
elif paro == 2:
desviacion = stats.pstdev(Fitness)
print(desviacion)
if desviacion <= 0.5:
isContinue = False
secuencia += 1
print("<--TERMINADO-->")
for i in range(_individuos):
print("Fitness ", i, ": ", Fitness[i], " --> Individuo: ", Poblacion[i])
_mejor = Funciones.mejor(Poblacion, Fitness)
print("Individuo ", _mejor[2], ": ", _mejor[1])
print("Fitness: ", _mejor[0])
elapsed_time = time() - start_time
print(elapsed_time)
else:
print("Necesito Ciudades :(")
for day in range(days):
header += "%02d | " % day
print(header)
for nurse in range(nurses):
s = " %d | " % (nurse + 1)
for day in range(days):
s += (" | ", "XX | ")[samples.first.sample[index(nurse, day)]]
print(s)
## Check Hamming distances between consecutive states
distances = []
for i in range(len(samples.record.sample) - 1):
h = HammingDistance(samples.record.sample[i],
samples.record.sample[i + 1])
distances.append(h)
mean_h = mean(distances)
std_h = pstdev(distances)
hDistances[nurses, days] = (mean_h, std_h)
# Fraction of solutions in ground state
numGs = sum(r.num_occurrences for r in samples.record
if isclose(r.energy, gs, abs_tol=1e-3))
p = numGs / numSamples
gsFractions
[nurses, days] = p
print(gsFractions)
print(hDistances)
def P(X, Y,n):
covariance = [(i - mean(X)) * (j - mean(Y)) for i, j in zip(X, Y)]
pearson_correlation = sum(covariance) / (n * pstdev(X, mean(X)) * pstdev(Y, mean(Y)))
return pearson_correlation
tObject, tAmbient = MLX90615.Read_MLX90615_Temperatures()
sleep_ms(TIME_MS_BETWEEN_TEMPERATURE_MEASUREMENTS)
if (MIN_TEMPERATURE_ACCEPTABLE <= tObject <=
MAX_TEMPERATURE_ACCEPTABLE):
measurements += 1
listTObject.append(tObject)
listTAmbient.append(tAmbient)
print("Medindo, fique parado")
# testa condição para habilitar flag_exit; ???
if (measurements == NUM_TEMPERATURE_MEASUREMENTS):
meanTObjecto = statistics.mean(listTObject)
meanTAmbient = statistics.mean(listTAmbient)
stadevTObjecto = statistics.pstdev(listTObject)
stadevTAmbient = statistics.pstdev(listTAmbient)
#if( (max(listTObject) < meanTObjecto+5) and (min(listTObject) > meanTObjecto-5)):
if (stadevTObjecto > 5):
print("Tente de novo, fique parado a 3 cm")
else:
print("Media da temperatura = {} °C".format(meanTObjecto /
100))
print("Incerteza = {}".format(stadevTObjecto / 100))
if (meanTObjecto > 3750):
print("FEBRE! Procurar o sistema de saúde")
# Enviar dados via IoT - Thingspeak
ts.uploadData(meanTObjecto / 100.0, stadevTObjecto,
meanTAmbient / 100.0, stadevTAmbient, numMedida)
1.7831648335686623E-7, 1.1702631416449307, 2.4139623633345764E-10,
8.746781077206833E-12, 4.191207381154527E-10, 0.004335392309483765,
7.762821496726247E-10, 1.1866063687193673E-12, 3.2673172025710073E-6
]
TempoDois_pontos = [
193.0, 51.0, 39.0, 45.0, 34.0, 37.0, 37.0, 42.0, 41.0, 33.0, 34.0, 33.0,
42.0, 35.0, 34.0, 30.0, 32.0, 33.0, 31.0, 30.0, 31.0, 30.0, 29.0, 31.0,
30.0, 41.0, 30.0, 31.0, 31.0, 30.0
]
mediaBlend = 0.0
mediaDoisPontos = 0.0
mediaTempoBlend = 0.0
mediaTempoDois_pontos = 0.0
for x in range(0, len(Blend)):
mediaTempoBlend += TempoBlend[x]
mediaTempoDois_pontos += TempoDois_pontos[x]
mediaBlend = mediaBlend / len(Blend)
mediaTempoBlend = mediaTempoBlend / len(TempoBlend)
mediaDoisPontos = mediaTempoDois_pontos / len(TempoDois_pontos)
print('Blend:')
print('Desvio padrao: ' + str(statistics.pstdev(Blend)))
print('Media do tempo: ' + str(mediaTempoBlend))
print('\nDois_pontos:')
print('Desvio padrao: ' + str(statistics.pstdev(Dois_pontos)))
print('Media do tempo:' + str(mediaTempoDois_pontos))
def pstdev(self):
'返回DataStruct.price的总体标准差 Population standard deviation'
return self.price.groupby(
level=1).apply(lambda x: statistics.pstdev(x))
def compute(test_list):
average = round(sum(test_list) / len(test_list), 2)
res = round(statistics.pstdev(test_list), 2)
# print(str(average)+'$'+"\\"+'pm$'+str(res))
return str(average) + '$\\pm$' + str(res)
from numpoisson.numpoisson import NumPoissonGeometry
print('Start')
npg = NumPoissonGeometry(3, 'x')
P_so3 = {(1, 2): 'x3', (1, 3): '-x2', (2, 3): 'x1'}
num_bivector_res = dict()
j = 2
for mesh_path in [
'3Qmesh_10_2.npy', '3Qmesh_10_3.npy', '3Qmesh_10_4.npy',
'3Qmesh_10_5.npy', '3Qmesh_10_6.npy', '3Qmesh_10_7.npy'
]:
print(f'step {j}')
tiempos = dict()
with open(mesh_path, 'rb') as f:
mesh = np.load(f)
for k in range(25):
A = datetime.datetime.now()
npg.num_bivector(P_so3, mesh, pt_output=True)
B = datetime.datetime.now()
tiempos[k] = (B - A).total_seconds()
promedio = stat.mean(tiempos.values())
desviacion = stat.pstdev(tiempos.values())
tiempos['promedios'] = promedio
tiempos['desviacion'] = desviacion
num_bivector_res[f'10**{j}'] = tiempos
j = j + 1
print(num_bivector_res)
print('Finish')
def run(self):
params = NEAT.Parameters()
params.PopulationSize = self.args.population_size
params.AllowClones = self.args.allow_clones
params.MutateAddNeuronProb = self.args.add_neuron_probability
params.MutateAddLinkProb = self.args.add_link_probability
params.MutateRemLinkProb = self.args.remove_link_probability
params.MutateRemSimpleNeuronProb = self.args.remove_simple_neuron_probability
params.TimeConstantMutationMaxPower = 1.0
params.MutateNeuronTimeConstantsProb = 0.2
params.MutateNeuronBiasesProb = 0.03
params.MinNeuronTimeConstant = 1.0
params.MaxNeuronTimeConstant = 2.0
params.MinNeuronBias = -1.0
params.MaxNeuronBias = 1.0
params.Elitism = 0.1 # fraction of population
num_inputs = BeerTrackerGenotype.num_input_nodes + 1 # always add one extra input, see http://multineat.com/docs.html
num_hidden_nodes = 2
num_outputs = 2
genome = NEAT.Genome(
0, # ID
num_inputs,
num_hidden_nodes,
num_outputs,
self.args.fs_neat,
NEAT.ActivationFunction.TANH, # OutputActType
NEAT.ActivationFunction.UNSIGNED_SIGMOID, # HiddenActType
0, # SeedType
params # Parameters
)
pop = NEAT.Population(
genome,
params,
True, # whether the population should be randomized
2.0, # how much the population should be randomized,
self.args.seed
)
for generation in range(1, self.args.num_generations + 1):
print '--------------------------'
generation_start_time = time.time()
print('generation {}'.format(generation))
# retrieve a list of all genomes in the population
genotypes = NEAT.GetGenomeList(pop)
genotype_fitness_values = []
for genotype in genotypes:
fitness = self.evaluate(genotype, generation)
genotype_fitness_values.append(
(fitness, genotype)
)
genotype.SetFitness(fitness)
genotype_fitness_values.sort()
flat_fitness_list = [x[0] for x in genotype_fitness_values]
max_fitness = flat_fitness_list[-1]
min_fitness = flat_fitness_list[0]
avg_fitness = statistics.mean(flat_fitness_list)
fitness_std_dev = statistics.pstdev(flat_fitness_list)
stats_item = {
'generation': generation,
'min_fitness': min_fitness,
'max_fitness': max_fitness,
'avg_fitness': avg_fitness,
'fitness_std_dev': fitness_std_dev,
}
self.log.append(stats_item)
pprint.pprint(stats_item)
if self.args.visualize and generation % self.args.visualize_every == 0:
net = NEAT.NeuralNetwork()
genotype_fitness_values[-1][1].BuildPhenotype(net) # build phenotype from best genotype
img = np.zeros((500, 500, 3), dtype=np.uint8)
NEAT.DrawPhenotype(img, (0, 0, 500, 500), net)
cv2.imshow("NN", img)
cv2.waitKey(1)
nn = neat_net_wrapper.NeatNetWrapper(net)
seed = generation
bt = BeerTracker(
nn=nn,
seed=seed
)
bt.gfx = self.beer_tracker_gfx
bt.run()
print bt.world.agent.num_small_misses, 'small miss(es)'
print bt.world.agent.num_large_misses, 'large miss(es)'
print bt.world.agent.num_partial_captures, 'partial capture(s)'
print bt.world.agent.num_small_captures, 'small capture(s)'
print bt.world.agent.num_large_captures, 'large capture(s)'
net.Save('best_neat_net.txt')
# advance to the next generation
pop.Epoch()
print("Generation execution time: %s seconds" % (time.time() - generation_start_time))
random_list_position_points = [[0 for i in range(6)] for i in range(4)]
for i in range(4):
for j in range(6):
random_list_position_points[i][j] = position_points[j][i]
random_list_how_stops = [[0 for i in range(6)] for i in range(15)]
for i in range(15):
for j in range(6):
random_list_how_stops[i][j] = how_stops[j][i]
for i in range(14):
average = 0
for j in range(5):
mean = statistics.mean(random_list_position_values[j])
pstdev = statistics.pstdev(random_list_position_values[j])
position_values[i + 6][j] = random.uniform(mean - 2 * pstdev,
mean + 2 * pstdev)
average += (position_values[i + 6][j]**2)
average = math.sqrt(average)
for j in range(5):
position_values[i + 6][j] = round(
position_values[i + 6][j] / average, 4)
for i in range(14):
average = 0
for j in range(4):
mean = statistics.mean(random_list_position_points[j])
pstdev = statistics.pstdev(random_list_position_points[j])
position_points[i + 6][j] = random.uniform(mean - 2 * pstdev,
mean + 2 * pstdev)
print(x)
x = statistics.median_high(example_list)
print(x)
x = statistics.mode([1, 1, 2, 3, 4, 3, 3, 3, 3])
print(x)
x = statistics.mode([
"a",
"b",
"c",
"d",
"d",
"a",
"a",
])
print(x)
x = statistics.pstdev([2, 2, 2, 6])
print(x)
x = statistics.pvariance([2, 2, 2, 6])
print(x)
x = statistics.stdev([2, 2, 2, 6])
print(x)
x = statistics.variance([2, 2, 2, 6])
print(x)
if nb_of_elements <= 0:
print('Input should be strictly positive, giving up.')
sys.exit()
seed(arg_for_seed)
L = [randint(-50, 50) for _ in range(nb_of_elements)]
print('\nThe list is:', L)
mean_l = sum(L) / len(L)
s = 0
for e in L:
s += ((e - mean_l)**2)
stddev_l = (s / len(L))**0.5
L.sort()
if not len(L) % 2:
median_l = (L[len(L) // 2] + L[len(L) // 2 - 1]) / 2
else:
median_l = L[len(L) // 2]
print('\nThe mean is {0:.2f}.'.format(mean_l))
print('The median is {0:.2f}.'.format(median_l))
print('The standard deviation is {0:.2f}.'.format(stddev_l))
print('\nConfirming with functions from the statistics module:')
print('The mean is {0:.2f}.'.format(mean(L)))
print('The median is {0:.2f}.'.format(median(L)))
print('The standard deviation is {0:.2f}.'.format(pstdev(L)))
