def predict_layer(net, layer, gpu): net.eval() samples = pp.make_patch(layer, resize=(128, 128), patch=5) patches = samples.shape[2] ret_samples = np.zeros_like(samples) for patch in range(patches): img = samples[:, :, patch] img = img[np.newaxis, np.newaxis, :, :] img = torch.from_numpy(img) img = img.float() if gpu: img = img.cuda(0) pass img = img.float() # 只有训练阶段才追踪历史 with torch.set_grad_enabled(False): output = net(img) _, preds = torch.max(output, 1) ret_samples[:, :, patch] = preds[0, :, :].cpu().numpy() # ut.plot_img(preds[0, :, :], mPath.DataPath_Volume_Predict + "output"+str(patch)+".jpg", 'Output', 2) pass pass # preds = ut.Merge_Patches(ret_samples, [512, 512], 5) preds = ut.Merge_Patches_And(ret_samples, [512, 512], 5) ut.save_img(preds, mPath.DataPath_Volume_Predict + "output.jpg") return preds
def predict_liverNii(net, nii, gpu, name): net.eval() nii = np.array(nii, dtype='float64') nii[nii < -200] = -200 nii[nii > 250] = 250 nii = ((nii + 200) / 450) layer = nii.shape[2] ut.CheckDirectory(mPath.DataPath_Volume_Predict + 'temp/') output_layer = np.zeros_like(nii) for i in range(layer): current_layer = np.flip(nii[:, :, i], 0) current_layer = np.rot90(current_layer) current_layer = np.rot90(current_layer) current_layer = np.rot90(current_layer) print("Predicting {}-{}".format(name, i)) temp = predict_liver(current_layer, gpu) temp = np.flip(temp, 0) temp = np.rot90(temp) temp = np.rot90(temp) temp = np.rot90(temp) output_layer[:, :, i] = temp output_layer = np.array(output_layer, dtype='uint8') new_img = nib.Nifti1Image(output_layer, affine=np.eye(4)) nib.save(new_img, mPath.DataPath_Volume_Predict + name + '.nii')
def predict_nii(net, nii, gpu, name): net.eval() nii = np.array(nii, dtype='float64') nii[nii < -200] = -200 nii[nii > 250] = 250 nii = ((nii + 200) * 255 // 450) nii = np.array(nii, dtype='uint8') layer = nii.shape[2] ut.CheckDirectory(mPath.DataPath_Volume_Predict + 'temp/') for i in range(layer): save(nii[:, :, i], mPath.DataPath_Volume_Predict + 'temp/' + str(i) + '.jpg') pass save_nii = np.zeros((512, 512, layer), dtype='float32') for i in range(layer): current_img = cv2.imread(mPath.DataPath_Volume_Predict + 'temp/' + str(i) + '.jpg')[:, :, 0] current_img = np.array(current_img, dtype='float64') current_img = current_img / 255 samples = predict_layer(net, current_img, gpu) samples = np.flip(samples, 0) samples = np.rot90(samples) samples = np.rot90(samples) samples = np.rot90(samples) save_nii[:, :, i] = samples print("Predicting {}-{}".format(name, i)) pass new_img = nib.Nifti1Image(save_nii, affine=np.eye(4)) nib.save(new_img, mPath.DataPath_Volume_Predict + name + '-.nii')
def predict_patch(net, img, gpu): net.eval() img = img[np.newaxis, np.newaxis, :, :] img = torch.from_numpy(img) img = img.float() if gpu: img = img.cuda() pass img = img.float() # 只有训练阶段才追踪历史 with torch.set_grad_enabled(False): output = net(img) _, preds = torch.max(output, 1) ut.plot_img(preds[0, :, :], mPath.DataPath_Volume_Predict + "output.jpg", 'Output', 2) pass pass
def predict_layer_multi(net, layer_input, gpu): net.eval() ret_samples = np.zeros( (layer_input.shape[0], layer_input.shape[1], layer_input.shape[3]), dtype='float64') for patch in range(layer_input.shape[3]): temp = layer_input[:, :, :, patch] input = np.zeros( (layer_input.shape[2], layer_input.shape[0], layer_input.shape[1])) for i in range(temp.shape[2]): input[i, :, :] = temp[:, :, i] pass # cv2.imshow('1', input[1, :, :]) # cv2.waitKey(0) input = input[np.newaxis, :, :, :] input = torch.from_numpy(input) input = input.type(torch.FloatTensor) if gpu: input = input.cuda(0) pass # 只有训练阶段才追踪历史 with torch.set_grad_enabled(False): output = net(input) _, preds = torch.max(output, 1) ret_samples[:, :, patch] = preds[0, :, :].cpu().numpy() # cv2.imshow('2', ret_samples[:,:,patch]) # cv2.waitKey(0) # ut.plot_img(preds[0, :, :], mPath.DataPath_Volume_Predict + "output"+str(patch)+".jpg", 'Output', 2) pass pass preds = ut.Merge_Patches_And(ret_samples, [512, 512], 5) preds[preds > 0] = 2 # cv2.imshow('2', preds*127) # cv2.waitKey(0) return preds
from Try import Utils as ut, mPath GPU_DEVICES = '0' os.environ["CUDA_VISIBLE_DEVICES"] = GPU_DEVICES Use_GPU = torch.cuda.is_available() Output_Class = 3 def predict_net(): pass if __name__ == '__main__': net = UNet(n_channels=1, n_classes=Output_Class) ut.CheckDirectory(mPath.DataPath_Net_CheckPoint) if Use_GPU: net.cuda() net.load_state_dict(torch.load(mPath.DataPath_Net_Normal)) pass else: net.load_state_dict( torch.load(mPath.DataPath_Net_Normal, map_location='cpu')) try: predict_net() train_net(net, lr=learning_rate, epochs=Train_Epochs, batch_size=Train_Batch_Size, val_percent=Validation_Percent,
import os import mPath from medpy.io import load, save import os.path import numpy as np import csv import cv2 import random from Try import Utils as ut ut.CheckDirectory(mPath.DataPath_Volume_Predict) def getRangImageDepth(image): """ :param image: :return:rangofimage depth """ fistflag = True startposition = 0 endposition = 0 for z in range(image.shape[2]): notzeroflag = np.max(image[:,:,z]) if notzeroflag and fistflag: startposition = z fistflag = False if notzeroflag: endposition = z return startposition, endposition
def train_net(net, epochs=5, batch_size=1, lr=0.01, val_percent=0.05, save_cp=True, gpu=True, classes=3): optimizer=optim.SGD(net.parameters(), lr=lr, momentum=0.9, weight_decay=0.0005) # optimizer=optim.adam(net.parameters(), # lr=lr, # momentum=0.9, # weight_decay=0.0005) # optimizer.zero_grad() # criterion=nn.BCELoss() criterion= Loss.MultclassDiceLoss() mTrain,mValid = LiTS_Data.split_to_train_val(mPath.CSVPath + "data.csv", Train_Mode,val_percent) mTrainDataset= LiTS_Data.Dataset_WithLiver(mTrain, Train_Mode,classes=classes,is_train=True,randomize=True) mValDataset= LiTS_Data.Dataset_WithLiver(mValid, Train_Mode, classes=classes,is_train=False,randomize=False) # mTrainDataset = LiTS_Data.Dataset_Liver(mTrain, is_train=True, randomize=True) # mValDataset = LiTS_Data.Dataset_Liver(mValid, is_train=False, randomize=False) mTrainDataloader=DataLoader(dataset=mTrainDataset,batch_size=batch_size,shuffle=True) modeList=[] if len(mValid)==0: modeList=['train'] else: mValDataloader = DataLoader(dataset=mValDataset, batch_size=batch_size, shuffle=True) modeList = ['train', 'val'] best_acc=0.0 batch_count=0 # Begin training iter_train=0 iter_val=0 for epoch in range(epochs): print() print() print('-' * 10) print("Starting epoch {}/{}".format(epoch+1,epochs)) adjust_learning_rate(optimizer,epoch) for phase in modeList: print() if(phase=='train'): net.train() dataset=mTrainDataloader dataLength=len(mTrainDataset) else: net.eval() dataset=mValDataloader dataLength = len(mValDataset) pass running_loss=0.0 running_corrects=0 running_dice=0.0 for index,sample in enumerate(dataset): batch_count=batch_count+1 img = sample['img'] mask = sample['mask'] if gpu: img = img.cuda() mask = mask.cuda() pass img = img.float() mask = mask.float() # 清空参数的梯度 optimizer.zero_grad() # 只有训练阶段才追踪历史 with torch.set_grad_enabled(phase == 'train'): output = net(img) _, preds = torch.max(output, 1) preds_onehot=torch.zeros_like(mask) for i in range(preds_onehot.shape[1]): preds_onehot[:,i,:,:]=preds==i pass # loss = criterion(output, mask) loss = criterion(output, mask,weights) if phase=='train': loss.backward() optimizer.step() pass # 记录loss和准确率 subloss=loss.item() subaccTotal=torch.sum(preds_onehot==mask.data) subaccTotal=subaccTotal.float() subaccTotal=subaccTotal/img.shape[0]/classes/img.shape[2]/img.shape[3] running_loss+=subloss*img.size(0) running_corrects+=subaccTotal*img.size(0) mask_ori=mask[:,1,:,:] sub_dice=ut.dice_cofficient(mask_ori,preds,1) samples=mask.shape[0] running_dice=running_dice+sub_dice*samples if(phase=='train'): writer.add_scalar('train_loss', subloss, iter_train) writer.add_scalar('train_acc', subaccTotal, iter_train) writer.add_scalar('train_dice', sub_dice, iter_train) iter_train+=1 elif(phase=='val'): writer.add_scalar('val_loss', subloss, iter_val) writer.add_scalar('val_acc', subaccTotal, iter_val) writer.add_scalar('val_dice', sub_dice, iter_val) iter_val += 1 # ut.plot_img(img[0, 0, :, :], mPath.DataPath_Log + "Input0-" + str(epoch) + ".jpg", "Input", 2) # ut.plot_img(mask[0, :, :, :], mPath.DataPath_Log + "Mask0-" + str(epoch) + ".jpg", "Mask", 2) # ut.plot_img(preds[0, :, :], mPath.DataPath_Log + "Output0-" + str(epoch) + ".jpg", "Output", 2) print('{} Loss:{:.6f} Acc:{:.10f} Dice:{:.10f}'.format(index, subloss, subaccTotal,sub_dice)) pass if not (dataLength==0): epoch_loss=running_loss/dataLength epoch_acc=running_corrects/dataLength epoch_dice=running_dice/dataLength else: epoch_loss=0 epoch_acc=0 epoch_dice=0 print('{} Loss:{:.6f} Acc:{:.10f} Dice:{:.10f}'.format(phase,epoch_loss,epoch_acc,epoch_dice)) # writer.add_scalars('scalar/epoch_data', {'epoch_loss': epoch_loss, 'epoch_acc': epoch_acc}, # epoch) if (phase == 'train'): writer.add_scalar('epoch_train_loss', epoch_loss, epoch) writer.add_scalar('epoch_train_acc', epoch_acc, epoch) writer.add_scalar('epoch_train_dice', epoch_dice, epoch) elif (phase == 'val'): writer.add_scalar('epoch_val_loss', epoch_loss, epoch) writer.add_scalar('epoch_val_acc', epoch_acc, epoch) writer.add_scalar('epoch_val_dice', epoch_dice, epoch) if epoch%Output_per_epoch==0: ut.plot_img(img[0,1,:,:], mPath.DataPath_Log + "Input0-" + str(epoch) + ".jpg", "Input",2) ut.plot_img(mask[0, :, :, :], mPath.DataPath_Log + "Mask0-" + str(epoch) + ".jpg", "Mask",2) ut.plot_img(preds[0, :, :], mPath.DataPath_Log + "Output0-" + str(epoch) + ".jpg", "Output",2) if(phase=='val' and epoch_dice>best_acc): best_acc=epoch_dice torch.save(net, mPath.DataPath_Net_Normal) pass pass pass torch.save(net, mPath.DataPath_Net_Final) writer.close() pass