Example #1
0
def preparePatches(pad, pxCount):
    """
    generates pixel patches for each of the pixels in each of the images already read
    :param pad: determines the size of the pixel patch, where patch width=((2*pad)+1)
    :param pxCount: the number of pixels to use per image when training and testing
    """
    
    train_input_patches[:]=[]
    train_labels_pixels[:]=[]
    test_input_patches[:]=[]
    test_labels_pixels[:]=[]
    #creates pixel patches for training set
    for i in range(len(train_input)):
        for j in range(pxCount):
            x=random.randint(0,1023)
            y=random.randint(0,1023)
            train_labels_pixels.append(train_labels[i][x][y])
            train_input[i]=border.createBorder(pad,train_input[i])
            ppatch=border.pixelPatch(pad, train_input[i],x,y).flatten()
            #ppatch=test.noisyPatch(5,train_labels[i],x,y).flatten() #creates patches with random noise isntead, for testing purposes
            train_input_patches.append(ppatch)
                  
    
    #creates pixel patches for test set
    for i in range(len(test_input)):
        for j in range(pxCount):
            x=random.randint(0,1023)
            y=random.randint(0,1023)
            test_labels_pixels.append(test_labels[i][x][y])
            test_input[i]=border.createBorder(pad,test_input[i])
            ppatch=border.pixelPatch(pad, test_input[i],x,y).flatten()
            #ppatch=test.noisyPatch(5,test_labels[i],x,y).flatten() #creates patches with random noise instead, for testing purposes
            test_input_patches.append(ppatch)
def sortClasses(pad, num_points, data, seed=None, equalClasses=True):
    """
    sorts the data into an equal number of white and black pixels
    :param pad: defines the pixel patch size, where the side length = 2*pad+1
    :param num_points: defines the number of points to use per image
    :param data: is the list of [input images, label images]
    :param seed: defines the seed to use for the random number generator
    :return: a list of [pixel patch data matrix, label points]
    """
    if not seed == None:
        random.seed(seed)
    input = data[0]
    label = data[1]
    merged_input=np.zeros(shape=((num_points)*len(input),(2*pad+1)**2))
    merged_label=np.zeros(shape=((num_points)*len(input)))
    x=0
    if equalClasses:
        for img in range(len(input)):
            membrane_indices = np.nonzero(label[img])
            nonmembrane_indices = np.nonzero(255-label[img])
            bordered=border.createBorder(pad, input[img])
            white=True
            
            for i in range(num_points):
                if white:
                    randindex=random.randint(0,len(membrane_indices[0])-1)
                    merged_input[x]=(border.pixelPatch(pad, bordered, membrane_indices[0][randindex], membrane_indices[1][randindex]).flatten())
                    merged_label[x]=(label[img][membrane_indices[0][randindex]][membrane_indices[1][randindex]])
                elif not white:
                    randindex=random.randint(0,len(nonmembrane_indices[0])-1)
                    merged_input[x]=(border.pixelPatch(pad, bordered, nonmembrane_indices[0][randindex], nonmembrane_indices[1][randindex]).flatten())
                    merged_label[x]=(label[img][nonmembrane_indices[0][randindex]][nonmembrane_indices[1][randindex]]) 
                white = not white
                x+=1
    else:
        for img in range(len(input)):
            bordered=border.createBorder(pad, input[img])
            for i in range(num_points):
                randx=random.randint(0,len(input[img])-255)
                randy=random.randint(0,len(input[img][0])-255)
                merged_input[x]=border.pixelPatch(pad,bordered,randx,randy).flatten()
                merged_label[x]=label[img][randx][randy]
                x+=1
    return merged_input, merged_label
import knn_trainer_helper
import sklearn.neighbors
from sklearn.neighbors import LSHForest
import time
import border
import matplotlib.pyplot as plt
import mahotas
import numpy as np
from scipy import stats
side = 1024
start = time.time()
k=25
pad=4
numpoints=50
input_img = np.float16(mahotas.imread('input/test/0.tif'))
input_bordered = border.createBorder(pad,input_img)
#input = border.outputMatrix(pad,input_img)
train_data=knn_trainer_helper.sortClasses(pad,numpoints,knn_trainer_helper.readImages(209,'input/train/','labels/train/'),seed=42)
t1 = time.time()
print 'init took '+str(t1-start)
lshf = LSHForest(n_estimators=20, n_candidates=200, n_neighbors=k,random_state=1).fit(train_data[0])
t2 = time.time()
print 'fit took '+str(t2-t1)
full_predicted=[]
for i in range(1024):
    predict_start=time.time()
    input = border.matrixRow(pad,input_bordered,i)
    approx_neighbors = lshf.kneighbors(input, return_distance=False)

    y_hat=[]
    for query in approx_neighbors:
Example #4
0
pad=10

#generates 100 random pixel coordinates to use from each image when testing/training/validating
for i in range(100):
    x_coord.append(random.randint(0,1023))
    y_coord.append(random.randint(0,1023))

for i in range(209):
    train_input.append(mahotas.imread("input/train/"+str(i)+".tif"))
    train_labels.append(mahotas.imread("labels/train/"+str(i)+".tif"))

#creates pixel patches for training set
for i in range(len(train_input)):
    for j in range(len(x_coord)):
        train_labels_pixels.append(train_labels[i][x_coord[j]][y_coord[j]])
        train_input[i]=border.createBorder(pad,train_input[i])
        ppatch=border.pixelPatch(pad, train_input[i], x_coord[j], y_coord[j]).flatten()
        train_input_patches.append(ppatch)
              
print 1
knn = sklearn.neighbors.KNeighborsClassifier(n_neighbors=k, weights='uniform')
print 2     
#fit the data
knn.fit(train_input_patches, train_labels_pixels)
print 3
img_patches=border.outputMatrix(pad, img)
print 4
predicted_img_flat = knn.predict(img_patches)
print 5
predicted_img = np.zeros(shape=(1024,1024), dtype=np.double)
print 6