def chains(im, df):
chains = pyramid.build_chains(df)
chains_f = []
for c in chains:
if len(c) > 2:
chains_f.append(c)
for i in range(len(chains_f)):
output.plot_image(im)
for segment in chains_f[i]:
plot_line(xy, segment['a'], segment['b'], 'r')
avg_slopes = []
avg_intercepts = []
for c in chains:
slopes = [segment['slope'] for segment in c]
intercepts = [segment['intercept'] for segment in c]
avg_slopes.append(average(slopes))
avg_intercepts.append(average(intercepts))
for i in range(len(chains)):
for j in range(len(chains)):
slope_ratio = avg_slopes[i] / avg_slopes[j]
intercept_ratio = avg_intercepts[i] / avg_intercepts[j]
if 0.5 < slope_ratio < 1.5 and 0.5 < intercept_ratio < 1.5:
print i, j, slope_ratio, intercept_ratio
def get_green_object_coordinates(data):
#rate = rospy.Rate(10)
bridge=CvBridge()
cv_image=bridge.imgmsg_to_cv2(data, "bgr8")
image = cv_image.copy()
cv_image = cv2.cvtColor(cv_image,cv2.COLOR_RGB2BGR)
imghsv = cv2.cvtColor(cv_image,cv2.COLOR_BGR2HSV)
lower = np.array([32, 89, 21])
upper = np.array([69, 255, 255])
mask = cv2.inRange(imghsv, lower, upper)
result = cv2.bitwise_and(cv_image,cv_image, mask = mask)
result = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
# Find contours and extract the bounding rectangle coordintes
# then find moments to obtain the centroid
cnts, hierarchy = cv2.findContours(result, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
#cnts = imutils.grab_contours(cnts)
#try:
# cnts = cnts[0] if len(cnts) == 2 else cnts[1]
#except IndexError:
# print("Camera goruntusunde probe yok.")
coordinate_x = []
coordinate_y = []
for c in cnts:
# compute the center of the contour
s = str(c[0])
s = s[2:-2]
temp = s.split()
coordinate_x.append(int(temp[0]))
coordinate_y.append(int(temp[1]))
# draw the contour and center of the shape on the image
cv2.drawContours(image, [c], -1, (0, 255, 0), 2)
# show the image
cv2.imshow("Image", image)
cv2.waitKey(1)
print("[center_publisher]", end=" ")
try:
if int(average(coordinate_y)) > 400:
center = [int(average(coordinate_x)), int(average(coordinate_y))]
print("Green object coordinates : ",end="")
else:
center = [0,0]
print("No green object", end=" ")
except ValueError:
center = [0,0]
print("No green object", end=" ")
p = str(center[0])+" "+str(center[1])
print(p)
pub.publish(p)
if center[0] < 700 and center[0] < 580 and center[1] > 500 and center[1] < 550:
print("\n\n\n\n\nhhhh\n\n\n\n")
rospy.sleep(5)
def test_all_sudokus(self):
total = 1000
sudokus = np.zeros((total, 81), np.int32)
solutions = np.zeros((total, 81), np.int32)
for i, line in enumerate(open('data/sudoku.csv', 'r').read().splitlines()[1:]):
if i >= total:
break
quiz, solution = line.split(",")
for j, q_s in enumerate(zip(quiz, solution)):
q, s = q_s
sudokus[i, j] = q
solutions[i, j] = s
sudokus = sudokus.reshape((-1, 9, 9))
solutions = solutions.reshape((-1, 9, 9))
times = []
for i in range(0, len(sudokus)):
start_time = time.process_time()
solution = sudoku_solver(sudokus[i])
end_time = time.process_time()
times.append(end_time - start_time)
np.testing.assert_array_equal(solution, solutions[i])
avg = str(round(average(times) * 1000, 2))
total_time = str(round(sum(times), 2))
print('-----')
print('Done!')
print(f' - Solved: {total} sudokus')
print(f' - Average time: {avg}ms')
print(f' - Total time: {total_time}s')
def __sum_relative_values_per_year(self, relative_values_per_year, n):
total_counts = []
if self.language == model.Language.GERMAN:
total_counts = config.TOTAL_NGRAM_COUNTS_GERMAN
elif self.language == model.Language.ENGLISH:
total_counts = config.TOTAL_NGRAM_COUNTS_ENGLISH
return int(average(relative_values_per_year) / (1 / total_counts[n]))
def interpolate_grid(grid_z, fill_value):
def Z(X, Y, params):
a, b, c, d = params
return -(a*X + b*Y + d)/c
grid_c = np.zeros(256)
grid_s = np.zeros(256)
for j in range(16):
for i in range(16):
if len(grid_z[j][i]) > 10:
x = np.array(grid_z[j][i])[:, 0]
y = np.array(grid_z[j][i])[:, 1]
z = np.array(grid_z[j][i])[:, 2]
A = np.c_[x, y, np.ones(x.shape)]
C, _, _, _ = np.linalg.lstsq(A, z, rcond=None)
vert_params = C[0], C[1], -1., C[2]
a = Z(rpm_bins[i], map_bins[j], vert_params)
b = average(z)
c = abs(a-b)
d = (a + b*c) / (c+1)
if abs(a-d) > 1:
print(rpm_bins[i], map_bins[j], a, '->', d)
a = round(d, ndigits)
grid_z[j][i] = a
grid_c[i + j * 16] = a
grid_s[i + j * 16] += len(x)
else:
grid_z[j][i] = 0
grid_c[i + j * 16] = fill_value
return grid_z, grid_c, grid_s
def get_average_cross_validation_accuracy(args):
try:
conv_layer_count, dense_layer_count, compiler_optimizer, active_fun = args
print("Testing parameters:", args)
csv_x_data, csv_y_data = parse_csv_data("train.csv")
feature = []
if(conv_layer_count == 3):
feature = [Conv2D(4, kernel_size=3, activation=active_fun, input_shape=(600,600,1)), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Flatten(),]
elif(conv_layer_count == 4):
feature = [Conv2D(4, kernel_size=3, activation=active_fun, input_shape=(600,600,1)), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Flatten(),]
elif(conv_layer_count == 5):
feature = [Conv2D(4, kernel_size=3, activation=active_fun, input_shape=(600,600,1)), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Flatten(),]
elif(conv_layer_count == 6):
feature = [Conv2D(4, kernel_size=3, activation=active_fun, input_shape=(600,600,1)), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Flatten(),]
elif(conv_layer_count == 7):
feature = [Conv2D(4, kernel_size=3, activation=active_fun, input_shape=(600,600,1)), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Conv2D(4, kernel_size=3, activation=active_fun), MaxPooling2D(pool_size=2), Flatten(),]
classifier = []
if dense_layer_count == 2:
classifier = [Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(1, activation='sigmoid'),]
elif dense_layer_count == 3:
classifier = [Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(1, activation='sigmoid'),]
elif dense_layer_count == 4:
classifier = [Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(1, activation='sigmoid'),]
elif dense_layer_count == 5:
classifier = [Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(1, activation='sigmoid'),]
elif dense_layer_count == 6:
classifier = [Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(1, activation='sigmoid'),]
elif dense_layer_count == 6:
classifier = [Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(1, activation='sigmoid'),]
elif dense_layer_count == 7:
classifier = [Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(8, activation=active_fun), Dropout(0.1), Dense(1, activation='sigmoid'),]
image_filenames = csv_x_data[:,0]
accuracy_vals = []
folds = StratifiedKFold(n_splits=5, random_state=None, shuffle=False)
for train_index, test_index in folds.split(image_filenames, csv_y_data):
raw_x_train_data, raw_x_test_data = image_filenames[train_index], image_filenames[test_index]
x_train_data = format_images("resized_train", raw_x_train_data)
x_train_data = x_train_data.reshape(200, 600, 600, 1)
x_test_data = format_images("resized_train", raw_x_test_data)
x_test_data = x_test_data.reshape(50, 600, 600, 1)
y_train_data, y_test_data = csv_y_data[train_index], csv_y_data[test_index]
model = Sequential(feature+classifier)
model.compile(optimizer=compiler_optimizer, loss='binary_crossentropy',metrics=['accuracy'],)
model.fit(x_train_data, y_train_data, epochs=10, batch_size=5, verbose=0)
#model.fit(x_train_data, to_categorical(y_train_data), epochs=10, batch_size=5, verbose=0)
y_expected = model.predict(x_test_data)
#accuracy_vals.append(accuracy_percent(y_expected, to_categorical(y_test_data)))
accuracy_vals.append(accuracy_percent(y_expected, y_test_data))
print("Accuracy vals: ", accuracy_vals)
correctness = average(accuracy_vals)
print("Average percent correct:", correctness)
global best_hyper_parameter_correctness
global best_hyper_parameter_tuple
if correctness > best_hyper_parameter_correctness:
best_hyper_parameter_tuple = (conv_layer_count, dense_layer_count, compiler_optimizer, active_fun)
best_hyper_parameter_correctness = correctness
return 1 - correctness
except:
return 1
def createHistogram(list1,list2=None,_title='histogram: % correcteness for required data set',firstTitle='random_reordering',secondTitle='spins_first',thirdTitle='moves_first',fourthTitle='interleve_reordering', fifthTitle = 'no_reordering'):
n, bins, patches = hist([list1,list2],bins=20,
color=['crimson', 'orange', ], label=[firstTitle + " (" + str(average(list1))[0:5] + ")", secondTitle + " (" + str(average(list2))[0:5] + ")"])
legend()
xlabel('%correct')
ylabel('number of results')
title(_title)
show()
def period_guess(self, y_s, t_0):
extrema = []
spacings = [log(extrema[i+1] - t_0) - log(extrema[i] - t_0)
for i in range(1, len(extrema))]
omegas = spacings / 2 * 22 / 7
omega_guess = average(omegas)
omega_std = std(omegas)
return omega_guess, omega_std
def runMultipleEpisodes(self, episodes: int) -> float:
rewards = []
for episode in range(episodes):
reward = self.runSingleEpisode()
rewards.append(reward)
averageEpisodeReward = average(rewards)
print("Average episode reward: " + str(averageEpisodeReward))
self.plotHistogram(rewards)
return averageEpisodeReward
def _tile_tile_distance(self, tile1, tile2):
"""
we define distance between two tiles as the average
Euclidian distance between the pixels of the tiles in RGB(0..255, 0..255, 0..255)
:param tile1:
:param tile2:
:return: distance in (0 ... 1)
math.sqrt(255**2 + 255**2 + 255**2) = 441.67
"""
return average(norm(tile1.astype(float) - tile2.astype(float), axis=2)) / math.sqrt(255.0**2 + 255.0**2 + 255.0**2)
def trimmers(samps):
avg = average(samps)
nodc = np.array(samps) - avg
rect = np.absolute(nodc)
window = 20
medi = pd.Series(rect).rolling(window).median()
level = np.max(medi)/5
first = np.argmax(medi>level)
last = first + np.argmax(medi[first:]<level)
return first, last
def afisare():
#Functie scrisa de @Mihalea Andreas (github.com/FreemanLX)
#Aici afisam minimul de mutari, maximul de mutari, media mutariilor, mediana mutariilor
#Numarul total de mutari folosit de jucator si de calculator
print("Minimul de mutari: " + str(min(mutari_arr)))
print("Maximul de mutari: " + str(max(mutari_arr)))
print("Media mutariilor: " + str(average(mutari_arr)))
print("Mediana mutariilor: " + str(statistics.median(mutari_arr)))
t_dupa = int(round(time.time() * 1000))
print("Timpul efectuat de joc este: "+str(t_dupa-t_inainte)+" milisecunde.")
print("Numarul total de mutari folosit de jucator este " + str(count_mutari_jucator))
print("Numarul total de mutari folosit de calculator este: " + str(sum(mutari_arr)))
def process(self, phonems: PhonemList):
for phonem in phonems:
if phonem.name in FrenchPhonems.VOWELS and random.randint(1,
4) == 1:
phonem.duration *= 8
if phonem.pitch_modifiers:
orgnl_pitch_avg = average(
[pitch for pos, pitch in phonem.pitch_modifiers])
else:
orgnl_pitch_avg = 150
phonem.set_from_pitches_list(
[orgnl_pitch_avg + ((-1)**i * 40) for i in range(4)])
return phonems
def __init__(self, alpha, dataset):
self.alpha = alpha
self.searched = {}
if dataset == '1':
with open('datasets\Cranfield\CRAN.ALL.json') as data:
self.dataset = json.load(data)
with open('datasets\Cranfield\CRAN.QRY.json') as data:
self.querys = json.load(data)
with open('datasets\Cranfield\CRAN.REL.json') as data:
self.rel = json.load(data)
elif dataset == '2':
with open('datasets\Med\MED.ALL.json') as data:
self.dataset = json.load(data)
with open('datasets\Med\MED.QRY.json') as data:
self.querys = json.load(data)
with open('datasets\Med\MED.REL.json') as data:
self.rel = json.load(data)
else:
raise Exception
self.data = {}
self.relevant_docs = int(
average([len(queries.values()) for queries in self.rel.values()]))
for doc in self.dataset.values():
self.data[doc['id']] = {
'id':
doc['id'],
'title':
word_tokenize(str(self.__preprocess(doc['title'])))
if 'title' in doc.keys() else [],
'text':
word_tokenize(str(self.__preprocess(doc['abstract'])))
if 'abstract' in doc.keys() else []
}
self.N = len(self.data)
self.__df()
self.__tf_idf()
for query in self.querys.values():
self.search(query['text'], query_id=query['id'])
def prep_experiments(qc_list: List[QuantumCircuit],
backend: IBMQBackend,
physical_dist_list: List[int],
save_path,
output=False):
"""prepare experiments multiple qcs varing hardware usage"""
# prepare pandas dataframe
columns = [
"Backend", "Physical distance", "Hardware Usage (%)",
"Total Circuit Duration Time", "Quantum Circuits", "Scheduled Pulse"
]
df = pd.DataFrame(columns=columns)
# backend info
num_hw_qubit = backend.configuration().num_qubits
for physical_dist in physical_dist_list:
transpiled, num_usage = dynamic_multiqc_compose(
queued_qc=qc_list,
backend=backend,
routing_method="sabre",
scheduling_method="alap",
num_hw_dist=physical_dist,
return_num_usage=True,
)
scheduled = [schedule(_tqc, backend=backend) for _tqc in transpiled]
usage = "{:.2%}".format(
average([_usage / num_hw_qubit for _usage in num_usage[0:-1]]))
tdt = sum([_sched._duration for _sched in scheduled])
df = df.append(
{
"Backend": backend.name,
"Physical distance": physical_dist,
"Hardware Usage (%)": usage,
"Total Circuit Duration Time": tdt,
"Quantum Circuits": transpiled,
"Scheduled Pulse": scheduled,
},
ignore_index=True)
# save the DataFrame as pickle file
pickle_dump(obj=df, path=save_path)
if output:
return df
def hist_analysis(im):
blurred_images = []
plt.figure()
for i in range(1, 100, 2):
im_blurred = cv2.medianBlur(im, i)
blurred_images.append(im_blurred)
hist_res = output.plot_image_histogram(im_blurred)
n = hist_res[0]
max_n = max(n)
w, h = images.get_image_size(im_blurred)
total_pixels = w * h
max_ratio = max_n / float(total_pixels)
avg = average(n)
print i, max_ratio, avg/total_pixels
def custom_score(labels, predictions):
'''
Calculate the score for the predictions, based on the labels passed to the
function, using a combination of accuracy, recall and precision, in an
attempt to get a model with a good accuracy and good enough precision and
recall values.
Args:
labels : ndarray
Array with the labels for each data point in the dataset.
predictions : ndarray
Array with the predictions for each data point in the dataset.
Returns:
total_score : double
The score assigned to the model, given the predictions.
'''
accuracy = accuracy_score(labels, predictions)
precision = precision_score(labels, predictions)
recall = recall_score(labels, predictions)
total_score = average([accuracy, precision, recall])
return total_score
def apply_alpha(self):
count_a = 0
count_r = 0
corrected_target = []
alpha_lst = self.alpha_num_set
target = self.df[self.target_header]
temp_lst = self.df[self.temp_header]
self.ref_temp = average(temp_lst).round(5)
# print('target: ', target)
while count_a <= len(alpha_lst) - 1:
corrected_target.append([])
while count_r <= len(target) - 1:
# print('134:',count_a,' target=', target[count_r],', alpha_lst=', alpha_lst[count_a],', temp=', temp_lst[count_r],', ref_temp=', ref_temp)
correction = (target[count_r] /
((alpha_lst[count_a] *
(temp_lst[count_r] - self.ref_temp)) + 1)
) + self.alpha_offset # apply alpha number
corrected_target[count_a].append(correction)
count_r += 1 # inc for loop
self.df[alpha_lst[count_a]] = corrected_target[count_a]
# print('168: ', count_a)
count_r = 0 # reset count for while loop
count_a += 1
self.corrected_target = corrected_target
d = d.split(",")
start_time.append(int(d[0]))
end_time.append(int(d[1]))
interval.append(int(d[2]))
statusCode.append(int(d[3]))
info = data[-1]
info_cqs = data[-2]
start_time = np.array(start_time)
end_time = np.array(end_time)
interval = np.array(interval)
statusCode = np.array(statusCode)
maximum1 = np.max(interval)
minimum1 = np.min(interval)
legend1 = '(ms): min={} max={} avr={}'.format(minimum1, maximum1,
int(average(interval)))
plt.ylabel("time (ms)")
plt.xlabel("")
plt.title(info + '\n' + info_cqs + legend1)
# plt.plot(interval, color="orange")
plt.legend([legend1])
plt.grid(color="grey", linewidth=1, axis="x", alpha=0.1)
colormap = np.array(['r', 'g'])
plt.scatter(start_time, interval, 3, c=colormap[statusCode])
plt.show()
def predicting(AwayTeam, HomeTeam, new_data_file):
if not (path.exists("home_data.csv") and path.exists("away_data.csv")
and path.exists("home_scores.csv") and path.exists("away_scores.csv")):
buildData()
reg_h = []
reg_a = []
nn_h = []
nn_a = []
teamData = pd.read_csv(new_data_file)
HomeTeam_data = teamData.loc[teamData['team_name']
== HomeTeam.strip()].values[0]
AwayTeam_data = teamData.loc[teamData['team_name']
== AwayTeam.strip()].values[0]
HomeTeam_win = int(HomeTeam_data[-21])
HomeTeam_proj_win = int(HomeTeam_data[-19])
HomeTeam_data_value = list(HomeTeam_data)
HomeTeam_data_value.pop()
HomeTeam_data_value.pop(0)
HomeTeam_data_value.pop(0)
AwayTeam_win = int(AwayTeam_data[-21])
AwayTeam_proj_win = int(AwayTeam_data[-19])
AwayTeam_data_value = list(AwayTeam_data)
AwayTeam_data_value.pop()
AwayTeam_data_value.pop(0)
AwayTeam_data_value.pop(0)
stat_home = []
stat_home.extend(HomeTeam_data_value)
stat_home.extend(AwayTeam_data_value)
stat_away = []
stat_away.extend(AwayTeam_data_value)
stat_away.extend(HomeTeam_data_value)
stat_home = np.array(stat_home).reshape((1, len(stat_home)))
stat_away = np.array(stat_away).reshape((1, len(stat_away)))
train_percentage = 0.7
acc1 = []
acc2 = []
print("Running Models", end='')
for i in range(3):
regression, model, acc1_, acc2_ = createModel(train_percentage)
home_score_r = regression.predict(stat_home)
away_score_r = regression.predict(stat_away)
home_score_n = model.predict(stat_home)
away_score_n = model.predict(stat_away)
reg_h.append(home_score_r[0])
reg_a.append(away_score_r[0])
nn_h.append(home_score_n[0][0])
nn_a.append(away_score_n[0][0])
acc1.append(acc1_)
acc2.append(acc2_)
print('.', end='')
print('\n')
avg_acc1 = average(acc1)
avg_acc2 = average(acc2)
print("With Train Test Split = {:d}:{:d}".format(
int(100*train_percentage), int(100*(1-train_percentage))))
print(
"Average Ridge Regression accuracy on testing sets: {:.2f}%".format(avg_acc1*100))
print("Average NN accuracy on testing sets: {:.2f}%".format(avg_acc2*100))
home_score_r = average(reg_h)
away_score_r = average(reg_a)
if home_score_r > away_score_r:
print("With the {} being the home team, regression predicts that they beat the {} by {:.2f} pts".format(
HomeTeam, AwayTeam, round(home_score_r-away_score_r, 2)))
else:
print("With the {} being the home team, regression predicts that they lose to the {} by {:.2f} pts".format(
HomeTeam, AwayTeam, round(away_score_r-home_score_r, 2)))
home_score_n = average(nn_h)
away_score_n = average(nn_a)
if home_score_n > away_score_n:
print("With the {} being the home team, NN predicts that they beat the {} by {:.2f} pts".format(
HomeTeam, AwayTeam, round(home_score_n-away_score_n, 2)))
else:
print("With the {} being the home team, NN predicts that they lose to the {} by {:.2f} pts".format(
HomeTeam, AwayTeam, round(away_score_n-home_score_n, 2)))
if home_score_r > away_score_r and home_score_n > away_score_n:
print("The average win margin for {} is {:.2f} pts".format(HomeTeam,
avg(home_score_r-away_score_r, home_score_n-away_score_n)))
if home_score_r < away_score_r and home_score_n < away_score_n:
print("The average win margin for {} is {:.2f} pts".format(AwayTeam,
avg(away_score_r-home_score_r, away_score_n-home_score_n)))
if HomeTeam_win > HomeTeam_proj_win:
print("The {} is exceeding expectations by {} wins".format(
HomeTeam, HomeTeam_win - HomeTeam_proj_win))
elif HomeTeam_proj_win > HomeTeam_win:
print("The {} is short of the expectations by {} wins".format(
HomeTeam, -HomeTeam_win + HomeTeam_proj_win))
if AwayTeam_win > AwayTeam_proj_win:
print("The {} is exceeding expectations by {} wins".format(
AwayTeam, AwayTeam_win - AwayTeam_proj_win))
elif AwayTeam_proj_win > AwayTeam_win:
print("The {} is short of the expectations by {} wins".format(
AwayTeam, -AwayTeam_win + AwayTeam_proj_win))
def _followxSingleDirection( self,
x,
direction = Direction.FORWARD,
forward_curve = None,
last_eigenvector = None,
weights = 1.):
'''Generates a partial lpc curve dictionary from the start point, x.
Arguments
---------
x : 1-dim, length m, numpy.array of floats, start point for the algorithm when m is dimension of feature space
direction : bool, proceeds in Direction.FORWARD or Direction.BACKWARD from this point (just sets sign for first eigenvalue)
forward_curve : dictionary as returned by this function, is used to detect crossing of the curve under construction with a
previously constructed curve
last_eigenvector : 1-dim, length m, numpy.array of floats, a unit vector that defines the initial direction, relative to
which the first eigenvector is biased and initial cos_neu_neu is calculated
weights : 1-dim, length n numpy.array of observation weights (can also be used to exclude
individual observations from the computation by setting their weight to zero.),
where n is the number of feature points
'''
x0 = copy(x)
N = self.Xi.shape[0]
d = self.Xi.shape[1]
it = self._lpcParameters['it']
h = array(self._lpcParameters['h'])
t0 = self._lpcParameters['t0']
rho0 = self._lpcParameters['rho0']
save_xd = empty((it,d))
eigen_vecd = empty((it,d))
c0 = ones(it)
cos_alt_neu = ones(it)
cos_neu_neu = ones(it)
lamb = empty(it) #NOTE this is named 'lambda' in the original R code
rho = zeros(it)
high_rho_points = empty((0,d))
count_points = 0
for i in range(it):
kernel_weights = self._kernd(self.Xi, x0, c0[i]*h) * weights
mu_x = average(self.Xi, axis = 0, weights = kernel_weights)
sum_weights = sum(kernel_weights)
mean_sub = self.Xi - mu_x
cov_x = dot( dot(transpose(mean_sub), numpy.diag(kernel_weights)), mean_sub) / sum_weights
#assert (abs(cov_x.transpose() - cov_x)/abs(cov_x.transpose() + cov_x) < 1e-6).all(), 'Covariance matrix not symmetric, \n cov_x = {0}, mean_sub = {1}'.format(cov_x, mean_sub)
save_xd[i] = mu_x #save first point of the branch
count_points += 1
#calculate path length
if i==0:
lamb[0] = 0
else:
lamb[i] = lamb[i-1] + sqrt(sum((mu_x - save_xd[i-1])**2))
#calculate eigenvalues/vectors
#(sorted_eigen_cov is a list of tuples containing eigenvalue and associated eigenvector, sorted descending by eigenvalue)
eigen_cov = eigh(cov_x)
sorted_eigen_cov = zip(eigen_cov[0],map(ravel,vsplit(eigen_cov[1].transpose(),len(eigen_cov[1]))))
sorted_eigen_cov.sort(key = lambda elt: elt[0], reverse = True)
eigen_norm = sqrt(sum(sorted_eigen_cov[0][1]**2))
eigen_vecd[i] = direction * sorted_eigen_cov[0][1] / eigen_norm #Unit eigenvector corresponding to largest eigenvalue
#rho parameters
rho[i] = sorted_eigen_cov[1][0] / sorted_eigen_cov[0][0] #Ratio of two largest eigenvalues
if i != 0 and rho[i] > rho0 and rho[i-1] <= rho0:
high_rho_points = vstack((high_rho_points, x0))
#angle between successive eigenvectors
if i==0 and last_eigenvector is not None:
cos_alt_neu[i] = direction * dot(last_eigenvector, eigen_vecd[i])
if i > 0:
cos_alt_neu[i] = dot(eigen_vecd[i], eigen_vecd[i-1])
#signum flipping
if cos_alt_neu[i] < 0:
eigen_vecd[i] = -eigen_vecd[i]
cos_neu_neu[i] = -cos_alt_neu[i]
else:
cos_neu_neu[i] = cos_alt_neu[i]
#angle penalization
pen = self._lpcParameters['pen']
if pen > 0:
if i == 0 and last_eigenvector is not None:
a = abs(cos_alt_neu[i])**pen
eigen_vecd[i] = a * eigen_vecd[i] + (1-a) * last_eigenvector
if i > 0:
a = abs(cos_alt_neu[i])**pen
eigen_vecd[i] = a * eigen_vecd[i] + (1-a) * eigen_vecd[i-1]
#check curve termination criteria
if i not in (0, it-1):
#crossing
cross = self._lpcParameters['cross']
if forward_curve is None:
full_curve_points = save_xd[0:i+1]
else:
full_curve_points = vstack((forward_curve['save_xd'],save_xd[0:i+1])) #inefficient, initialize then append?
if not cross:
prox = where(ravel(cdist(full_curve_points,[mu_x])) <= mean(h))[0]
if len(prox) != max(prox) - min(prox) + 1:
break
#convergence
convergence_at = self._lpcParameters['convergence_at']
conv_ratio = abs(lamb[i] - lamb[i-1]) / (2 * (lamb[i] + lamb[i-1]))
if conv_ratio < convergence_at:
break
#boundary
boundary = self._lpcParameters['boundary']
if conv_ratio < boundary:
c0[i+1] = 0.995 * c0[i]
else:
c0[i+1] = min(1.01*c0[i], 1)
#step along in direction eigen_vecd[i]
x0 = mu_x + t0 * eigen_vecd[i]
#trim output in the case where convergence occurs before 'it' iterations
curve = { 'save_xd': save_xd[0:count_points],
'eigen_vecd': eigen_vecd[0:count_points],
'cos_neu_neu': cos_neu_neu[0:count_points],
'rho': rho[0:count_points],
'high_rho_points': high_rho_points,
'lamb': lamb[0:count_points],
'c0': c0[0:count_points]
}
return curve
def get_ave(self):
return average(self.ylist)
def avg_degree(self):
return average(self.degree().values())
field1 = np.array(field1)
field2 = np.array(field2)
field3 = np.array(field3)
plt.ylabel("time (ms)")
plt.xlabel("")
plt.title(info)
plt.plot(field1, color="orange")
plt.plot(field2, color="blue")
plt.plot(field3, color="green")
maximum1 = np.max(field1)
minimum1 = np.min(field1)
maximum2 = np.max(field2)
minimum2 = np.min(field2)
maximum3 = np.max(field3)
minimum3 = np.min(field3)
legend1 = 'WiFi (ms): min={} max={} avr={}'.format(minimum1, maximum1,
int(average(field1)))
legend2 = 'SIM (ms): min={} max={} avr={}'.format(minimum2, maximum2,
int(average(field2)))
legend3 = 'Sum (ms): min={} max={} avr={}'.format(minimum3, maximum3,
int(average(field3)))
plt.legend([legend1, legend2, legend3])
plt.grid(color="grey", linewidth=1, axis="x", alpha=0.1)
plt.show()
output.append([link, title[0].text, name, score])
# Calculate and plot the frequency of player mentions in the articles
namecount = sorted(namecount.items(), key=lambda x: x[1], reverse=True)
for i in range(5):
top5_name.append(namecount[i][0])
top5_freq.append(namecount[i][1])
plt.bar(np.arange(0, 10, step = 2),top5_freq,width = 0.8)
plt.xticks(np.arange(0, 10, step = 2),top5_name, rotation=0)
plt.xlabel("Players")
plt.ylabel("Frequency")
plt.title("Frequency of articles writen on tennis players")
plt.savefig("task4.png")
# Calculate and plot the average game diff and win pct by player
avg_diff=[average(game_difference[player]) for player in game_difference]
player_names=[player for player in game_difference]
fig=plt.figure()
with open('tennis.json') as f:
Data = json.load(f)
for name in player_names:
for entry in Data:
if entry["name"]==name.upper():
win_percentage.append(float(entry["wonPct"][:-1]))
break
plt.scatter(avg_diff, win_percentage)
plt.xlabel('Average Game Difference')
plt.ylabel('Win Percenctage')
plt.title('Scatter of Average Game Gifference by Win Percentage')
texts = []
for i in range(0,len(avg_diff)):
#new range: new_range_ig_naive_bayse = [0.7169642857142857, 0.6879464285714286, 0.7044642857142858, 0.6910714285714286, 0.6941964285714286, 0.6955357142857143, 0.6959821428571429, 0.6915178571428572, 0.6901785714285714, 0.6745535714285714, 0.6821428571428572, 0.6790178571428571, 0.6683035714285714, 0.6669642857142857, 0.6486607142857143, 0.646875, 0.6464285714285715, 0.6455357142857143, 0.6450892857142857, 0.6495535714285714, 0.6508928571428572, 0.6508928571428572, 0.6513392857142857, 0.6504464285714285, 0.646875, 0.646875, 0.6477678571428571, 0.6464285714285715, 0.6464285714285715, ] new_range_ig_linear_svm = [0.7098214285714286, 0.6861607142857142, 0.6991071428571428, 0.6959821428571429, 0.6825892857142857, 0.6915178571428572, 0.6785714285714286, 0.6959821428571429, 0.6799107142857143, 0.6745535714285714, 0.6763392857142857, 0.6785714285714286, 0.6772321428571428, 0.6638392857142857, 0.6651785714285714, 0.6638392857142857, 0.6642857142857143, 0.6575892857142858, 0.6580357142857143, 0.6598214285714286, 0.6540178571428571, 0.6544642857142857, 0.6571428571428571, 0.6665178571428572, 0.6647321428571429, 0.6616071428571428, 0.6638392857142857, 0.6651785714285714, 0.6584821428571429, ] new_range_ig_hyperbolic_svm = [0.6964285714285714, 0.6870535714285714, 0.6977678571428572, 0.6941964285714286, 0.6866071428571429, 0.6986607142857143, 0.6848214285714286, 0.6834821428571428, 0.6901785714285714, 0.671875, 0.6700892857142857, 0.6790178571428571, 0.6566964285714286, 0.6611607142857143, 0.6709821428571429, 0.6598214285714286, 0.6678571428571428, 0.6696428571428571, 0.6709821428571429, 0.6602678571428572, 0.6629464285714286, 0.6669642857142857, 0.6714285714285714, 0.6665178571428572, 0.6700892857142857, 0.6584821428571429, 0.6633928571428571, 0.6709821428571429, 0.665625, ] stochastic_naive_bayse = [0.5205357142857143, 0.565625, 0.6017857142857143, 0.6200892857142857, 0.6352678571428572, 0.6142857142857143, 0.6348214285714285, 0.6433035714285714, 0.6303571428571428, 0.6334821428571429, 0.640625, 0.6410714285714286, 0.6508928571428572, 0.6495535714285714, 0.6486607142857143, 0.659375, 0.6575892857142858, 0.6607142857142857, 0.6714285714285714, 0.6741071428571429, 0.6683035714285714, 0.6776785714285715, 0.6651785714285714, 0.6830357142857143, 0.6852678571428571, 0.6700892857142857, 0.6732142857142858, 0.6803571428571429, 0.6741071428571429, ] stochastic_linear_svm = [0.5294642857142857, 0.5428571428571428, 0.6013392857142857, 0.6334821428571429, 0.6272321428571429, 0.603125, 0.6129464285714286, 0.640625, 0.6419642857142858, 0.6508928571428572, 0.6544642857142857, 0.6580357142857143, 0.6633928571428571, 0.66875, 0.6714285714285714, 0.6464285714285715, 0.6723214285714286, 0.6785714285714286, 0.6772321428571428, 0.6803571428571429, 0.6803571428571429, 0.6879464285714286, 0.6830357142857143, 0.6839285714285714, 0.7008928571428571, 0.6982142857142857, 0.69375, 0.6745535714285714, 0.6910714285714286, ] stochastic_hyperbolic_svm = [0.5482142857142858, 0.5732142857142857, 0.6022321428571429, 0.628125, 0.6196428571428572, 0.6366071428571428, 0.6142857142857143, 0.634375, 0.65, 0.6540178571428571, 0.6522321428571428, 0.6763392857142857, 0.6736607142857143, 0.66875, 0.6736607142857143, 0.6660714285714285, 0.6736607142857143, 0.6696428571428571, 0.6607142857142857, 0.6741071428571429, 0.7008928571428571, 0.6857142857142857, 0.6799107142857143, 0.6852678571428571, 0.6830357142857143, 0.6794642857142857, 0.690625, 0.6799107142857143, 0.6897321428571429, ] pca_hyperbolic_svm = [0.6571428571428571, 0.6352678571428572, 0.6160714285714286, 0.5513392857142857, 0.6169642857142857, 0.6223214285714286, 0.5508928571428572, 0.6352678571428572, 0.6321428571428571, 0.634375, 0.6450892857142857, 0.6267857142857143, 0.6410714285714286, 0.646875, 0.6361607142857143, 0.6459821428571428, 0.6348214285714285, 0.6375, 0.6433035714285714, 0.6424107142857143, 0.6388392857142857, 0.6303571428571428, 0.6419642857142858, 0.6334821428571429, 0.6285714285714286, 0.6375, 0.6330357142857143, 0.6379464285714286, 0.6375, ] pca_linear_svm = [0.6316964285714286, 0.6196428571428572, 0.5370535714285715, 0.35401785714285716, 0.603125, 0.6017857142857143, 0.60625, 0.6160714285714286, 0.6013392857142857, 0.6053571428571428, 0.621875, 0.6330357142857143, 0.6410714285714286, 0.63125, 0.6241071428571429, 0.6366071428571428, 0.6339285714285714, 0.6370535714285714, 0.6223214285714286, 0.6339285714285714, 0.6348214285714285, 0.6392857142857142, 0.6263392857142858, 0.6223214285714286, 0.6415178571428571, 0.6339285714285714, 0.6357142857142857, 0.6392857142857142, 0.6223214285714286, ] pca_naive_bayse = [0.3665178571428571, 0.3879464285714286, 0.590625, 0.5785714285714286, 0.378125, 0.5794642857142858, 0.6040178571428572, 0.35625, 0.5785714285714286, 0.5785714285714286, 0.5803571428571429, 0.6236607142857142, 0.5790178571428571, 0.5763392857142857, 0.5816964285714286, 0.5763392857142857, 0.5741071428571428, 0.625, 0.5665178571428572, 0.5696428571428571, 0.5919642857142857, 0.63125, 0.5852678571428571, 0.5816964285714286, 0.5803571428571429, 0.5910714285714286, 0.5848214285714286, 0.5803571428571429, 0.5803571428571429, ] list1 = new_range_ig_naive_bayse + new_range_ig_linear_svm + new_range_ig_hyperbolic_svm list2 = stochastic_naive_bayse + stochastic_linear_svm + stochastic_hyperbolic_svm list3 = pca_hyperbolic_svm + pca_linear_svm + pca_naive_bayse print 'ig VS stochastic' print wilcoxon(list1, list2) print 'avg ig=', average(list1), ' avg stochastic=', average(list2) print 'ig VS PCA' print wilcoxon(list1, list3) print 'avg ig=', average(list1), ' avg PCA=', average(list3) print 'stochastic VS PCA' print wilcoxon(list2, list3) print 'avg stochastic=', average(list2), ' avg PCA=', average(list3)
else:
grid_z[j][i] = 0
grid_c[i + j * 16] = fill_value
return grid_z, grid_c, grid_s
print(end='.', flush=True)
log = parse_file(open(sys.argv[1], encoding='windows-1252'))
print(end='.', flush=True)
points = get_points(log, logfct)
print(end='.', flush=True)
grid_z = fill_grid(np.digitize(points[0], rpm_bins), np.digitize(
points[1], map_bins), points)
print(end='.', flush=True)
z, c, s = interpolate_grid(grid_z, average(points[2]))
print('!')
flip_z = np.flip(np.array(grid_z), 0)
if print_array:
print(flip_z)
if plot_array:
grid_x, grid_y = np.meshgrid(rpm_bins, map_bins)
plt.scatter(grid_x, grid_y, c=c, s=s, alpha=0.25, cmap='viridis')
plt.grid()
plt.show()
output_file = open("output.csv", "w+")
for j in range(16):
def train(self,
train_episodes=2000000,
episodes_log_freq=10000,
alpha=0.1,
discount_factor=0.999):
#perfBeforeTraining = self.runMultipleEpisodes(10000)
epsilon = 1 #0.7#1 (large epsilon => random)
max_epsilon = 1
min_epsilon = 0.01 #0.001
decay = 1 / train_episodes #0.01
#Training the agent
#Creating lists to keep track of reward and epsilon values
training_rewards = []
epsilons = []
average_rewards = []
for episode in range(train_episodes):
#Reseting the environment each time as per requirement
state = self.env.reset()
#Starting the tracker for the rewards (total for the episode = life time)
total_episode_award = 0
done = False
while not done:
#Choosing an action given the states based on a random number
exp_exp_tradeoff = random.uniform(0, 1)
### STEP 2: SECOND option for choosing the initial action - exploit
#If the random number is larger than epsilon: employing exploitation
#and selecting best action
if exp_exp_tradeoff > epsilon:
action = self.chooseAction(state)
### STEP 2: FIRST option for choosing the initial action - explore
#Otherwise, employing exploration: choosing a random action
else:
action = self.env.action_space.sample()
#assert len(action)==3
### STEPs 3 & 4: performing the action and getting the reward
#Taking the action and getting the reward and outcome state
new_state, reward, done, info = self.env.step(action)
### STEP 5: update the Q-table
#Updating the Q-table using the Bellman equation
#Q[state, action] = Q[state, action] + alpha * (reward + discount_factor * np.max(Q[new_state, :]) - Q[state, action])
index = tuple(np.concatenate([state, action]))
self.Q[index] = self.Q[index] + alpha * (
reward + discount_factor * np.max(self.Q[tuple(new_state)])
- self.Q[index])
#Increasing our total reward and updating the state
total_episode_award += reward
state = new_state
#Cutting down on exploration by reducing the epsilon
#epsilon = min_epsilon + (max_epsilon - min_epsilon)*np.exp(-decay*episode)
epsilon = epsilon - decay
#Adding the total reward and reduced epsilon values
training_rewards.append(total_episode_award)
epsilons.append(epsilon)
if (episode + 1) % episodes_log_freq == 0:
latest = slice(-episodes_log_freq, None)
avg = average(training_rewards[latest])
print("Mean training score: " + str(avg))
average_rewards.append(avg)
#print ("Mean score from start: " + str(sum(training_rewards)/(episode+1)))
#print ("Training score over time: " + str(sum(training_rewards)/train_episodes))
#Visualizing results and total reward over all episodes
#x = range(train_episodes)
plt.plot(average_rewards)
plt.xlabel('Episode')
plt.ylabel('Training total reward')
plt.title('Total rewards over all episodes in training')
plt.show()
#Visualizing the epsilons over all episodes
plt.plot(epsilons)
plt.xlabel('Episode')
plt.ylabel('Epsilon')
plt.title("Epsilon for episode")
plt.show()
ylabel('number of results')
title(_title)
show()
from matplotlib.pyplot import plot,show, legend
def createXYSpreadGraph(list1,list2,name1,name2,_title='average % correcteness for required data set'):
l1=plot(range(1,len(list1)*2+1,2),list1,'blue',label=name1)
l2=plot(range(1,len(list2)*2+1,2),list2,'red',label=name2)
xlabel('k')
ylabel('%correct (average)')
legend()
title(_title)
show()
ignoreAverages = []
ignoreAverages.append(average(ignoreAttributes1NN))
ignoreAverages.append(average(ignoreAttributes3NN))
ignoreAverages.append(average(ignoreAttributes5NN))
ignoreAverages.append(average(ignoreAttributes7NN))
ignoreAverages.append(average(ignoreAttributes9NN))
ignoreAverages.append(average(ignoreAttributes11NN))
ignoreAverages.append(average(ignoreAttributes13NN))
ignoreAverages.append(average(ignoreAttributes15NN))
ignoreAverages.append(average(ignoreAttributes17NN))
ignoreAverages.append(average(ignoreAttributes19NN))
ignoreAverages.append(average(ignoreAttributes21NN))
ignoreAverages.append(average(ignoreAttributes23NN))
ignoreAverages.append(average(ignoreAttributes25NN))
useAllAverages = []
useAllAverages.append(average(useAllAttributes1NN))
useAllAverages.append(average(useAllAttributes3NN))
print('-------txt读写-----------')
e=eye(2)
print(e)
savetxt("eye.txt",e)
print('-------csv-----------')
t,y=loadtxt('haha1.csv', delimiter=',', usecols=(6,7), unpack=True)
print(t)
print(y)
c=loadtxt('haha1.csv', delimiter=',', usecols=(6,7), unpack=False)
print('-------均值 最大小值 排序-----------')
print(c)
print(average(t))
print(mean(t))
print(max(t))
print(min(t))
c=arange(5)
c[2]=77
c[3]=88
print(c)
print(median(c))
print(msort(c))
print('-------方差-----------')
print(var(c))
print('c:',c)
print('len:',len(c))
print('c.size:',c.size)
TN_in_TP += 1
if (FP_in_TP != 0) & (FN_in_TP == 0) & (TN_in_TP == 0):
the_errors = [err for err in total_error_list[l] if err >= 0]
error_save_data.append(the_errors)
if len(the_errors) == 0:
continue
else:
column_error_min = min(the_errors)
column_error_max = max(the_errors)
Total_max_list.append(column_error_max)
column_error_average = average(the_errors)
Total_average_list.append(column_error_average)
print(
"NO.%d seed corresponding MT: min_err %f max_err %f avg_err %f FP %d"
% (non_nan_columns_index_cnn_MT_label_seed[l], column_error_min,
column_error_max, column_error_average, FP_in_TP))
elif (FP_in_TP != 0) & (FN_in_TP != 0) & (TN_in_TP == 0):
the_errors = [err for err in total_error_list[l] if err >= 0]
error_save_data.append(the_errors)
if len(the_errors) == 0:
continue
else:
def analytic_score_sentences(self, sentence_tuples):
return {'ref-lev': average([levenshtein(h, r) for h, r in sentence_tuples])}
def avg_degree(self):
return average(self.degree().values())
def compute_segment_center(p1, p2):
return [average((p1[dimension], p2[dimension])) for dimension in range(len(p1))]
if lmatched.__contains__(name):
print
else:
lmatched.append(name)
else:
print(key + "was not matched my the face API")
print("the very famous category matched " + str(vcorrect) + " out of " + str(len(Very_famous)) +
" Pictures with an average confidence rating of " + str(average(vscores)))
print("a total of " + str(len(vmatched)) + " People were matched out of " + str(len(Very_famous)/3))
print("the medium famous category matched " + str(mcorrect) + " out of " + str(len(Medium_famous)) +
" Pictures with an average confidence rating of " + str(average(mscores)))
print("a total of " + str(len(mmatched)) + " People were matched out of " + str(len(Medium_famous)/3))
print("the low famous category matched " + str(lcorrect) + " out of " + str(len(Low_famous)) +
" Pictures with an average confidence rating of " + str(average(lscores)))
print("a total of " + str(len(lmatched)) + " People were matched out of " + str(len(Low_famous)/3))
def simulateAmount(amount, times=1):
evaluations = [evaluatePrintedAmount(generateGaussianSample(mu, sigma), amount) for _ in range(0, times)]
return average(evaluations).round().astype(int)
from scipy.stats.morestats import wilcoxon from numpy.lib.function_base import average, median #tree = [96.19047619047619, 96.28571428571429, 95.61904761904762, 96.0, 96.57142857142857, 96.57142857142857, 95.14285714285714, 96.0, 96.19047619047619, 95.9047619047619, 96.28571428571429, 95.61904761904762, 97.33333333333333, 94.85714285714286, 95.14285714285714, 94.28571428571429, 94.19047619047619, 96.38095238095238, 95.04761904761905, 94.85714285714286, 96.19047619047619, 96.38095238095238, 96.38095238095238, 96.47619047619048, 96.19047619047619, 94.57142857142857, 96.38095238095238, 96.47619047619048, 96.47619047619048, 94.95238095238095, 96.19047619047619, 95.14285714285714, 95.71428571428571, 94.85714285714286, 95.9047619047619, 96.66666666666667, 94.95238095238095, 94.57142857142857, 94.19047619047619, 94.19047619047619, 95.9047619047619, 95.9047619047619, 94.66666666666667, 96.0952380952381, 96.0, 95.9047619047619, 97.14285714285714, 96.19047619047619, 96.28571428571429, 96.19047619047619] #C457NN = [96.0, 94.95238095238095, 94.28571428571429, 95.61904761904762, 95.23809523809524, 96.38095238095238, 95.23809523809524, 96.0, 95.04761904761905, 96.0952380952381, 96.19047619047619, 94.57142857142857, 96.47619047619048, 96.38095238095238, 95.42857142857143, 94.85714285714286, 94.57142857142857, 96.19047619047619, 94.76190476190476, 94.47619047619048, 94.95238095238095, 95.61904761904762, 96.19047619047619, 96.0, 95.04761904761905, 95.33333333333333, 96.28571428571429, 95.52380952380952, 96.47619047619048, 95.61904761904762, 95.80952380952381, 95.14285714285714, 96.0952380952381, 95.04761904761905, 95.33333333333333, 96.85714285714286, 95.23809523809524, 96.0952380952381, 93.52380952380952, 95.52380952380952, 95.71428571428571, 96.0, 94.57142857142857, 96.66666666666667, 96.0, 95.61904761904762, 96.38095238095238, 95.61904761904762, 96.0, 95.61904761904762] tree = [96.18604651162791, 96.18604651162791, 96.37209302325581, 96.46511627906976, 96.74418604651163, 96.09302325581395, 95.90697674418605, 96.18604651162791, 96.27906976744185, 96.27906976744185, 96.09302325581395, 96.18604651162791, 96.65116279069767, 96.18604651162791, 95.81395348837209, 96.0, 96.55813953488372, 96.18604651162791, 95.72093023255815, 95.72093023255815, 96.0, 95.90697674418605, 96.09302325581395, 96.0, 96.46511627906976, 96.18604651162791, 96.09302325581395, 95.90697674418605, 95.81395348837209, 96.55813953488372, 96.0, 96.46511627906976, 96.0, 96.09302325581395, 96.18604651162791, 95.72093023255815, 96.27906976744185, 95.62790697674419, 94.79069767441861, 95.81395348837209, 96.09302325581395, 96.18604651162791, 96.37209302325581, 96.37209302325581, 96.27906976744185, 96.09302325581395, 96.46511627906976, 96.74418604651163, 96.0, 96.18604651162791] C457NN = [94.13953488372093, 95.53488372093024, 96.46511627906976, 95.44186046511628, 95.72093023255815, 95.53488372093024, 95.06976744186046, 96.0, 94.88372093023256, 95.81395348837209, 94.97674418604652, 94.69767441860465, 96.37209302325581, 95.25581395348837, 94.79069767441861, 95.53488372093024, 96.46511627906976, 96.0, 95.90697674418605, 95.62790697674419, 95.81395348837209, 94.32558139534883, 95.16279069767442, 94.4186046511628, 94.97674418604652, 96.0, 95.81395348837209, 95.34883720930233, 95.72093023255815, 95.90697674418605, 95.53488372093024, 95.72093023255815, 95.25581395348837, 95.62790697674419, 96.55813953488372, 96.37209302325581, 96.09302325581395, 94.51162790697674, 95.16279069767442, 94.79069767441861, 95.25581395348837, 94.69767441860465, 96.46511627906976, 95.44186046511628, 95.81395348837209, 96.55813953488372, 95.25581395348837, 96.46511627906976, 94.97674418604652, 94.97674418604652] print 'average tree = ',average(tree) print 'average C4.5(7NN) = ', average(C457NN) print 'median tree = ',median(tree) print 'median C4.5(7NN) = ', median(C457NN) print 'wilcoxon test for J48 or C4.5(7NN):', wilcoxon(tree, C457NN)
people.pop(31)
people.pop(30)
people.pop(0)
person = (random.choice(people))
questions = []
unique_questions = []
occurence_count = []
for i in range(0, 100):
question = (random.choice(people))
if questions.__contains__(question):
occurence_count.append(question)
else:
unique_questions.append(question)
questions.append(question)
print(len(questions))
print(len(unique_questions))
ocount = []
for uquestion in unique_questions:
count = questions.count(uquestion)
print('This question ' + uquestion + ' appeared ' + str(count) + ' times')
ocount.append(count)
print("There was a total of " + str(len(occurence_count)) +
" Same occurences of a question")
print(str(average(ocount)))
def draw_pose(dwg, pose, src_size, inference_box, depthFrame,intrinsics,color='yellow', threshold=0.2):
global timestamps
global checkfpsNow
global fps
box_x, box_y, box_w, box_h = inference_box
scale_x, scale_y = src_size[0] / box_w, src_size[1] / box_h
xys = {}
cv2.namedWindow('motion', cv2.WINDOW_AUTOSIZE)
# print(pose)
# print(dwg.shape)
# print(len(depthFrame[0]))
realXYZ={}
oldPoints={}
for label, keypoint in pose.keypoints.items():
if keypoint.score < threshold : continue
# Offset and scale to source coordinate space.
#print(keypoint.yx[0],keypoint.yx[1])
kp_y = int((keypoint.yx[0] - box_y) * scale_y)
kp_x = int((keypoint.yx[1] - box_x) * scale_x)
#print(kp_x,kp_y)
scale=10
kp_x=int(kp_x-(kp_x%scale))
kp_y=int(kp_y-(kp_y%scale))
xys[label] = (kp_x, kp_y)
dwg=cv2.circle(dwg,(int(kp_x), int(kp_y)), 3,(0,0,255),5)
realX,realY,realZ=rs.rs2_deproject_pixel_to_point(intrinsics,[kp_y,kp_x],depthFrame[int(kp_y)-1][int(kp_x)])
realXYZ[label]=[realX,realY,realZ]
#dwg=cv2.putText(dwg,"({0},{1},{2})".format(round(realY),round(realX),round(realZ)),(int(kp_x),int(kp_y) ),(cv2.FONT_HERSHEY_COMPLEX),0.6,(0,255,0),1,cv2.LINE_AA)
# dwg=cv2.putText(dwg,"({0},{1},{2})".format((kp_x),(kp_y),str(depthFrame[int(kp_y)-1][int(kp_x)])),(int(kp_x),int(kp_y) ),(cv2.FONT_HERSHEY_COMPLEX),0.6,(0,255,0),1,cv2.LINE_AA)
for a, b in EDGES:
if a not in xys or b not in xys: continue
ax, ay = xys[a]
bx, by = xys[b]
dwg=cv2.line(dwg,(ax, ay),(bx, by), (0,255,0),2)
for A,B,C,D in shoulderAngles:
if B not in xys or C not in xys or D not in xys: continue
if("right hip" in xys): A="right hip"
elif("left hip" in xys): A="left hip"
else: continue
# print(list(xys[A])[1],xys[B],xys[C])
# print((depthFrame[list(xys[A])[1]-1] [list(xys[A])[0]]))
# a,b,c,d=list(map(lambda p: ((np.asarray(xys[p]+tuple([depthFrame[list(xys[p])[1]-1][list(xys[p])[0]]])))),[A,B,C,D]))
a,b,c,d=list(map(lambda p: np.asarray(realXYZ[p]),[A,B,C,D]))
# print(a,b,c)
ANGLES=projectedAngle(c-d,a,b,d)
dwg=cv2.putText(dwg,str(ANGLES),(xys[D]),(cv2.FONT_HERSHEY_COMPLEX),0.6,(0,255,0),1,cv2.LINE_AA)
for A,B,C in elbowAngles:
if A not in xys or B not in xys or C not in xys: continue
# print(list(xys[A])[1],xys[B],xys[C])
# print((depthFrame[list(xys[A])[1]-1] [list(xys[A])[0]]))
# realX,realY,realZ=rs.rs2_deproject_pixel_to_point(intrinsics,[kp_y,kp_x],depthFrame[int(kp_y)-1][int(kp_x)])
# a,b,c=list(map(lambda p: ((np.asarray(xys[p]+tuple([depthFrame[list(xys[p])[1]-1][list(xys[p])[0]]])))),[A,B,C]))
a,b,c=list(map(lambda p: np.asarray(realXYZ[p]),[A,B,C]))
# a,b,c=list(map(lambda p: ((np.asarray(xys[p]+tuple([depthFrame[list(xys[p])[1]-1][list(xys[p])[0]]])))),[A,B,C]))
# print(a,b,c)
ANGLE=str(angle(b-a,c-b,True))
if(ANGLE!=-1):
dwg=cv2.putText(dwg,ANGLE,(xys[B]),(cv2.FONT_HERSHEY_COMPLEX),1,(0,255,0),2,cv2.LINE_AA)
if(len(timestamps)>30 and checkfpsNow>5):
checkfpsNow=0
fps=1/average(timestamps)
checkfpsNow+=1
dwg=cv2.putText(dwg,str(round(fps))+' fps',(10,20),(cv2.FONT_HERSHEY_COMPLEX),1,(255,0,0),2,cv2.LINE_AA)
cv2.imshow('motion', dwg)
