def kernel(self, seq: ndarray, table: ndarray):
# def max_score(s1, s2):
# if s1 >= s2:
# return s1
# else:
# return s2
#
def match(b1, b2):
return b1 + b2 == 3
table_flattened = table.ravel()
# scop begin
for i in range(self.N):
diag_i = np.arange(0, self.N - i - 1)
diag_j = np.arange(i + 1, self.N)
slice_W = slice(i, i + self.N * (self.N - i - 1), self.N + 1)
slice_center = slice(i + 1, i + 1 + self.N * (self.N - i - 1),
self.N + 1)
slice_SW = slice(i + self.N, i + self.N * (self.N - i), self.N + 1)
slice_S = slice(i + 1 + self.N, i + 1 + self.N * (self.N - i),
self.N + 1)
table_flattened[slice_center] = np.maximum(
table_flattened[slice_center], table_flattened[slice_W])
table_flattened[slice_center] = np.maximum(
table_flattened[slice_center], table_flattened[slice_S])
if i > 0:
table_flattened[slice_center] = np.maximum(
table_flattened[slice_center], table_flattened[slice_SW] +
match(seq[0:self.N - 1 - i], seq[i + 1:self.N]))
else:
table_flattened[slice_center] = np.maximum(
table_flattened[slice_center], table_flattened[slice_SW])
if i < self.N - 1:
table_flattened[slice_center] = np.maximum(
table_flattened[slice_center],
np.max(table[0:self.N - i - 1, i + 1:self.N], axis=0))
def calculate_metrics(confusion_matrix: ndarray) -> tuple:
tn, fp, fn, tp = confusion_matrix.ravel()
accuracy = (tp + tn) / sum([tn, fp, fn, tp])
recall = tp / (tp + fn)
precision = tp / (tp + fp)
return accuracy, recall, precision
def kernel(self, A: ndarray):
# scop begin
# for t in range(0, self.TSTEPS - 1 +1):
# for i in range(1, self.N - 2 + 1):
# for j in range(1, self.N - 2 + 1):
# A[i,j] = (A[i - 1,j - 1] + A[i - 1,j] + A[i - 1,j + 1] # Dependences prevent vectorization: A[i,j-1] -> A[i,j]
# + A[i,j - 1] + A[i,j] + A[i,j + 1]
# + A[i + 1,j - 1] + A[i + 1,j] + A[i + 1,j + 1]) / 9.0
A_flattened = A.ravel()
self_N_1 = self.N - 1
self_Nx2 = self.N * 2
for t in range(self.TSTEPS):
for i in range(1, self_N_1):
end = i * self.N
slice_NW = slice(i - 1, end - 1, self_N_1)
slice_N = slice(i, end, self_N_1)
slice_NE = slice(i + 1, end + 1, self_N_1)
start = self.N + i
end += self.N
slice_W = slice(start - 1, end - 1, self_N_1)
slice_center = slice(start, end, self_N_1)
slice_E = slice(start + 1, end + 1, self_N_1)
start += self.N
end += self.N
slice_SW = slice(start - 1, end - 1, self_N_1)
slice_S = slice(start, end, self_N_1)
slice_SE = slice(start + 1, end, self_N_1)
A_flattened[slice_center] = (
A_flattened[slice_NW] + A_flattened[slice_N] +
A_flattened[slice_NE] + A_flattened[slice_W] +
A_flattened[slice_center] + A_flattened[slice_E] +
A_flattened[slice_SW] + A_flattened[slice_S] +
A_flattened[slice_SE]) / 9.0
# diagonal version
# diag_i = np.arange(1,i+1)
# diag_j = np.arange(i,0,-1)
# A[diag_i,diag_j] = ( A[diag_i-1,diag_j-1] + A[diag_i-1,diag_j] + A[diag_i-1,diag_j+1]+ A[diag_i,diag_j-1] + A[diag_i,diag_j] + A[diag_i,diag_j+1] + A[diag_i+1,diag_j-1] + A[diag_i+1,diag_j] + A[diag_i+1,diag_j+1] ) / 9.0
# scalar version
# for j in range( 1, i+1 ):
# A[j,i-j+1] = (A[j-1,i-j] + A[j-1,i-j+1] + A[j-1,i-j+2]
# + A[j,i-j] + A[j,i-j+1] + A[j,i-j+2]
# + A[j+1,i-j] + A[j+1,i-j+1] + A[j+1,i-j+2] ) / 9.0
for i in range(2, self.N):
start = self.N * i - 2
end = self.N**2 - 3 * self.N + i + 1
slice_NW = slice(start - 1, end - 1, self.N - 1)
slice_N = slice(start, end, self.N - 1)
slice_NE = slice(start + 1, end + 1, self.N - 1)
start += self.N
end += self.N
slice_W = slice(start - 1, end - 1, self.N - 1)
slice_center = slice(start, end, self.N - 1)
slice_E = slice(start + 1, end + 1, self.N - 1)
start += self.N
end += self.N
slice_SW = slice(start - 1, end - 1, self.N - 1)
slice_S = slice(start, end, self.N - 1)
slice_SE = slice(start + 1, end + 1, self.N - 1)
A_flattened[slice_center] = (
A_flattened[slice_NW] + A_flattened[slice_N] +
A_flattened[slice_NE] + A_flattened[slice_W] +
A_flattened[slice_center] + A_flattened[slice_E] +
A_flattened[slice_SW] + A_flattened[slice_S] +
A_flattened[slice_SE]) / 9.0