def scatter_data_test(showFigs=True):
I = plt.imread('../data/dataset_brains/1_1_t1.tif')
X1 = I.flatten().T
X1 = X1.reshape(-1, 1)
GT = plt.imread('../data/dataset_brains/1_1_gt.tif')
gt_mask = GT > 0
Y = gt_mask.flatten() # labels
I_blurred = ndimage.gaussian_filter(I, sigma=2)
X2 = I_blurred.flatten().T
X2 = X2.reshape(-1, 1)
X_data = np.concatenate((X1, X2), axis=1)
features = ('T1 intensity', 'T1 gauss 2'
) # Keep track of features you added
if showFigs:
util.scatter_data(X_data, Y, 0, 1)
#------------------------------------------------------------------#
# Implement a few test cases of with different features
I_blurred = ndimage.gaussian_filter(I, sigma=10)
X3 = I_blurred.flatten().T
X3 = X3.reshape(-1, 1)
I_blurred = ndimage.gaussian_filter(I, sigma=20)
X4 = I_blurred.flatten().T
X4 = X4.reshape(-1, 1)
X_data = np.concatenate((X1, X2, X3, X4), axis=1)
if showFigs:
util.scatter_data(X_data, Y, 0, 1)
#------------------------------------------------------------------#
return X_data, Y
def scatter_all(DM, LM, FL):
# scatter 2 features and their correspoding labels
# DM is matrix with all train_data
# LM is matrix with all labels_data
# FL is array with all feature names
row, column, subject = DM.shape
subject = 5
fig, axs = plt.subplots(nrows=column,
ncols=column,
figsize=(column * 5, column * 5),
sharex='all',
sharey='all')
for i in range(column):
for j in range(column):
ax = axs[i, j]
ax.grid(True)
ax.set_xlim(-2, 2)
ax.set_ylim(-2, 2)
# ax.legend(['Background', 'White matter', 'Grey matter', 'CSF'])
for im in range(subject):
X = DM[:, :, im]
Y = LM[:, im]
# if i == j:
# ax.hist(X, bins=100)
# else:
util.scatter_data(X, Y, feature0=i, feature1=j, ax=ax)
if i == column - 1:
axs[i, j].set_xlabel(FL[j].format(j + 1), fontsize=18)
if j == 0:
axs[i, j].set_ylabel(FL[i].format(i + 1), fontsize=18)
plt.show()
def scatter_t2_test(showFigs=True):
I1 = plt.imread('../data/dataset_brains/1_1_t1.tif')
X1 = I1.flatten().T
X1 = X1.reshape(-1, 1)
I2 = plt.imread('../data/dataset_brains/1_1_t2.tif')
X2 = I2.flatten().T
X2 = X2.reshape(-1, 1)
GT = plt.imread('../data/dataset_brains/1_1_gt.tif')
gt_mask = GT>0
Y = gt_mask.flatten() # labels
I1_blurred = ndimage.gaussian_filter(I1, sigma=4)
X12 = I1_blurred.flatten().T
X12 = X12.reshape(-1, 1)
X_data = np.concatenate((X1, X12), axis=1)
features = ('T1 intensity', 'T1 gauss 2') # Keep track of features you added
if showFigs:
util.scatter_data(X_data,Y,0,1)
#------------------------------------------------------------------#
# TODO: Extract features from the T2 image and compare them to the T1 features
#------------------------------------------------------------------#
return X_data, Y
def easy_hard_data_classifier_test():
#-------------------------------------------------------------------#
# generate and classify (using nn_classifier) 2 pairs of datasets (easy and hard)
# calculate classification error in each case
trainX, trainY, testX, testY = generate_train_test(2, task='easy')
util.scatter_data(trainX, trainY)
D = scipy.spatial.distance.cdist(testX, trainX, metric='euclidean')
min_index = np.argmin(D, axis=1)
predicted_labels = trainY[min_index]
err = util.classification_error(testY, predicted_labels)
print('True labels:\n{}'.format(testY))
print('Predicted labels:\n{}'.format(predicted_labels))
print('Error:\n{}'.format(err))
trainX, trainY, testX, testY = generate_train_test(2, task='hard')
util.scatter_data(trainX, trainY)
D = scipy.spatial.distance.cdist(testX, trainX, metric='euclidean')
min_index = np.argmin(D, axis=1)
predicted_labels = trainY[min_index]
err = util.classification_error(testY, predicted_labels)
print('True labels:\n{}'.format(testY))
print('Predicted labels:\n{}'.format(predicted_labels))
print('Error:\n{}'.format(err))
#-------------------------------------------------------------------#
pass
def test_mypca():
#Generates some toy data in 2D, computes PCA, and plots both datasets
N = 100
mu1 = [0, 0]
mu2 = [2, 0]
sigma1 = [[2, 1], [1, 1]]
sigma2 = [[2, 1], [1, 1]]
XG, YG = seg.generate_gaussian_data(N, mu1, mu2, sigma1, sigma2)
fig = plt.figure(figsize=(15, 6))
ax1 = fig.add_subplot(121)
util.scatter_data(XG, YG, ax=ax1)
sigma = np.cov(XG, rowvar=False)
w, v = np.linalg.eig(sigma)
ax1.plot([0, v[0, 0]], [0, v[1, 0]],
c='g',
linewidth=3,
label='Eigenvector1')
ax1.plot([0, v[0, 1]], [0, v[1, 1]],
c='k',
linewidth=3,
label='Eigenvector2')
ax1.set_title('Original data')
ax_settings(ax1)
ax2 = fig.add_subplot(122)
X_pca, v, w, fraction_variance = seg.mypca(XG)
util.scatter_data(X_pca, YG, ax=ax2)
sigma2 = np.cov(X_pca, rowvar=False)
w2, v2 = np.linalg.eig(sigma2)
ax2.plot([0, v2[0, 0]], [0, v2[1, 0]],
c='g',
linewidth=3,
label='Eigenvector1')
ax2.plot([0, v2[0, 1]], [0, v2[1, 1]],
c='k',
linewidth=3,
label='Eigenvector2')
ax2.set_title('My PCA')
ax_settings(ax2)
handles, labels = ax2.get_legend_handles_labels()
plt.figlegend(handles,
labels,
loc='upper center',
bbox_to_anchor=(0.5, -0.05),
bbox_transform=plt.gcf().transFigure,
ncol=4)
print(fraction_variance)
def feature_stats_test():
X, Y = scatter_data_test(showFigs=False)
I = plt.imread('../data/dataset_brains/1_1_t1.tif')
c, coord_im = seg.extract_coordinate_feature(I)
X_data = np.concatenate((X, c), axis=1)
#------------------------------------------------------------------#
# Write code to examine the mean and standard deviation of your dataset containing variety of features
means = np.zeros(X_data.shape[1])
stds = np.zeros(X_data.shape[1])
for i in range(X_data.shape[1]):
means[i] = np.mean(X_data[:, i])
stds[i] = np.std(X_data[:, i])
util.scatter_data(X_data, Y, 0, 1)
print(means)
print(stds)
def minimum_distance_test(X, Y, C, D):
#------------------------------------------------------------------#
# plot the datasets on top of each other in different colors and visualize the data,
# calculate the distances between the datasets,
# order the distances (min to max) using the provided code,
# calculate how many samples are closest to each of the samples in `C`
util.scatter_data(X, Y, 0, 1)
plt.scatter(C[:,0],C[:,1])
min_index = np.argmin(D, axis=1)
min_dist = D[:, min_index]
print('D',D)
print('min_index', min_index)
print('min_dist', min_dist)
print('mindist', min_dist.diagonal())
print(C[:,0], (min_index == 0).sum())
print(C[:,1], (min_index == 1).sum())
def kmeans_clustering_test():
#------------------------------------------------------------------#
#TODO: Store errors for training data
X_data, Y, feature_labels_train = util.create_dataset(1, 1, 'brain')
predicted_labels = seg.kmeans_clustering(X_data, K=2)
I = plt.imread('../data/dataset_brains/1_1_t1.tif')
GT = plt.imread('../data/dataset_brains/1_1_gt.tif')
gt_mask = GT > 0
gt_labels = gt_mask.flatten() # labels
predicted_mask = predicted_labels.reshape(I.shape)
fig = plt.figure(figsize=(15, 5))
ax1 = fig.add_subplot(131)
ax1.imshow(I)
ax2 = fig.add_subplot(132)
ax2.imshow(predicted_mask)
ax3 = fig.add_subplot(133)
ax3.imshow(gt_mask)
util.scatter_data(X_data, predicted_labels, 0, 1)
def scatter_data_test(showFigs=True):
I = plt.imread('../data/dataset_brains/1_1_t1.tif')
X1 = I.flatten().T
X1 = X1.reshape(-1, 1)
GT = plt.imread('../data/dataset_brains/1_1_gt.tif')
gt_mask = GT>0.5
Y = gt_mask.flatten() # labels
I_blurred = ndimage.gaussian_filter(I, sigma=2)
X2 = I_blurred.flatten().T
X2 = X2.reshape(-1, 1)
X_data = np.concatenate((X1, X2), axis=1)
features = ('T1 intensity', 'T1 gauss 2') # Keep track of features you added
if showFigs:
util.scatter_data(X_data,Y,0,1)
#------------------------------------------------------------------#
# TODO: Implement a few test cases of with different features
features += ('T1 gauss 5',)
features += ('T1 gauss 10',)
features += ('T1 gauss 15',)
I_blurred_5 = ndimage.gaussian_filter(I, sigma=5)
X5 = I_blurred_5.flatten().T
X5 = X5.reshape(-1, 1)
I_blurred_10 = ndimage.gaussian_filter(I, sigma=10)
X10 = I_blurred_10.flatten().T
X10 = X10.reshape(-1, 1)
I_blurred_15 = ndimage.gaussian_filter(I, sigma=15)
X15 = I_blurred_15.flatten().T
X15 = X15.reshape(-1, 1)
X_data = np.concatenate((X1, X2, X5, X10, X15), axis=1)
if showFigs:
util.scatter_data(X_data,Y,1,3)
#------------------------------------------------------------------#
return X_data, Y
def scatter_all(DM, LM, FL):
# scatter 2 features and their corresponding labels
# DM is matrix with all train_data
# LM is matrix with all labels_data
# FL is array with all feature names
row, column, subject = DM.shape
fig, axs = plt.subplots(nrows=column,
ncols=column,
figsize=(column * 5, column * 5))
# Make array with appended data from all subjects
X = DM[:, :, 0]
Y = LM[:, 0]
for im in range(1, subject):
X = np.append(X, DM[:, :, im], axis=0)
Y = np.append(Y, LM[:, im], axis=0)
# Now, loop over figures
for i in range(column):
for j in range(column):
ax = axs[i, j]
ax.grid(True)
# Plot stacked histograms on diagonals
if i == j:
ax.hist(X[:, i], bins=50, density=True)
# Scatter features on remaining subplots
else:
util.scatter_data(X, Y, feature0=i, feature1=j, ax=ax)
# Set labels on outside plots for readability
if i == column - 1:
axs[i, j].set_xlabel(FL[j].format(j + 1), fontsize=18)
if j == 0:
axs[i, j].set_ylabel(FL[i].format(i + 1), fontsize=18)
plt.show()
def initialize_cluster_centers(N=100, num_clusters=2):
# Generate 100 samples per Gaussian class
X, Y = seg.generate_gaussian_data(N)
# Select num_clusters rows from X and store in w_initial
start = np.random.randint(0, 98)
n_cluster_rows = X[start:(start + num_clusters), :]
w_initial = np.array(n_cluster_rows)
ax1 = util.scatter_data(X, Y)
ax1.scatter(w_initial[:, 0], w_initial[:, 1], c='y')
plt.show()
return X, w_initial
def minimum_distance_test(X, Y, C, D):
#------------------------------------------------------------------#
# TODO: plot the datasets on top of each other in different colors and visualize the data,
# calculate the distances between the datasets,
# order the distances (min to max) using the provided code,
# calculate how many samples are closest to each of the samples in `C`
ax1 = util.scatter_data(X, Y)
ax1.scatter(C[:, 0], C[:, 1], c='y')
plt.show()
min_index = np.argmin(D, axis=1)
min_dist = np.min(D, axis=1)
min_dist = np.asarray([min_dist])
min_dist = min_dist.T
print(min_dist)
def scatter_data_test(showFigs=True):
I = plt.imread('../data/dataset_brains/1_1_t1.tif')
X1 = I.flatten().T
X1 = X1.reshape(-1, 1)
GT = plt.imread('../data/dataset_brains/1_1_gt.tif')
gt_mask = GT > 0
Y = gt_mask.flatten() # labels
I_blurred = ndimage.gaussian_filter(I, sigma=2)
X2 = I_blurred.flatten().T
X2 = X2.reshape(-1, 1)
X_data = np.concatenate((X1, X2), axis=1)
features = ('T1 intensity', 'T1 gauss 2') # Keep track of features you added
if showFigs:
ax = util.scatter_data(X_data, Y, 0, 1)
return X_data, Y
return X_data, Y
def distance_classification_test():
#------------------------------------------------------------------#
# Use the provided code to generate training and testing data
# Classify the points in test_data, based on their distances d to the points in train_data
train_data, train_labels = seg.generate_gaussian_data(2);
test_data, test_labels = seg.generate_gaussian_data(1);
# train_data=np.array([[1,1],[0,0],[0,1],[1,0]]);
# train_labels=np.array([[0],[1],[0],[1]])
util.scatter_data(train_data, train_labels, 0, 1)
util.scatter_data(test_data, test_labels, 0, 1)
D = scipy.spatial.distance.cdist(test_data, train_data, metric='euclidean')
min_index = np.argmin(D, axis=1)
newlabels=train_labels[min_index]
print(test_data)
print(newlabels)
util.scatter_data(test_data,newlabels,0,1)
def PCA_features_demo():
task = 'tissue'
n = 5
all_subjects = np.arange(n)
train_slice = 1
tmp_data, tmp_labels, tmp_feature_labels = util.create_dataset(
1, train_slice, task)
all_data_matrix = np.empty((tmp_data.shape[0], tmp_data.shape[1], n))
all_labels_matrix = np.empty((tmp_labels.shape[0], n))
# Load all datasets once and compile in all_data_matrix
for i in all_subjects:
train_data, train_labels, train_feature_labels = util.create_dataset(
i + 1, train_slice, task)
all_data_matrix[:, :, i] = train_data
all_labels_matrix[:, i] = train_labels.ravel()
# Perform PCA and plots the first patient's features against each other
# Also calculates tha amount of features needed to account for at least 95% of the variance
X_pca, v, w, fraction_variance = seg.mypca(all_data_matrix[:, :, 0])
fig = plt.figure(figsize=(40, 40))
plot = 1
for i in range(8):
for j in range(8):
ax = plt.subplot(8, 8, plot)
ax = util.scatter_data(X_pca,
all_labels_matrix[:, 0],
feature0=i,
feature1=j,
ax=ax)
plot += 1
needed_features = np.sum((fraction_variance < 0.95).astype(int)) + 1
print("needed features to account for 95% of variance: {0}".format(
needed_features))
def scatter_data_test(showFigs=True):
I = plt.imread('../data/dataset_brains/1_1_t1.tif')
X1 = I.flatten().T
X1 = X1.reshape(-1, 1)
GT = plt.imread('../data/dataset_brains/1_1_gt.tif')
gt_mask = GT > 0
Y = gt_mask.flatten() # labels
I_blurred = ndimage.gaussian_filter(I, sigma=2)
X2 = I_blurred.flatten().T
X2 = X2.reshape(-1, 1)
X_data = np.concatenate((X1, X2), axis=1)
features = ('T1 intensity', 'T1 gauss 2'
) # Keep track of features you added
if showFigs:
util.scatter_data(X_data, Y, 0, 1)
#------------------------------------------------------------------#
# TODO: Implement a few test cases of with different features
I_blurred = ndimage.gaussian_filter(
I, sigma=5
) #nieuwe feature gemaakt door andere sigma in gaussische filter te gebruiken
X3 = I_blurred.flatten().T
X3 = X3.reshape(-1, 1)
I_blurred = ndimage.gaussian_filter(I, sigma=10)
X4 = I_blurred.flatten().T
X4 = X4.reshape(-1, 1)
X_data = np.concatenate((X_data, X3), axis=1)
X_data = np.concatenate((X_data, X4), axis=1)
if showFigs:
util.scatter_data(X_data, Y, 1, 2) #plot feature 2 tegen 3
util.scatter_data(X_data, Y, 2, 3) #plot feature 3 tegen 4
#------------------------------------------------------------------#
return X_data, Y
def scatter_t2_test(showFigs=True):
I1 = plt.imread('../data/dataset_brains/1_1_t1.tif')
X1 = I1.flatten().T
X1 = X1.reshape(-1, 1)
I2 = plt.imread('../data/dataset_brains/1_1_t2.tif')
X2 = I2.flatten().T
X2 = X2.reshape(-1, 1)
GT = plt.imread('../data/dataset_brains/1_1_gt.tif')
gt_mask = GT>0
Y = gt_mask.flatten() # labels
I1_blurred = ndimage.gaussian_filter(I1, sigma=4)
X12 = I1_blurred.flatten().T
X12 = X12.reshape(-1, 1)
X_data = np.concatenate((X1, X12), axis=1)
features = ('T1 intensity', 'T1 gauss 2') # Keep track of features you added
# if showFigs:
# util.scatter_data(X_data,Y,0,1)
#------------------------------------------------------------------#
# TODO: Extract features from the T2 image and compare them to the T1 features
features += ('T1 gauss 5',)
features += ('T1 gauss 10',)
features += ('T1 gauss 0',)
features +=('T2 intensity',)
features += ('T2 gauss 2',)
features += ('T2 gauss 5',)
features += ('T2 gauss 10',)
features += ('T2 gauss 0',)
#features for I1
I_blurred_5 = ndimage.gaussian_filter(I1, sigma=5)
X5 = I_blurred_5.flatten().T
X5 = X5.reshape(-1, 1)
I_blurred_10 = ndimage.gaussian_filter(I1, sigma=10)
X10 = I_blurred_10.flatten().T
X10 = X10.reshape(-1, 1)
I_blurred_15 = ndimage.gaussian_filter(I1, sigma=0)
X15 = I_blurred_15.flatten().T
X15 = X15.reshape(-1, 1)
#features for I2
I2_blurred = ndimage.gaussian_filter(I2, sigma=4)
X22 = I2_blurred.flatten().T
X22 = X22.reshape(-1, 1)
I_blurred_5_2 = ndimage.gaussian_filter(I2, sigma=5)
X5_2 = I_blurred_5_2.flatten().T
X5_2 = X5_2.reshape(-1, 1)
I_blurred_10_2 = ndimage.gaussian_filter(I2, sigma=10)
X10_2 = I_blurred_10_2.flatten().T
X10_2 = X10_2.reshape(-1, 1)
I_blurred_15_2 = ndimage.gaussian_filter(I2, sigma=0)
X15_2 = I_blurred_15_2.flatten().T
X15_2 = X15_2.reshape(-1, 1)
# X_data_all = np.concatenate((X1, X12, X5, X10, X15,
# X2, X22, X5_2, X10_2, X15_2), axis=1)
X_data_all = np.concatenate((X1, X2), axis=1)
util.scatter_data(X_data_all,Y,0,1) #X1 and X2
#------------------------------------------------------------------#
return X_data, Y
def logistic_regression():
# dataset preparation
num_training_samples = 300
num_validation_samples = 100
# here we reuse the function from the segmentation practicals
m1 = [2, 3]
m2 = [-0, -4]
s1 = [[8, 7], [7, 8]]
s2 = [[8, 6], [6, 8]]
[trainingX,
trainingY] = seg.generate_gaussian_data(num_training_samples, m1, m2, s1,
s2)
r, c = trainingX.shape
print('Training sample shape: {}'.format(trainingX.shape))
# we need a validation set to monitor for overfitting
[validationX,
validationY] = seg.generate_gaussian_data(num_validation_samples, m1, m2,
s1, s2)
r_val, c_val = validationX.shape
print('Validation sample shape: {}'.format(validationX.shape))
validationXones = util.addones(validationX)
# train a logistic regression model:
# the learning rate for the gradient descent method
# (the same as in intensity-based registration)
mu = 0.001
# we are actually using stochastic gradient descent
batch_size = 30
# initialize the parameters of the model with small random values,
# we need one parameter for each feature and a bias
Theta = 0.02 * np.random.rand(c + 1, 1)
# number of gradient descent iterations
num_iterations = 300
# variables to keep the loss and gradient at every iteration
# (needed for visualization)
iters = np.arange(num_iterations)
loss = np.full(iters.shape, np.nan)
validation_loss = np.full(iters.shape, np.nan)
# Create base figure
fig = plt.figure(figsize=(15, 8))
ax1 = fig.add_subplot(121)
im1, Xh_ones, num_range_points = util.plot_lr(trainingX, trainingY, Theta,
ax1)
seg_util.scatter_data(trainingX, trainingY, ax=ax1)
ax1.grid()
ax1.set_xlabel('x_1')
ax1.set_ylabel('x_2')
ax1.legend()
ax1.set_title('Training set')
text_str1 = '{:.4f}; {:.4f}; {:.4f}'.format(0, 0, 0)
txt1 = ax1.text(0.3,
0.95,
text_str1,
bbox={
'facecolor': 'white',
'alpha': 1,
'pad': 10
},
transform=ax1.transAxes)
ax2 = fig.add_subplot(122)
ax2.set_xlabel('Iteration')
ax2.set_ylabel('Loss (average per sample)')
ax2.set_title('mu = ' + str(mu))
h1, = ax2.plot(iters, loss, linewidth=2, label='Training loss')
h2, = ax2.plot(iters,
validation_loss,
linewidth=2,
label='Validation loss')
ax2.set_ylim(0, 0.7)
ax2.set_xlim(0, num_iterations)
ax2.grid()
ax1.legend()
text_str2 = 'iter.: {}, loss: {:.3f}, val. loss: {:.3f}'.format(0, 0, 0)
txt2 = ax2.text(0.3,
0.95,
text_str2,
bbox={
'facecolor': 'white',
'alpha': 1,
'pad': 10
},
transform=ax2.transAxes)
# iterate
for k in np.arange(num_iterations):
# pick a batch at random
idx = np.random.randint(r, size=batch_size)
# the loss function for this particular batch
loss_fun = lambda Theta: cad.lr_nll(util.addones(trainingX[idx, :]),
trainingY[idx], Theta)
# gradient descent:
# here we reuse the code for numerical computation of the gradient
# of a function
Theta = Theta - mu * reg.ngradient(loss_fun, Theta)
# compute the loss for the current model parameters for the
# training and validation sets
# note that the loss is divided with the number of samples so
# it is comparable for different number of samples
loss[k] = loss_fun(Theta) / batch_size
validation_loss[k] = cad.lr_nll(validationXones, validationY,
Theta) / r_val
# upldate the visualization
ph = cad.sigmoid(Xh_ones.dot(Theta)) > 0.5
decision_map = ph.reshape(num_range_points, num_range_points)
decision_map_trns = np.flipud(decision_map)
im1.set_data(decision_map_trns)
text_str1 = '{:.4f}; {:.4f}; {:.4f}'.format(Theta[0, 0], Theta[1, 0],
Theta[2, 0])
txt1.set_text(text_str1)
h1.set_ydata(loss)
h2.set_ydata(validation_loss)
text_str2 = 'iter.={}, loss={:.3f}, val. loss={:.3f} '.format(
k, loss[k], validation_loss[k])
txt2.set_text(text_str2)
display(fig)
clear_output(wait=True)
def segmentation_demo():
#only SECTION 2 is needed for what we want to do
train_subject = 1
test_subject = 2
train_slice = 1
test_slice = 1
task = 'tissue'
#SECTION 1 (this seciton has nothing to do with SECTION 2)
#Load data from a train and testsubject
train_data, train_labels, train_feature_labels = util.create_dataset(
train_subject, train_slice, task)
test_data, test_labels, test_feature_labels = util.create_dataset(
test_subject, test_slice, task)
util.scatter_data(train_data, train_labels, 0, 6)
util.scatter_data(test_data, test_labels, 0, 6)
predicted_labels = seg.segmentation_atlas(None, train_labels, None)
err = util.classification_error(test_labels, predicted_labels)
dice = util.dice_overlap(test_labels, predicted_labels)
#Display results
true_mask = test_labels.reshape(240, 240)
predicted_mask = predicted_labels.reshape(240, 240)
fig = plt.figure(figsize=(8, 8))
ax1 = fig.add_subplot(111)
ax1.imshow(true_mask, 'gray')
ax1.imshow(predicted_mask, 'viridis', alpha=0.5)
print('Subject {}, slice {}.\nErr {}, dice {}'.format(
test_subject, test_slice, err, dice))
## SECTION 2:Compare methods
num_images = 5
num_methods = 3
im_size = [240, 240]
all_errors = np.empty([num_images, num_methods])
all_errors[:] = np.nan
all_dice = np.empty([num_images, num_methods])
all_dice[:] = np.nan
all_subjects = np.arange(5) #list of all subjects [0, 1, 2, 3, 4]
train_slice = 2
task = 'tissue'
all_data_matrix = np.empty(
[train_data.shape[0], train_data.shape[1], num_images])
all_labels_matrix = np.empty([train_labels.size, num_images])
#Load datasets once
print('Loading data for ' + str(num_images) + ' subjects...')
for i in all_subjects:
sub = i + 1
train_data, train_labels, train_feature_labels = util.create_dataset(
sub, train_slice, task)
all_data_matrix[:, :, i] = train_data
all_labels_matrix[:, i] = train_labels.flatten()
print('Finished loading data.\nStarting segmentation...')
#Go through each subject, taking i-th subject as the test
for i in all_subjects:
sub = i + 1
#Define training subjects as all, except the test subject
train_subjects = all_subjects.copy()
train_subjects = np.delete(train_subjects, i)
train_data_matrix = all_data_matrix[:, :, train_subjects]
train_labels_matrix = all_labels_matrix[:, train_subjects]
test_data = all_data_matrix[:, :, i]
test_labels = all_labels_matrix[:, i]
test_shape_1 = test_labels.reshape(im_size[0], im_size[1])
fig = plt.figure(figsize=(15, 5))
predicted_labels, predicted_labels2 = seg.segmentation_combined_atlas(
train_labels_matrix)
all_errors[i, 0] = util.classification_error(test_labels,
predicted_labels2)
all_dice[i, 0] = util.dice_multiclass(test_labels, predicted_labels2)
predicted_mask_1 = predicted_labels2.reshape(im_size[0], im_size[1])
ax1 = fig.add_subplot(131)
ax1.imshow(test_shape_1, 'gray')
ax1.imshow(predicted_mask_1, 'viridis', alpha=0.5)
text_str = 'Err {:.4f}, dice {:.4f}'.format(all_errors[i, 0],
all_dice[i, 0])
ax1.set_xlabel(text_str)
ax1.set_title('Subject {}: Combined atlas'.format(sub))
predicted_labels, predicted_labels2 = seg.segmentation_combined_knn(
train_data_matrix, train_labels_matrix, test_data)
all_errors[i, 1] = util.classification_error(test_labels,
predicted_labels2)
all_dice[i, 1] = util.dice_multiclass(test_labels, predicted_labels2)
predicted_mask_2 = predicted_labels2.reshape(im_size[0], im_size[1])
ax2 = fig.add_subplot(132)
ax2.imshow(test_shape_1, 'gray')
ax2.imshow(predicted_mask_2, 'viridis', alpha=0.5)
text_str = 'Err {:.4f}, dice {:.4f}'.format(all_errors[i, 1],
all_dice[i, 1])
ax2.set_xlabel(text_str)
ax2.set_title('Subject {}: Combined k-NN'.format(sub))
#OUR METHOD
#predict the labels using our method
predicted_labels_mymethod = segmentation_mymethod(train_data_matrix,
train_labels_matrix,
test_data,
num_iter=100,
mu=0.1)
#determine error and dice (multiclass, since there are more classes)
all_errors[i,
2] = util.classification_error(test_labels,
predicted_labels_mymethod)
all_dice[i, 2] = util.dice_multiclass(test_labels,
predicted_labels_mymethod)
#reshape the predicted labels in order to plot the results
predicted_mask_3 = predicted_labels_mymethod.reshape(
im_size[0], im_size[1])
#plot the predicted image over the real image
plt.imshow(predicted_mask_3, 'viridis')
ax3 = fig.add_subplot(133)
ax3.imshow(test_shape_1, 'gray')
ax3.imshow(predicted_mask_3, 'viridis', alpha=0.5)
text_str = 'Err {:.4f}, dice {:.4f}'.format(all_errors[i, 2],
all_dice[i, 2])
ax3.set_xlabel(text_str)
ax3.set_title('Subject {}: My method'.format(sub))
#save the figure after every loop (3 subimages/plots)
fig.savefig("Results for test subject {}".format(sub), )
def kmeans(X, labels, num_iter, mu=0.1):
# X,_ = seg.normalize_data(X)
N, M = X.shape
#Define number of clusters we want
clusters = 4
# Cost function used by k-Means
# fun = lambda w: seg.cost_kmeans(X,w)
fun = funX(X)
## Algorithm
#Initialize cluster centers
idx = np.random.randint(N, size=clusters)
initial_w = X[idx, :]
w_draw = initial_w
print(w_draw)
#Reshape into vector (needed by ngradient)
w_vector = initial_w.reshape(clusters * M, 1)
#Vector to store cost
xx = np.linspace(1, num_iter, num_iter)
kmeans_cost = np.empty(*xx.shape)
kmeans_cost[:] = np.nan
fig = plt.figure(figsize=(14, 6))
ax1 = fig.add_subplot(121)
util.scatter_data(X, labels, ax=ax1)
line1, = ax1.plot(w_draw[:, 0],
w_draw[:, 1],
"k*",
markersize=10,
label='W-vector')
# im3 = ax1.scatter(w_draw[:,0], w_draw[:,1])
ax1.grid()
ax2 = fig.add_subplot(122, xlim=(0, num_iter), ylim=(0, 10))
text_str = 'k={}, g={:.2f}\ncost={:.2f}'.format(0, 0, 0)
txt2 = ax2.text(0.3,
0.95,
text_str,
bbox={
'facecolor': 'green',
'alpha': 0.4,
'pad': 10
},
transform=ax2.transAxes)
# xx = xx.reshape(1,-1)
line2, = ax2.plot(xx, kmeans_cost, lw=2)
ax2.set_xlabel('Iteration')
ax2.set_ylabel('Cost')
ax2.grid()
for k in np.arange(num_iter):
# gradient ascent
g = util.ngradient(fun, w_vector)
w_vector = w_vector - mu * g.T
# calculate cost for plotting
kmeans_cost[k] = fun(w_vector)
text_str = 'k={}, cost={:.2f}'.format(k, kmeans_cost[k])
txt2.set_text(text_str)
# plot
line2.set_ydata(kmeans_cost)
w_draw_new = w_vector.reshape(clusters, M)
line1.set_data(w_draw_new[:, 0], w_draw_new[:, 1])
# display(fig)
clear_output(wait=True)
plt.pause(.005)
display(fig)
# TODO: Find distance of each point to each cluster center
# Then find the minimum distances min_dist and indices min_index
w_final = w_vector.reshape(clusters, M)
D = scipy.spatial.distance.cdist(
X, w_final, metric='euclidean') #distances between X and C
min_index = np.argmin(D, axis=1)
min_dist = np.zeros((len(min_index), 1))
for i in range(len(min_index)):
min_dist[i, 0] = D.item((i, min_index[i]))
# Sort by intensity of cluster center
sorted_order = np.argsort(w_final[:, 0], axis=0)
# Update the cluster indices based on the sorted order and return results in
# predicted_labels
predicted_labels = np.empty(*min_index.shape)
predicted_labels[:] = np.nan
for i in np.arange(len(sorted_order)):
predicted_labels[min_index == sorted_order[i]] = i
return kmeans_cost, predicted_labels, w_final
Theta = 0.02*np.random.rand(c+1, 1)
# number of gradient descent iterations
num_iterations = 300
# variables to keep the loss and gradient at every iteration
# (needed for visualization)
iters = np.arange(num_iterations)
loss = np.full(iters.shape, np.nan)
validation_loss = np.full(iters.shape, np.nan)
# Create base figure
fig = plt.figure(figsize=(15,8))
ax1 = fig.add_subplot(121)
im1, Xh_ones, num_range_points = util.plot_lr(trainingX, trainingY, Theta, ax1)
seg_util.scatter_data(trainingX, trainingY, ax=ax1)
ax1.grid()
ax1.set_xlabel('x_1')
ax1.set_ylabel('x_2')
ax1.legend()
ax1.set_title('Training set')
text_str1 = '{:.4f}; {:.4f}; {:.4f}'.format(0, 0, 0)
txt1 = ax1.text(0.3, 0.95, text_str1, bbox={'facecolor': 'white', 'alpha': 1, 'pad': 10}, transform=ax1.transAxes)
ax2 = fig.add_subplot(122)
ax2.set_xlabel('Iteration')
ax2.set_ylabel('Loss (average per sample)')
ax2.set_title('mu = '+str(mu))
h1, = ax2.plot(iters, loss, linewidth=2, label='Training loss')
h2, = ax2.plot(iters, validation_loss, linewidth=2, label='Validation loss')
ax2.set_ylim(0, 0.7)
