def write_images_to_tensorboard(inputs, outputs, global_step, step=False, best=False): # Add images to tensorboard # Current autoencoder fit grid1 = torchvision.utils.make_grid(torch.cat(( inputs.cpu(), outputs.cpu())), nrow=args.batch_size) # Current quality of generated random images sample_size = 4 * args.batch_size sample = torch.randn(sample_size, args.latent_dim).to(args.device) decoded_sample = args.net.decode(sample).cpu() # print images grid2 = torchvision.utils.make_grid(decoded_sample, nrow=args.batch_size) if step: args.writer.add_image('Train/fit', grid1, global_step) args.writer.add_image('Train/generated', grid2, global_step) elif best: args.writer.add_image('Best/fit', grid1, global_step) args.writer.add_image('Best/generated', grid2, global_step) else: args.writer.add_image('encoder-fit', grid1) args.writer.add_image('latent-random-sample-decoded', grid2) imshow(grid1) imshow(grid2)
def plot_latent_space(dataiter, images, labels): # Plot mesh grid from latent space numImgs = 30 lo, hi = -3., 3. # Define mesh grid ticks z1 = torch.linspace(lo, hi, numImgs) z2 = torch.linspace(lo, hi, numImgs) # Create mesh as pair of elements z = [] for idx in range(numImgs): for jdx in range(numImgs): z.append([z1[idx], z2[jdx]]) z = torch.tensor(z).to(args.device) # Decode elements from latent space decoded_z = args.net.decode(z).cpu() # print images grid = torchvision.utils.make_grid(decoded_z, nrow=numImgs) imshow(grid) args.writer.add_image('latent-space-grid-decoded', grid) # Plot encoded test set into latent space numBatches = 500 for idx in range(numBatches): tImages, tLabels = dataiter.next() images = torch.cat((images.cpu(), tImages.cpu()), 0) labels = torch.cat((labels.cpu(), tLabels.cpu()), 0) # encode into latent space images = images.cpu() encoded_images_loc, _ = args.net.cpu().encode(images) encoded_images_loc = encoded_images_loc.cpu().detach().numpy() # Scatter plot of latent space x = encoded_images_loc[:, 0] y = encoded_images_loc[:, 1] # Send to tensorboard fig = plt.figure(figsize=(12, 10)) ax = fig.add_subplot(1, 1, 1) sct = ax.scatter(x, y, c=labels, cmap='jet') fig.colorbar(sct) args.writer.add_figure('scatter-plot-of-encoded-test-sample', fig) # Plot with matplotlib plt.figure(figsize=(12, 10)) plt.scatter(x, y, c=labels, cmap='jet') plt.colorbar() filename = "imgs/test_into_latent_space_{}.png".format(numBatches) plt.savefig(filename) plt.show()
parser = ArgumentParser( description='Calculates the background levels for a set of images') parser.add_argument('--in', required=True, dest='infiles', nargs='+', help='Images used to set thresholds') parser.add_argument('--out', default='bg.png', help='Output file name') parser.add_argument( "--conv_len", type=int, default=0, help='Distance to which pixels are included in averaging') parser.add_argument('--show', action='store_true', help='Display resulting threshold image') parser.add_argument('--bg_img', type=int, help='Limits number of images to be processed') parser.add_argument('--clear_hotpix', action='store_true', help='If convolved, raise hot pixel thresholds to 256') args = parser.parse_args() bg = find_bg(args.infiles, args.out, args.conv_len, args.bg_img, args.clear_hotpix) if args.show: import imshow imshow.imshow(args.out)
key = roi.toSlice() self.outputs["Output"].setDirty(key) from lazyflow import operators # create graph g = Graph() # construct image reader reader = operators.OpImageReader(graph=g) reader.inputs["Filename"].setValue("ostrich.jpg") # create Shifter_Operator with Graph-Objekt as argument shifter = OpArrayShifter1(graph=g) # connect Shifter-Input with Image Reader Output # because the Operator has only one Input Slot in this example, # the "setupOutputs" method is executed shifter.inputs["Input"].connect(reader.outputs["Image"]) # shifter.outputs["Output"][:]returns an "GetItemWriterObject" object. # its method "allocate" will be executed, this method call the "writeInto" # method which calls the "fireRequest" method of the, in this case, # "OutputSlot" object which calls another method in "OutputSlot and finally # the "execute" method of our operator. # The wait() function blocks other activities and waits till the results # of the requested Slot are calculated and stored in the result area. result = shifter.outputs["Output"][:].allocate().wait() # display the result imshow(result)
def main(): if len(sys.argv) > 5: # Get console parameters train_percentage = float(sys.argv[1]) train_batch = int(sys.argv[2]) test_batch = int(sys.argv[3]) dist_mean = float(sys.argv[4]) dist_sd = float(sys.argv[5]) else: print("Not enough parameters") return # Printing parameters torch.set_printoptions(precision=10) torch.set_printoptions(edgeitems=32) # Set up GPU device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # Assuming that we are on a CUDA machine, this should print a CUDA device: print("Device : ", device) # Load dataset full_dataset = datasets.MNISTSegmentationDataset(dist_mean, dist_sd) # Divide into Train and Test train_size = int(train_percentage * len(full_dataset)) test_size = len(full_dataset) - train_size train_dataset, test_dataset = torch.utils.data.random_split( full_dataset, [train_size, test_size]) # Dataset information print("train_dataset : ", len(train_dataset)) print("test_dataset : ", len(test_dataset)) # Create dataset loaders trainloader = torch.utils.data.DataLoader(train_dataset, batch_size=train_batch, shuffle=True, num_workers=0) testloader = torch.utils.data.DataLoader(test_dataset, batch_size=test_batch, shuffle=True, num_workers=0) # Show sample of images # get some random training images dataiter = iter(trainloader) images, labels = dataiter.next() # # show images imshow( torchvision.utils.make_grid(torch.cat((images, labels)), nrow=train_batch)) # Create network net = Net() net.to(device) print(net) # Define loss function and optimizer criterion = nn.L1Loss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) # Train network for epoch in range(2): # loop over the dataset multiple times running_loss = 0.0 for i, data in enumerate(trainloader, 0): # get the inputs; data is a list of [inputs, labels] inputs, labels = data # Crop segmentation map # labels = labels#[:,:,8:-8,8:-8] if torch.cuda.is_available(): inputs = inputs.cuda() labels = labels.cuda() # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs = net(inputs) # cprint(outputs.size(),inputs.size(),labels.size()) loss = criterion(outputs, labels) loss.backward() optimizer.step() # print statistics running_loss += loss.item() if i % 2000 == 1999: # print every 2000 mini-batches print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 2000)) running_loss = 0.0 print('Finished Training') # Test network and predict dataiter = iter(testloader) images, labels = dataiter.next() if torch.cuda.is_available(): images_cuda = images.cuda() labels_cuda = labels.cuda() # print images imshow( torchvision.utils.make_grid(torch.cat((images, labels)), nrow=test_batch)) outputs = net(images_cuda) #images = images#[:,:,8:-8,8:-8] #labels = labels#[:,:,8:-8,8:-8] predicted = ((outputs > .5).type(torch.float) - .5) * 2 predicted_cpu = predicted.cpu() #print(images.size(),labels.size(),predicted_cpu.size()) imshow( torchvision.utils.make_grid(torch.cat((images, labels, predicted_cpu)), nrow=test_batch)) # Calculate network accuracy on Test dataset correct = 0 total = 0 with torch.no_grad(): for data in testloader: images, labels = data if torch.cuda.is_available(): images_cuda = images.cuda() labels_cuda = labels.cuda() outputs = net(images_cuda) #images = images#[:,:,8:-8,8:-8] #labels = labels#[:,:,8:-8,8:-8] predicted = ((outputs > .5).type(torch.float) - .5) * 2 predicted_cpu = predicted.cpu() # print(images.size(),labels.size(),predicted.size()) # print(predicted) # print(labels) # print("total : ",labels.size(0) * labels.size(1) * labels.size(2) * labels.size(3)) # print("correct : ",(predicted.type(torch.long) == labels_cuda.type(torch.long)).sum().item()) # print("label lit : ", (labels == 1).sum().item()) # print("predicted lit : ", (predicted == 1).sum().item()) # imshow(torchvision.utils.make_grid(torch.cat((images,labels,predicted_cpu)),nrow = test_batch)) correct += (predicted.type(torch.long) == labels_cuda.type( torch.long)).sum().item() total += labels.size(0) * labels.size(1) * labels.size( 2) * labels.size(3) print('Accuracy of the network on the %d test images: %d %%' % (len(test_dataset), 100 * correct / total))
def train(trainset): # Split dataset train_size = int(args.train_percentage * len(trainset)) test_size = len(trainset) - train_size train_dataset, test_dataset \ = torch.utils.data.random_split(trainset, [train_size, test_size]) # Dataset information print('train dataset : {} elements'.format(len(train_dataset))) # Create dataset loader train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True) # Show sample of images if args.plot: # get some random training images dataiter = iter(train_loader) images, _ = dataiter.next() grid = torchvision.utils.make_grid(images) imshow(grid) args.writer.add_image('sample-train', grid) # Define optimizer if args.optimizer == 'adam': optimizer = optim.Adam(args.net.parameters(), lr=1e-3) elif args.optimizer == 'sgd': optimizer = optim.SGD(args.net.parameters(), lr=0.01, momentum=0.9) elif args.optimizer == 'rmsprop': optimizer = optim.RMSprop(args.net.parameters(), lr=0.01) # Loss function criterion = elbo_loss_function # Set best for minimization best = float('inf') print('Started Training') # loop over the dataset multiple times for epoch in range(args.epochs): # reset running loss statistics train_loss = mse_loss = running_loss = 0.0 for batch_idx, data in enumerate(train_loader, 1): # get the inputs; data is a list of [inputs, labels] inputs, _ = data inputs = inputs.to(args.device) with autograd.detect_anomaly(): # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs, mu, logvar = args.net(inputs) loss = criterion(outputs, inputs, mu, logvar) loss.backward() optimizer.step() # update running loss statistics train_loss += loss.item() running_loss += loss.item() mse_loss += F.mse_loss(outputs, inputs) # Global step global_step = batch_idx + len(train_loader) * epoch # Write tensorboard statistics args.writer.add_scalar('Train/loss', loss.item(), global_step) args.writer.add_scalar('Train/mse', F.mse_loss(outputs, inputs), global_step) # check if current batch had best fitness if loss.item() < best: best = loss.item() update_best(inputs, outputs, loss, global_step) # print every args.log_interval of batches if batch_idx % args.log_interval == 0: print("Train Epoch : {} Batches : {} " "[{}/{} ({:.0f}%)]\tLoss : {:.6f}" "\tError : {:.6f}" .format(epoch, batch_idx, args.batch_size * batch_idx, len(train_loader.dataset), 100. * batch_idx / len(train_loader), running_loss / args.log_interval, mse_loss / args.log_interval)) mse_loss = running_loss = 0.0 # Add images to tensorboard write_images_to_tensorboard(inputs, outputs, global_step, step=True) print('====> Epoch: {} Average loss: {:.4f}'.format( epoch, train_loss / len(train_loader))) # Add trained model args.writer.close() print('Finished Training')
def main(): if len(sys.argv) > 5: # Get console parameters train_percentage = float(sys.argv[1]) train_batch = int(sys.argv[2]) test_batch = int(sys.argv[3]) number_of_epochs = int(sys.argv[4]) number_of_mini_batches = int(sys.argv[5]) else: print("Not enough parameters") return # Printing parameters torch.set_printoptions(precision=10) torch.set_printoptions(edgeitems=32) # Set up GPU device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # Assuming that we are on a CUDA machine, this should print a CUDA device: print("Device : ", device) # Load dataset full_dataset = datasets.ISBI2012DatasetTrain('./dataset/train-volume.tif', './dataset/train-labels.tif') submit_dataset = datasets.ISBI2012DatasetTest('./dataset/test-volume.tif') # Divide into Train and Test train_size = int(train_percentage * len(full_dataset)) test_size = len(full_dataset) - train_size train_dataset, test_dataset \ = torch.utils.data.random_split(full_dataset, [train_size, test_size]) # Test with full dataset test_dataset = full_dataset # Dataset information print("train_dataset : ", len(train_dataset)) print("test_dataset : ", len(test_dataset)) # Create dataset loaders trainloader = torch.utils.data.DataLoader(train_dataset, batch_size=train_batch, shuffle=True, num_workers=0) testloader = torch.utils.data.DataLoader(test_dataset, batch_size=test_batch, shuffle=True, num_workers=0) submitloader = torch.utils.data.DataLoader(submit_dataset, batch_size=train_batch, shuffle=False, num_workers=0) # Show sample of images # get some random training images dataiter = iter(trainloader) images, labels = dataiter.next() # show images imshow( torchvision.utils.make_grid(torch.cat((images, labels)), nrow=train_batch)) print('Started Training') # Create network net = UNet() net.to(device) # print(net) # Define loss function and optimizer loss_history = [] criterion = nn.L1Loss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) # Train network - loop over the dataset multiple times for epoch in range(number_of_epochs): running_loss = 0.0 for i, data in enumerate(trainloader, 0): # get the inputs; data is a list of [inputs, labels] inputs, labels = data if torch.cuda.is_available(): inputs = inputs.cuda() labels = labels.cuda() # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() # print statistics running_loss += loss.item() # print every number_of_mini_batches if i % number_of_mini_batches == number_of_mini_batches - 1: print( '[%d, %5d] loss: %.8f' % (epoch + 1, i + 1, running_loss / number_of_mini_batches)) loss_history.append(running_loss / number_of_mini_batches) running_loss = 0.0 print('Finished Training') # Test network and predict dataiter = iter(testloader) images, labels = dataiter.next() if torch.cuda.is_available(): images_cuda = images.cuda() labels_cuda = labels.cuda() # print images imshow( torchvision.utils.make_grid(torch.cat((images, labels)), nrow=test_batch)) outputs = net(images_cuda) predicted = ((outputs > .5).type(torch.float) - .5) * 2 predicted_cpu = predicted.cpu() imshow( torchvision.utils.make_grid(torch.cat((images, labels, predicted_cpu)), nrow=test_batch)) # Print loss over time plt.plot(range(1, number_of_epochs + 1), loss_history) plt.xlabel("Epochs") plt.ylabel("Loss") plt.show() # Calculate network accuracy on Test dataset correct = 0 total = 0 with torch.no_grad(): for data in testloader: images, labels = data if torch.cuda.is_available(): images_cuda = images.cuda() labels_cuda = labels.cuda() outputs = net(images_cuda) else: outputs = net(images) predicted = ((outputs > .5).type(torch.float) - .5) * 2 predicted_cpu = predicted.cpu() correct += (predicted.type(torch.long) == labels_cuda.type( torch.long)).sum().item() total += labels.size(0) \ * labels.size(1) \ * labels.size(2) \ * labels.size(3) \ print('Accuracy of the network on the %d test images: %d %%' % (len(test_dataset), 100 * correct / total))
# result = req.notify(callback) # # The callback function that you have to provide receives # as first argument the result array. (To learn more read # the documentation of the GetItemRequestObject) # # we will use a mere sychronous request for now: result = req.wait() # To visualize the result of our graph processing pipeline # we will use a small image viewer helper: imshow(result) # finally, we allso want to make sure that the noOp, which # is in fact an OpArrayPiper, does not change the image of # the image reader . # While doing so we will introduce you to the # call chaining syntax you may use when retrieving results # of operator outputs: result2 = reader.outputs["Image"][:].allocate().wait() # this combines all previous operations into # one line. imshow(result2)
def main(): classes, testloader, trainloader = set_dataset() # ランダムな訓練データを取得 dataiter = iter(trainloader) images, labels = dataiter.next() # 画像を表示 imshow(torchvision.utils.make_grid(images)) print(' '.join('%5s' % classes[labels[j]] for j in range(4))) net = Net() criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) for epoch in range(2): running_loss = 0.0 for i, data in enumerate(trainloader, 0): inputs, labels = data optimizer.zero_grad() outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() if i % 2000 == 1999: print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 2000)) running_loss = 0.0 print('Finished Training') PATH = './cifar_net.pth' torch.save(net.state_dict(), PATH) dataiter = iter(testloader) images, labels = dataiter.next() imshow(torchvision.utils.make_grid(images)) print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4))) net = Net() net.load_state_dict(torch.load(PATH)) outputs = net(images) _, predicted = torch.max(outputs, 1) print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4))) correct = 0 total = 0 with torch.no_grad(): for data in testloader: images, labels = data outputs = net(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total)) class_correct = list(0. for i in range(10)) class_total = list(0. for i in range(10)) with torch.no_grad(): for data in testloader: images, labels = data outputs = net(images) _, predicted = torch.max(outputs, 1) c = (predicted == labels).squeeze() for i in range(4): label = labels[i] class_correct[label] += c[i].item() class_total[label] += 1 for i in range(10): print('Accuracy of %5s : %2d %%' % ( classes[i], 100 * class_correct[i] / class_total[i])) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(device) net.to(device) inputs, labels = data[0].to(device), data[1].to(device)
warp_matrix, (sz[1], sz[0]), flags=cv2.INTER_LINEAR + cv2.WARP_INVERSE_MAP) result = cv2.warpAffine(result, warp_matrix, (sz[1], sz[0]), flags=cv2.INTER_LINEAR + cv2.WARP_INVERSE_MAP) # Show final results #imshow(im2_aligned[0],name="Aligned Image 2",showresult=True ) return (im2_aligned, result) if __name__ == '__main__': print("This file provides the function for aligning two images.") im1 = cv2.imread("D:\\footlongmodel2\\DSC_0536.jpg") im2 = cv2.imread("D:\\footlongmodel2\\DSC_0570.jpg") im3 = np.uint8(im1[600:1800, 3400:4000, 1]) im4 = np.uint8(im2[600:1800, 3400:4000, 1]) #im3 = np.uint8(im1[:,:,1]) #im4 = np.uint8(im2[:,:,1]) imshow(im3, name='im3', x=im3.shape[0], y=im3.shape[1]) imshow(im4, name='im4', x=im4.shape[0], y=im4.shape[1]) im5, res = alignImage(im3, im4, im4) im6, res = alignImage(im3, im4, im3)
def findOilBlob(filename, threshold=127, color='gray', iterations=[2, 8, 6], showresult=False): #filename = "test.jpg" print("Reading image : ", filename) imReference = cv2.imread(filename, cv2.IMREAD_COLOR) ''' # filter image imReference = cv2.bilateralFilter(imReference,5,40,40) ''' # convert to grayscale if color in ['blue', 'BLUE', 'Blue', 'B', 'b']: imgray = imReference[:, :, 0] elif color in ['green', 'GREEN', 'Green', 'G', 'g']: imgray = imReference[:, :, 1] elif color in ['red', 'RED', 'Red', 'R', 'r']: imgray = imReference[:, :, 2] else: imgray = cv2.cvtColor(imReference, cv2.COLOR_BGR2GRAY) imgrayorig = imgray.copy() #imgSPLIT = cv2.split(imReference); #imgray = imgSPLIT[1]; imshow(imgray, showresult, name='grayscale') # filter image imgray = cv2.bilateralFilter(imgray, 5, 40, 40) # cut image edges imReference = imReference[2:-2, 2:-2, :] # denoise imgray = cv2.fastNlMeansDenoising(imgray, None, 10, 7, 21) imshow(imgray, showresult, name='denoise') # threshold ret, thresh = cv2.threshold(imgray, threshold, 255, cv2.THRESH_OTSU) imshow(thresh, showresult, name='threshold') # erode and dilate kernel = np.ones((5, 5), np.uint8) erosion = cv2.erode(thresh, kernel, iterations=iterations[0]) dilation = cv2.dilate(erosion, kernel, iterations=iterations[1]) imshow(dilation, showresult, name='dilation') erosion = cv2.erode(dilation, kernel, iterations=iterations[2]) imshow(erosion, showresult, name='erosion') # get the contours ''' # The cv2.findContours() function removed the first output in a newer version. tmpim, contours, hierarchy = cv2.findContours(thresh, method=cv2.RETR_TREE, \ mode=cv2.CHAIN_APPROX_SIMPLE) ''' contours, hierarchy = cv2.findContours(erosion, method=cv2.RETR_TREE, \ mode=cv2.CHAIN_APPROX_SIMPLE) cv2.drawContours(imgray, contours, contourIdx = -1, color=(255,0,0), \ thickness=4) imshow(imgray, showresult, name='contours') # First, the real interfaces have a lot of points. # Abandon the contours with only several points. # Keep only the longest contour. contours = sorted(contours, key=len, reverse=True) contoursorig = np.copy(contours) contours = contours[0] return (imgray, contours, imgrayorig, contoursorig)
numcontourpoint = curvatureradius.shape[0] curvatureradiusplot = (curvatureradius[:, 2] - minradius) / (maxradius - minradius) * 256 Nx, Ny, __ = imorig.shape for lp1 in range(numcontourpoint): # coordinate index indy = int(oilcontour[lp1, 0]) indx = int(oilcontour[lp1, 1]) # color imorig[indx - dotsize:indx + dotsize + 1, indy - dotsize:indy + dotsize + 1, [0, 1]] = 0 imorig[indx - dotsize:indx + dotsize + 1, indy - dotsize:indy + dotsize + 1, 2] = curvatureradiusplot[lp1] imshow(imorig, showresult) savename = targetpath + '/' + ite[1] cv2.imwrite(savename, imorig) ''' count = count+1 if count > 5: break ''' print(maxradiustotal, minradiustotal) # plot the curvature radius of the last image plt.figure() plt.plot(curvatureradius[:, 2], 'sr-') # plot the color bar for the curvature radius