def generate_puzzle(self, words_clues=None):
if not words_clues:
print(
"generate puzzle needs a list of words and clues in"
"the following format [{'answer': 'வணக்கம்', 'clue': 'hello in tamil'}]"
)
return None
result = []
across = 1
down = 1
num_puzzle = len(words_clues) - 1
while num_puzzle >= 0:
rand_num = random.randint(0, num_puzzle)
p = words_clues.pop(rand_num)
num_puzzle -= 1
if len(p['answer']) >= self.width:
continue
x = self._find_best_fit(p)
x['startx'], x['starty'] = x['starty'], x['startx']
if x['orientation'] == 'across':
x['position'] = across
across += 1
else:
x['position'] = down
down += 1
result.append(x)
print_matrix(self.puzzle_matrix, self.width)
print(result)
def nice_print(result):
if type(result) is list and type(result[0]) is list and type(result[0][0]) is not dict and type(result[0][0]) is not list:
print_matrix(result)
elif type(result) is list and type(result[0]) is not dict:
for line in result:
print(line)
else:
print(json.dumps(result, indent=2))
def print(self):
# Print the current state of all state (memory) elements of the CPU
print_val(self.PC, "PC")
print_mem(self.imem, "IMEM", val_width=16)
print_mem(self.regfile, "Regfile", label_all=True)
print_mem(self.dmem, "DMEM")
print_input(self.buttons, "Input")
print_matrix(self.matrix, "Output")
def pprint(self, show_labels=False):
if show_labels:
vertex_list = self.vertex_list or [
Vertex(i) for i in range(self.shape[0])
]
row_labels = [v.label for v in vertex_list]
print_matrix(self, row_labels)
else:
print_matrix(self)
def print_best(iteration, simulated_annealing, n_rows, n_columns):
if simulated_annealing.get_best_point() != -1:
print(f"\n---{iteration} iteration best working_point:")
utils.print_matrix(simulated_annealing.get_best_point())
print(f"---{iteration} iteration best score: {simulated_annealing.get_best_score()}")
print(f"--{iteration} iteration best iteration: {simulated_annealing.best_score_iteration}")
print(f"\n---{iteration} iteration best working point in original form:")
utils.print_matrix(generate_accepted_output(simulated_annealing.entry_matrix, simulated_annealing.get_best_point(), n_rows, n_columns))
else:
print("\n---No best working_point!!! No feasible solution found!!!")
def compute_cosine_matrices(speaker_files):
speakers = []
for s in speaker_files:
print(s)
vocab_file = s.replace("embeddings_",
"wordids_").replace(".npz", ".json")
indices = get_common_word_indices(vocab_file, common_words)
m = np.load(s)['arr_0']
m = slice_matrix_in_order(m, indices)
print_matrix(
m, common_words,
s.replace("embeddings_", "common_vocab_").replace(".npz", ".dm"))
m_cos = compute_cosines(m)
speakers.append(m_cos)
print_matrix(
m_cos, common_words,
s.replace("embeddings_", "cosines_").replace(".npz", ".dm"))
return speakers
def main(use_penalty, input_field, number_of_iterations=100000, starting_temperature=90, init_generation_mode=0, author_penalty=150, university_penalty=200):
if input_field == 'f':
used_input = filozofia_input
elif input_field == 'm':
used_input = matematyka_input
elif input_field == 'i':
used_input = informatyka_techniczna_telekomunikacja_input
else:
print("---Unknown input field")
return
lp_matrix, score_matrix, contribution_matrix, author_limits, n_rows, n_columns = generate_accepted_input(used_input)
if use_penalty:
simulated_annealing = SimulatedAnnealingPenalty(lp_matrix, score_matrix, contribution_matrix, author_limits, number_of_iterations, starting_temperature, init_generation_mode, author_penalty, university_penalty)
else:
simulated_annealing = SimulatedAnnealingRepair(lp_matrix, score_matrix, contribution_matrix, author_limits, number_of_iterations, starting_temperature, init_generation_mode)
pair_count = get_author_article_pairs_count(simulated_annealing.working_point)
print(f"---Pair author/article count: {pair_count}")
if number_of_iterations < 1000*pair_count:
print("Too small number of iterations")
print(f"Should be greater or equal: {1000*pair_count}")
return
print("---Entry matrix (score, contribution, unit gain): ")
utils.print_matrix(simulated_annealing.entry_matrix)
print("---Init working point: ")
utils.print_matrix(simulated_annealing.working_point)
print("\n---Init working point in original form:")
utils.print_matrix(generate_accepted_output(simulated_annealing.entry_matrix, simulated_annealing.working_point, n_rows, n_columns))
stop_list = [1, 10*pair_count, 100*pair_count, 1000*pair_count]
print("\n---Running Simulated Annealing...")
prev_iteration = 0
for stop in stop_list:
iterations = stop - prev_iteration
working_point, score = simulated_annealing.simulated_annealing(iterations)
prev_iteration = stop
print(f"---After {stop} iterations:")
print(f"---{simulated_annealing.best_score_iteration} best iteration score: {simulated_annealing.get_best_score()}")
print_best(prev_iteration, simulated_annealing, n_rows, n_columns)
working_point, score = simulated_annealing.simulated_annealing()
print_best(number_of_iterations, simulated_annealing, n_rows, n_columns)
elif args.exercise == 2:
from tests import test_exercise_2
test_exercise_2()
elif args.exercise == 3:
from tests import test_exercise_3
test_exercise_3()
elif args.exercise == 4:
from tests import test_exercise_4
test_exercise_4()
else:
from utils import print_matrix
# print_heading(f'Solution to exercise {args.exercise}')
if args.exercise == 1:
from markov import exercise_1
_, trans_table = exercise_1()
print_matrix(trans_table)
elif args.exercise == 2:
from markov import exercise_2
_, trans_table = exercise_2()
print_matrix(trans_table)
elif args.exercise == 3 or args.exercise == 4:
from markov import exercise_3, exercise_4
((p1, std1), (p3, std3),
(p9, std9)) = exercise_3() if args.exercise == 3 else exercise_4()
for s, p, std in [(1, p1, std1), (3, p3, std3), (9, p9, std9)]:
print(f'p(state = {s}) = {p}+-{std}')
def read_file(filename="input.mat"):
'''
Method - 1 . All params in the same file.
Legacy code!
File format:
TRANSA TRANSB ALPHA BETA LDA LDB LDC M N K
A
B
C
'''
A = None
B = None
C = None
lines = []
params = {}
try:
f = open(filename, "r")
lines = f.readlines()
except:
print "Failed to open/read from file: " + filename
raise
line = lines[0].split(' ')
try:
params['TRANSA'] = line[0]
params['TRANSB'] = line[1]
params['ALPHA'] = float(line[2])
params['BETA'] = float(line[3])
params['LDA'] = int(line[4])
params['LDB'] = int(line[5])
params['LDC'] = int(line[6])
params['M'] = int(line[7])
params['N'] = int(line[8])
params['K'] = int(line[9])
if params['LDA'] < 0 or\
params['LDB'] < 0 or\
params['LDC'] < 0 or\
params['M'] < 0 or\
params['N'] < 0 or\
params['K'] < 0:
raise WrongParameterError(
"One of the matrix dimensions is negative")
# read matrix A[M][K]
A = parse_matrix(lines[1:params['M'] + 1], params['M'], params['K'])
# read matrix B[K][N]
B = parse_matrix(
lines[(params['M'] + 1):(params['M'] + params['K'] + 1)],
params['K'], params['N'])
# read matrix C
C = parse_matrix(lines[(params['M'] + params['K'] + 1):], params['M'],
params['N'])
print_matrix(A, "----Matrix A----", "----End of Matrix A----")
print_matrix(B, "----Matrix B----", "----End of Matrix B----")
print_matrix(C, "----Matrix C----", "----End of Matrix C----")
except ValueError:
print "Error when converting one of the parameters"
raise
except Exception as ex:
raise
if A == None or\
B == None or\
C == None:
return None
params['A'] = A
params['B'] = B
params['C'] = C
f.close()
return params
import utils
from utils import print_matrix as my_print_matrix
from pprint import pprint as pp
import sys
print_matrix = True
utils.print_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
pp([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
pp(sys.path)
print("__name__:", __name__)
def play_pyano():
n_folds = 5
learning_rate = 0.1 # 1e-05
n_epoch = 1500
mu = 0.001
filename = 'data-copy.csv' # 'data.csv'
dataset = utils.load_csv(filename)
utils.ds_to_float(dataset)
# print_dataset(dataset)
# convert class column to integers
last_column_index = len(dataset[0]) - 1
utils.column_to_int(dataset, last_column_index)
# print_dataset(dataset)
# normalize input variables
minmax = utils.min_max(dataset)
# print(minmax)
utils.normalize(dataset, minmax)
folds = utils.cross_validation_split(dataset, n_folds)
#for fold in folds:
#print("Fold {} \n \n".format(fold))
scores = list()
predicted = []
actual = []
for fold in folds:
train_set = list(folds)
train_set.remove(fold)
train_set = sum(train_set, [])
test_set = list()
for row in fold:
row_copy = list(row)
test_set.append(row_copy)
row_copy[-1] = None
predicted = train_and_predict(dataset, train_set, test_set, row,
learning_rate, n_epoch, mu)
actual = [row[-1] for row in fold]
accuracy = utils.accuracy_met(actual, predicted)
cm = confusion_matrix(actual, predicted)
utils.print_matrix(cm)
FP = cm.sum(axis=0) - np.diag(cm)
FN = cm.sum(axis=1) - np.diag(cm)
TP = np.diag(cm)
TN = cm.sum() - (FP + FN + TP)
print('False Positives\n{}'.format(FP))
print('False Negatives\n{}'.format(FN))
print('True Positives\n{}'.format(TP))
print('True Negatives\n{}'.format(TN))
TPR = TP / (TP + FN)
print('Sensitivity \n{}'.format(TPR))
TNR = TN / (TN + FP)
print('Specificity \n{}'.format(TNR))
Precision = TP / (TP + FP)
print('Precision \n{}'.format(Precision))
Recall = TP / (TP + FN)
print('Recall \n{}'.format(Recall))
Acc = (TP + TN) / (TP + TN + FP + FN)
print('Áccuracy \n{}'.format(Acc))
Fscore = 2 * (Precision * Recall) / (Precision + Recall)
print('FScore \n{}'.format(Fscore))
k = cohen_kappa_score(actual, predicted)
print('Çohen Kappa \n{}'.format(k))
scores.append(accuracy)
import utils matrix = [[0] * 5 for i in range(3)] utils.print_matrix(matrix)
def face_detect_main(options, cam_id=0):
#装载训练好的模型
model = Model()
model.load_model(MODEL_PATH)
#识别部分，分为使用图片进行识别，和利用摄像头中的实时图像进行识别
if options == 'use_images':
#如果选择使用现有图片来预测，则从62类的照片中每类任意抽出一张进行预测
order_sheet, mini_id = generate_orderSheet(TEST_DATA)
generate_testdata(TEST_DATA)
image_visualization()
predict = model.predict(images, image_num=len(labels))
for i in range(len(labels)):
predict[i] = order_sheet[predict[i]] + mini_id
labels[i] = order_sheet[labels[i]] + mini_id
print('[predict]')
print_matrix(predict)
print('[truth]')
print_matrix(labels)
print('accuracy: %d' % (cal_accuracy(predict, labels) * 100) + '%')
image = Image.open('../test.png')
image.show()
elif options == 'use_camera':
#默认使用电脑自带摄像头进行预测，修改camera_id可以选择使用外接摄像头
camera_id = cam_id
color = (255, 0, 255)
cap = cv2.VideoCapture(camera_id)
order_sheet, mini_id = generate_orderSheet(TEST_DATA)
while True:
#获取摄像头中实时图片并灰度化，减少分割出人脸时的计算量
_, frame = cap.read()
frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
#加载cascade分类器,并从图像中分割出人脸部分
cascade = cv2.CascadeClassifier(cascade_path)
faceRects = cascade.detectMultiScale(frame_gray,
scaleFactor=1.2,
minNeighbors=3,
minSize=(48, 48),
maxSize=(192, 192))
if len(faceRects) > 0:
for faceRect in faceRects:
x, y, w, h = faceRect
#send face image to network
image = frame[y - 30:y + h + 30, x - 30:x + w + 30]
image = cv2.cvtColor(resize_image(image, padding=True),
cv2.COLOR_BGR2RGB).astype(
np.float32) / 255
image = image.reshape(1, 64, 64, 3)
faceID = model.predict(image)
#using faceID to set the annotation
label = str(order_sheet[faceID] + mini_id)
cv2.rectangle(frame, (x - 10, y - 10),
(x + w + 10, y + h + 10),
color,
thickness=2)
#文字提示是谁
cv2.putText(
frame,
label,
(x + 10, y - 40), #坐标
cv2.FONT_HERSHEY_SIMPLEX, #字体
1, #字号
color, #颜色
2) #字的线宽
cv2.imshow("face_detect", frame)
#等待10毫秒看是否有按键输入
k = cv2.waitKey(10)
#如果输入q则退出循环
if k & 0xFF == ord('q'):
break
#释放摄像头并销毁所有窗口
cap.release()
cv2.destroyAllWindows()
import os
from nussinov import Nussinov
from utils import FastaReader, pairs2parentheses, print_matrix
if __name__ == "__main__":
nus = Nussinov()
#seq = "ACCAGCU"
seq = "GCGCUCUGAUGAGGCCGCAAGGCCGAAACUGCCGCAAGGCAGUCAGCGC"
nus.seq = seq
nus.fill_matrix()
print_matrix(nus.V_matrix, seq=seq)
pairs = nus.get_pairs()
print(pairs)
print(seq)
parentheses = pairs2parentheses(pairs, len(seq))
print(parentheses)
print(parentheses.count("("))
ex_path1 = sys.argv[1] # Path de la première matrice
ex_path2 = sys.argv[2] # Path de la deuxième matrice
# def looper(a, b, seuil):
# start = time.time()
# _ = strassen_seuil(a, b, seuil)
# duration = (time.time() - start) * 1000
# print(f'{seuil}\t{duration}')
if __name__ == "__main__":
a = read_matrix(ex_path1)
b = read_matrix(ex_path2)
# seuil = 150
seuil = len(a) // 2
# for seuil in range(len(a)):
# looper(a, b, seuil)
start = time.time()
matrix = strassen_seuil(a, b, seuil)
duration = (time.time() - start) * 1000
options = sys.argv[3:]
if '-p' in options: # On imprime la matrice résultat
# Données bidon, mais output du bon format demandé
print_matrix(matrix)
if '-t' in options: # On imprime le temps d'exécution
print(duration) # Données bidon, mais output du bon format demandé ok
appendRecursively(fileTree, pathList)
setReachable(fileTree)
outputs = []
printRecursively(".", fileTree, True)
i = -1
def index():
global i
i +=1
return "[%d]" % i
if not outputs:
exit(1)
elif len(outputs) > 1:
sys.stderr.write("Velg path:\n")
print_matrix([["Index", "Path", "Antall filer"]] + map(lambda line: (index(), line[0], line[1]), outputs), sys.stderr)
try:
i = input()
except:
exit(1)
else:
i = 0
git_root = Popen(["git", "root"], stdout=PIPE).communicate()[0]
print("%s/%s" % (git_root.rstrip(), outputs[i][0]))
def begin_new_game(player1, player2):
"""
This is the function that calls and makes all the necessary updates when the user enters a move
"""
matrix = [[" ", " ", " "], [" ", " ", " "], [" ", " ", " "]]
Global_variables.random_player_begin = Global_variables.next_player
if Global_variables.random_player_begin == 0:
Global_variables.random_player_begin = randint(1, 2)
if Global_variables.random_player_begin == 1:
Global_variables.next_player = 2
current_player = player1
print(current_player, end=" ")
character = input("what character do you want to be? O or X: ")
if character.upper() == "O":
player1_character = "O"
player2_character = "X"
else:
player1_character = "X"
player2_character = "O"
else:
Global_variables.next_player = 1
current_player = player2
print(current_player, end=" ")
character = input("what character do you want to be? O or X: ")
if character.upper() == "O":
player2_character = "O"
player1_character = "X"
else:
player2_character = "X"
player1_character = "O"
while True:
print_matrix(matrix)
if current_player == player1:
character = player1_character
else:
character = player2_character
valid = True
while valid:
print(current_player,
"enter the position where you want to place",
character,
"?",
end=" ")
move = int(input(""))
if validate_move(move, matrix) == True:
valid = False
else:
print(
"That move is not valid! You should consider entering a different position!"
)
make_move(move, matrix, character)
if check_if_player_is_winner(character, matrix) == True:
print("The winner of this match is ", current_player)
if current_player == player1:
Global_variables.player_one_score = Global_variables.player_one_score + 1
else:
Global_variables.player_two_score = Global_variables.player_two_score + 1
return
if current_player == player1:
current_player = player2
else:
current_player = player1
if can_continue(matrix) == True:
print("It is a draw!")
return
from utils import print_matrix
def load_origins():
return [Location(line.strip()) for line in open("origins.txt")]
def load_destinations():
destinations = []
with open("destinations.csv") as f:
reader = csv.reader(f)
for row in reader:
# Support empty lines and comments for easier readability of csv
if not row or row[0].startswith("#"):
continue
destinations.append(
Location(name=row[0],
address=row[1],
comment=row[2],
weight=float(row[3]),
mode=row[4]))
return destinations
if __name__ == "__main__":
force = len(sys.argv) == 2 and sys.argv[1] in {"--force", "-f"}
streets_ahead = StreetsAheadService()
origins, destinations = load_origins(), load_destinations()
matrix = streets_ahead.summary(origins, destinations, force=force)
print_matrix(matrix, sort_by='wa')
def Generate_OrderSheet(self):
'''
初始得到的标签列表元素为string类型
首先将其转化为np.array
然后根据得到的np.array中元素的大小，从小到大排序得到一张次序表
然后遍历np.array，每一个元素在次序表中搜索对应，并用次序表中这个元素的下标
来取代np.array中该元素的值
这样就可以把一个string类型的列表转化为一个one-hot编码方式所需求得顺序np.array数组
'''
#using os operation to get the number of classes
print(
"============================================================================"
)
print(
'|| the original class labels is: ||'
)
print(
"============================================================================"
)
#print labels
folders = os.listdir(self.DATASET_ROOT_DIR)
folders = np.asarray(folders, dtype=np.float32)
print(folders)
print(
"============================================================================\n"
)
self.minimun_id = min(folders)
print("=======================================")
print('the minimum class label is: ' + str(self.minimun_id) + '||')
print("=======================================\n")
class_num = len(folders)
self.predefined_class = class_num
print("=================================================")
print('the total number of predefined classes is: ' + str(class_num) +
'||')
print("=================================================\n")
for folder in folders:
temp = int(folder) - self.minimun_id
self.relative_sheet = np.append(self.relative_sheet, temp)
print(
"============================================================================="
)
print(
'|| the relative class label sheet is: ||'
)
print(
"============================================================================="
)
print(self.relative_sheet)
print(
"=============================================================================\n"
)
self.order_sheet = Bubble_Sort(self.relative_sheet)
print(
"============================================================================="
)
print(
'|| generated order sheet: ||'
)
print(
"============================================================================="
)
print_matrix(self.order_sheet)
print(
"=============================================================================\n"
)
