def scatter_old(self):
maskMalig = self.labels == 1
maskBenig = self.labels == 0
embed_method = 'euclidean'
rating_method = 'euclidean' # 'chebyshev'
embed_benig_d = flatten_dm(calc_distance_matrix(self.embedding[maskBenig], embed_method))
embed_malig_d = flatten_dm(calc_distance_matrix(self.embedding[maskMalig], embed_method))
embed_cross_d = flatten_dm(
calc_cross_distance_matrix(self.embedding[maskMalig], self.embedding[maskBenig], embed_method))
rating = np.array(self.rating)
rating_benig_d = flatten_dm(calc_distance_matrix(rating[maskBenig], rating_method))
rating_malig_d = flatten_dm(calc_distance_matrix(rating[maskMalig], rating_method))
rating_cross_d = flatten_dm(calc_cross_distance_matrix(rating[maskMalig], rating[maskBenig], rating_method))
# Plot outputs
plt.figure()
plt.scatter(embed_cross_d, rating_cross_d, color='blue')
plt.scatter(embed_malig_d, rating_malig_d, color='red')
plt.scatter(embed_benig_d, rating_benig_d, color='green')
plt.xlabel('Embed')
plt.ylabel('Rating')
def linear_regression_by_maligancy(self, embed_method='euclidean', rating_method='chebyshev'):
maskMalig = self.labels == 1
maskBenig = self.labels == 0
embed_benig_d = flatten_dm(calc_distance_matrix(self.embedding[maskBenig], embed_method))
embed_malig_d = flatten_dm(calc_distance_matrix(self.embedding[maskMalig], embed_method))
rating = np.array(self.rating)
rating_benig_d = flatten_dm(calc_distance_matrix(rating[maskBenig], rating_method))
rating_malig_d = flatten_dm(calc_distance_matrix(rating[maskMalig], rating_method))
plt.figure()
plt.scatter(embed_malig_d, rating_malig_d, color='red')
plt.scatter(embed_benig_d, rating_benig_d, color='green')
def test_rules(metric):
a = np.array([1, 1, 1, 1, 1, 1])
b = np.array([2, 2, 1, 1, 1, 1])
c = np.array([3, 1, 1, 1, 1, 1])
e = np.array([2, 2, 2, 2, 2, 2])
f = np.array([2, 2, 2, 2, 2, 1])
rule1 = calc_distance_matrix(np.vstack([a, b]),
metric)[0, 1] < calc_distance_matrix(
np.vstack([a, c]), metric)[0, 1]
rule2 = calc_distance_matrix(np.vstack([e, f]),
metric)[0, 1] < calc_distance_matrix(
np.vstack([a, e]), metric)[0, 1]
return rule1, rule2
def evaluate_size_distance_matrix(self):
nodule_size = np.array([np.count_nonzero(q) for q in self.masks]).reshape(-1, 1) * 0.5 * 0.5
tresh = [0, 15, 30, 60, 120]
nodule_size = np.digitize(nodule_size, tresh)
self.size_distance_matrix = calc_distance_matrix(nodule_size, 'l1')
self.size_metric = 'l1'
return self.size_distance_matrix
def evaluate_rating_distance_matrix(self, method='chebyshev', clustered_rating_distance=False, weighted=False):
if clustered_rating_distance:
n = len(self.rating)
self.rating_distance_matrix = rating_clusters_distance_matrix(self.rating, weights=self.weights if weighted else None)
else:
rating = np.array([np.mean(rat, axis=0) for rat in self.rating])
self.rating_distance_matrix = calc_distance_matrix(rating, method)
#assert self.rating_distance_matrix.shape[0] == self.embed_distance_matrix.shape[0]
self.rating_metric = method
return self.rating_distance_matrix
def evaluate_embed_distance_matrix(self, method='euclidean', round=False, epoch=None):
if self.multi_epcch:
assert (epoch is not None)
assert (self.epochs is not None)
epoch_idx = np.argwhere(epoch == self.epochs)[0][0]
embd = self.embedding[epoch_idx]
assert np.all(np.isfinite(embd))
else:
embd = self.embedding
embd = embd if (round==False) else np.round(embd)
self.embed_distance_matrix = calc_distance_matrix(embd, method)
self.embed_metric = method
assert np.all(np.isfinite(self.embed_distance_matrix))
def malig_regression(self, method = 'correlation'):
#size = self.embed_distance_matrix.shape[0]
malig_rating = [calc_rating(meta, 'malig') for meta in self.meta_data]
malig_rating = np.array(malig_rating).reshape(-1,1)
malig_rating_distance_matrix = calc_distance_matrix(malig_rating, method)
malig_dist = flatten_dm(malig_rating_distance_matrix)
embed_dist = flatten_dm(self.embed_distance_matrix)
rating_dist = flatten_dm(self.rating_distance_matrix)
plt.figure()
plt.subplot(211)
plt.title('embed-malig')
plt.scatter(malig_dist, embed_dist, color='black')
plt.subplot(212)
plt.title('rating-malig')
plt.scatter(malig_dist, rating_dist, color='black')
def evaluate_rating_distance_matrix(self, method='chebyshev', clustered_rating_distance=False, weighted=False, local_scaling=False):
if clustered_rating_distance and np.concatenate(self.rating).ndim != 1:
n = len(self.rating)
self.rating_distance_matrix = rating_clusters_distance_matrix(self.rating, weights=self.weights if weighted else None)
else:
if np.concatenate(self.rating).ndim == 1:
print('Simple L2 distance matrix (not clustered_rating), due to only a single rating vector being provided')
rating = self.rating
else:
rating = np.array([np.mean(rat, axis=0) for rat in self.rating])
self.rating_distance_matrix = calc_distance_matrix(rating, method)
#assert self.rating_distance_matrix.shape[0] == self.embed_distance_matrix.shape[0]
if local_scaling:
self.rating_distance_matrix = self.rating_distance_matrix / (self.rating_distance_matrix.std(axis=0, keepdims=True) + 1e-6)
self.rating_metric = method
return self.rating_distance_matrix
def load_distance_matrix(self, name, flat=True):
if name == 'embed':
xVec = self.embed_distance_matrix
xMet = self.embed_metric
elif name == 'rating':
xVec = self.rating_distance_matrix
xMet = self.rating_metric
elif name == 'malig':
#malig_rating = [calc_rating(meta, method='malig') for meta in self.meta_data]
#malig_rating = np.array(malig_rating).reshape(-1, 1).astype('float64')
malig_rating = np.array([[np.mean(rat[:, -1])] for rat in self.rating])
xVec = calc_distance_matrix(malig_rating, method='euclidean')
xMet = 'euclidean'
elif name == 'size':
xVec = self.size_distance_matrix
xMet = self.size_metric
else:
assert False
return flatten_dm(xVec) if flat else xVec, xMet
def load_distance_matrix(self, name, flat=True):
if name == 'embed':
xVec = self.embed_distance_matrix
xMet = self.embed_metric
elif name == 'rating':
xVec = self.rating_distance_matrix
xMet = self.rating_metric
elif name == 'malig':
malig_rating = [
calc_rating(meta, method='malig') for meta in self.meta_data
]
malig_rating = np.array(malig_rating).reshape(-1,
1).astype('float64')
xVec = calc_distance_matrix(malig_rating, method='euclidean')
xMet = 'euclidean'
else:
assert False
if flat:
return flatten_dm(xVec), xMet
else:
return xVec, xMet
def scatter(self, X, Y, xMethod = 'euclidean', yMethod = 'euclidean', sub=False):
xVec = self.load(X)
yVec = self.load(Y)
maskMalig = self.labels == 1
maskBenig = self.labels == 0
x_benig_d = flatten_dm(calc_distance_matrix( xVec[maskBenig], xMethod))
x_malig_d = flatten_dm(calc_distance_matrix( xVec[maskMalig], xMethod))
x_cross_d = flatten_dm(calc_cross_distance_matrix( xVec[maskMalig],
xVec[maskBenig], xMethod))
y_benig_d = flatten_dm(calc_distance_matrix( yVec[maskBenig], yMethod))
y_malig_d = flatten_dm(calc_distance_matrix( yVec[maskMalig], yMethod))
y_cross_d = flatten_dm(calc_cross_distance_matrix( yVec[maskMalig],
yVec[maskBenig], yMethod))
print('{}-{}:'.format(X,Y))
print('\tCross R2 = {}'.format(linear_regression(x_cross_d, y_cross_d)[1]))
print('\tMalig R2 = {}'.format(linear_regression(x_malig_d, y_malig_d)[1]))
print('\tBenig R2 = {}'.format(linear_regression(x_benig_d, y_benig_d)[1]))
print('\tCross R = {}'.format(pearsonr(x_cross_d, y_cross_d)[0]))
print('\tMalig R = {}'.format(pearsonr(x_malig_d, y_malig_d)[0]))
print('\tBenig R = {}'.format(pearsonr(x_benig_d, y_benig_d)[0]))
# Plot outputs
plt.figure()
if sub: plt.subplot(311)
plt.scatter(x_cross_d, y_cross_d, color='blue', alpha=0.5, s=10)
if sub: plt.subplot(312)
plt.scatter(x_malig_d, y_malig_d, color='red', alpha=0.2, s=10)
plt.ylabel(Y)
if sub: plt.subplot(313)
plt.scatter(x_benig_d, y_benig_d, color='green', alpha=0.1, s=10)
plt.xlabel(X)
#if X is 'embed' and Y is 'malig':
# plt.figure()
# plt.plot(np.histogram2d(np.squeeze(x_malig_d), np.squeeze(y_malig_d), [5, 8])[0].T)
if sub:
plt.figure()
plt.title('Cross')
plt.plot(np.histogram2d(np.squeeze(x_cross_d), np.squeeze(y_cross_d), [5,5], normed=True)[0].T)
plt.xlabel('Malig Rating')
plt.legend(['0', '1', '2', '3', '4'])
plt.figure()
plt.title('Malig')
plt.plot(np.histogram2d(np.squeeze(x_malig_d), np.squeeze(y_malig_d), [5,5], normed=True)[0].T)
plt.xlabel('Malig Rating')
plt.legend(['0', '1', '2', '3', '4'])
plt.figure()
plt.title('Benig')
plt.plot(np.histogram2d(np.squeeze(x_benig_d), np.squeeze(y_benig_d), [5,5], normed=True)[0].T)
plt.xlabel('Malig Rating')
plt.legend(['0', '1', '2', '3', '4'])
def evaluate_embed_distance_matrix(self, method='euclidean'):
self.embed_distance_matrix = calc_distance_matrix(
self.embedding, method)
self.embed_metric = method
def evaluate_rating_distance_matrix(self, method='chebyshev'):
self.rating_distance_matrix = calc_distance_matrix(self.rating, method)
assert self.rating_distance_matrix.shape[
0] == self.embed_distance_matrix.shape[0]
self.rating_metric = method
return self.rating_distance_matrix
for entry in dataset
])
print("Ratings speard over {} annotations".format(Ratings.shape))
for metric in metrics[:]:
t1, t2 = test_rules(metric)
print("Metric: {} -\t{}\t{}".format(metric, t1, t2))
for metric in metrics[:]:
# intra
# =======
intra = []
for entry in dataset:
dm = calc_distance_matrix(
rating_normalize(entry['rating'], method=normalization), metric)
if dm.shape[0] > 1:
fdm = flatten_dm(dm)
intra.append(fdm)
#else:
# intra.append(dm)
intra = np.concatenate(intra)
intra_dist, intra_dist_std = np.mean(intra), np.std(intra)
# inter
# ========
dm = calc_distance_matrix(Ratings, metric)
dm = flatten_dm(dm)
innter_dist, innter_dist_std = np.mean(dm), np.std(dm)