def main(): # Checks the number of arguments and if the number is wrong, a # message telling this will be sent to stdout and the program ends, if(len(sys.argv) == 4): trainingListFileName = sys.argv[1] trainingFacitFileName = sys.argv[2] examineFileName = sys.argv[3] else: print("Wrong number of arguments") exit(-1) # The Image objects of the user included traininglist will be built and added to the list. # Same with the file the program will use to test its training on in the end. defaultTestImgList = ImageReader.parse(trainingListFileName,trainingFacitFileName) examineImgList = ImageReader.parseTest(examineFileName) learningRate = 0.1 # A list with the four node types are built, the number 1-4 represents a mood/ smile type. nodeList = [] nodeList.extend([Node(learningRate, 1), Node(learningRate, 2), Node(learningRate, 3), Node(learningRate, 4)]) # The program is trained trainNetworkOnImgList(nodeList,defaultTestImgList) # The program puts its training to the test with the user included test file. exmamineNetwork(nodeList,examineImgList,True)
def train(modelname): # server = tf.train.Server.create_local_server() # sess = tf.Session(server.target) # K.set_session(sess) # os.environ["CUDA_VISIBLE_DEVICES"] = "0" # K.set_floatx('float16') learning_rate = 0.0001 epochs = 80 batch_size = 20 decay_r = (learning_rate / (epochs)) images_n = 15000 # model = nb.build_model() model = keras.models.load_model( "64i_15k_300_retrained_HSV_120more", custom_objects={'binary_activation': nb.binary_activation}) fp = os.path.expanduser('~') + "/Downloads/img_celeba/data_crop_256_jpg" images = ir.read_directory(fp, images_n) images = np.array(images) / 255 images = np.array(images, dtype=np.float16) loss_func = "mse" if False: # todo: implement multigpu setting multi_model = keras.utils.multi_gpu_model(model, gpus=1, cpu_merge=True, cpu_relocation=False) else: multi_model = model multi_model.compile(optimizer=keras.optimizers.Adam(lr=learning_rate, decay=decay_r), loss=loss_func, metrics=['accuracy']) history = multi_model.fit(images, images, validation_split=0.05, callbacks=[], batch_size=batch_size, epochs=epochs) model.save(modelname) test_im = ir.read_directory(fp, limit=200, start=images_n - 50) test_im_disp = np.array(test_im) test_im = np.array(test_im) / 255 test_pred = model.predict(test_im) test_pred = np.array(test_pred * 255, dtype=np.uint8) rd.main(modelname) for i, d in enumerate(test_pred): break fig, (ax0, ax1) = plt.subplots(nrows=1, ncols=2) c_d = cv2.cvtColor(d, cv2.COLOR_BGR2RGB) ax0.imshow(c_d, interpolation='nearest', aspect='auto') c_test_im = cv2.cvtColor(test_im_disp[i], cv2.COLOR_BGR2RGB) ax1.imshow(c_test_im, interpolation='nearest', aspect='auto') plt.show() if i > 50: break
def histogramEqualization(imagePath): os.remove("./image.txt") finalSize = ImageConverter.getBytesFromFile(imagePath) print("Image Converter to bytes...") os.remove("../AssemblyCode/imageHE.txt") open("../AssemblyCode/imageHE.txt", 'w') subprocess.Popen(["make"], stdout=subprocess.PIPE, cwd="../AssemblyCode") print("Image processing Please wait...") time.sleep(15) print("Image processed...") print("Opening image...") deleteLastLine("../AssemblyCode/imageHE.txt") ImageReader.imageReader(imagePath, finalSize)
def display_grid(): start_time = time.time() print("Reading image") matrix, (start_x, start_y), (end_x, end_y) = ImageReader.read_image(image_to_process) print("Setting nodes") node_grid = ng.NodeGrid(matrix) node_grid.set_start(start_x, start_y) node_grid.set_end(end_x, end_y) print("Finding path") path = node_grid.find_path() print("Path found") print("Drawing path") ImageReader.draw_path(image_to_process, image_to_save, path) print("Finished") elapsed_time = time.time() - start_time print('{} seconds elapsed'.format(elapsed_time))
def main(modelname = "64i_15k_300_retrained_HSV_200more"): os.environ['CUDA_VISIBLE_DEVICES'] = '' fp = os.path.expanduser('~') + "/Downloads/imama/" # fp = os.path.expanduser('~') + "/Bakk/Bakalauras/personal_testing_images/logos" # fp = os.path.expanduser('~') + "/Bakk/Bakalauras/personal_testing_images/cropped" # fp = os.path.expanduser('~') + "/Bakk/Bakalauras/personal_testing_images/random" images_n = 10 images = ir.read_directory(fp, images_n, start=0) images = np.array(images) / 255 model = load_model(modelname, custom_objects={'binary_activation': nb.binary_activation}, compile=True) print(model.summary()) visualise_model(images, model, "conv2d_14", 8, 8)
def main(): # imageReader = ImageReader.ImageReader() traitRecognitor = TraitRecognitor.TraitRecognitor() # ScoreCalculator is modelled but not yet implemented. its not foccussed during the Bachelor Thesis # scoreCalculator = ScoreCalculator.ScoreCalculator() imageProcessor = ImageProcessor.ImageProcessor() contourFinder = ContourFinder.ContourFinder() contourDrawer = ContourDrawer.ContourDrawer() imageWriter = ImageWriter.ImageWriter() ImageAnalysisController( imageReader=imageReader, traitRecognitor=traitRecognitor, # Score calculator not yet implemented, it was not focus of Bachelor Thesis #scoreCalculator = scoreCalculator, imageWriter=imageWriter, imageProcessor=imageProcessor, contourFinder=contourFinder, contourDrawer=contourDrawer)
return c_matrix def computeAccuracyofDclassifier(prelist,label): count=0 tup=zip(prelist, label) for (p,l) in tup: if tuple(p)==tuple(l): print(p,l) count=count+1 return count/100 images, label, direction = ImageReader.readTestImage() batch = ImageReader.getbatch(images, label, direction, test_list_len) with tf.Session() as sess: new_saver=tf.train.import_meta_graph('owckpt/model.ckpt.meta') new_saver.restore(sess,'owckpt/model.ckpt') yc= tf.get_collection('pred_networkc')[0] yd = tf.get_collection('pred_networkd')[0] graph=tf.get_default_graph() X=graph.get_operation_by_name('X').outputs[0] sess.run(tf.local_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) for i in range(1):
from skimage import feature from skimage import filters from skimage.transform import hough_line, hough_line_peaks, probabilistic_hough_line import ImageReader import RGBToGrayScale #dialog box para pegar o path da imagem. root = tk.Tk() root.withdraw() #root.withdraw() path = filedialog.askopenfilename() #Lê a imagem || Exercício 1 image = ImageReader.readImage(path) #Fim Exercício 1 #Transforma a Imagem em Monocromática || Exercício 2 graysScale = RGBToGrayScale.rgb2gray(image) fig, axes = plt.subplots(1, 2, figsize=(8, 4)) fig.suptitle("Original para Escala de Cinza", ha='center', va='top') fig.dpi = 125 ax = axes.ravel() ax[0].imshow(image) ax[0].set_title("Original") ax[1].imshow(graysScale, cmap=plt.cm.gray) ax[1].set_title("Grayscale")
def train(): ''' 进行训练 ''' #定义记录部分 log = Metrics.Logger(config.csv_path, config.tb_path) #定义模型 if config.start_epoch == 1: model = net.get_net(classes_num=config.classes_num, channel_size=config.channel_size, cnn_weights_path=config.cnn_weights_path, drop_rate=config.drop_rate) else: model = net.get_net(classes_num=config.classes_num, channel_size=config.channel_size, drop_rate=config.drop_rate) print("model load succeed") if config.use_cuda: model = model.cuda() #将model转到cuda上 if config.use_parallel: model = nn.DataParallel(model, device_ids=config.device_ids) cudnn.benchmark = True if config.start_epoch != 1: all_weights_path = config.save_weights_path.format(config.start_epoch - 1) model.load_state_dict(torch.load(all_weights_path)) print("{} load succeed".format(all_weights_path)) #加载数据集 train_folder = config.train_img_path validate_folder = config.validate_img_path train_loader = ImageReader.get_loader("train", train_folder) validate_loader = ImageReader.get_loader("validate", validate_folder) #定义优化器和学习率调度器 optimizer = SGD(params=model.parameters(), lr=config.start_lr, momentum=0.9, weight_decay=config.weight_decay) scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=config.stones, gamma=0.1) #定义评估函数 accuracy = Metrics.AccuracyList(num=1) l_train = Metrics.LossList(1) l_val = Metrics.LossList(1) #定义最好的准确率 best_acc = 0 for i in range(config.start_epoch, config.start_epoch + config.num_epoch): #分配学习率 scheduler.step(epoch=i) lr = scheduler.get_lr()[0] print("{} epoch start , lr is {}".format(i, lr)) #开始训练这一轮 model.train() accuracy.set_zeros() l_train.set_zeros() train_step = 0 for (x1, x2), y in train_loader: x1 = Variable(x1) x2 = Variable(x2) y = Variable(y) if config.use_cuda: x1 = x1.cuda() x2 = x2.cuda() y = y.cuda(async=True) optimizer.zero_grad() #清空梯度值 y_ = model(x1, x2) #求y #求这一步的损失值和准确率 step_loss, loss_list = model.get_loss(y_, y) step_acc = accuracy(y_, y) l_train.log(loss_list) #更新梯度值 step_loss.backward() optimizer.step() train_step += 1 #训练步数+1 #输出这一步的记录 print("{} epoch,{} step,step loss is {:.6f},step acc is {:.4f}". format(i, train_step, loss_list[0], max(step_acc))) del (step_loss, x1, x2, y, y_) #求这一轮训练情况 train_acc_list = accuracy.get_acc_list() train_loss_list = l_train.get_loss_list() #保存模型 weights_name = config.save_weights_path.format(i) torch.save(model.state_dict(), weights_name) del_weights_name = config.save_weights_path.format(i - 1) if os.path.exists(del_weights_name): os.remove(del_weights_name) print("{} save,{} delete".format(weights_name, del_weights_name)) #开始验证步骤 model.eval() accuracy.set_zeros() #将accuracy中total_sample和total_correct清0 l_val.set_zeros() for (x1, x2), y in validate_loader: x1 = Variable(x1, requires_grad=False) x2 = Variable(x2, requires_grad=False) y = Variable(y, requires_grad=False) if config.use_cuda: x1 = x1.cuda() x2 = x2.cuda() y = y.cuda(async=True) y_ = model(x1, x2) _, loss_list = model.get_valloss(y_, y) accuracy(y_, y) l_val.log(loss_list) del (x1, x2, y, y_, _) val_acc_list = accuracy.get_acc_list() val_loss_list = l_val.get_loss_list() print("validate end,log start") #保存最佳的模型 if best_acc < max(val_acc_list): weights_name = config.save_weights_path.format("best_acc") torch.save(model.state_dict(), weights_name) best_acc = max(val_acc_list) #求model的正则化项 l2_reg = 0.0 for param in model.parameters(): l2_reg += torch.norm(param).data[0] #开始记录 log.log(i, train_acc_list, train_loss_list, val_acc_list, val_loss_list, l2_reg, lr) print("log end ...") print( "{} epoch end, train loss is {},train acc is {},val loss is {},val acc is {},weight l2 norm is {}" .format(i, train_loss_list[0], max(train_acc_list), val_loss_list[0], max(val_acc_list), l2_reg)) del (model) print("{} train end,best_acc is {}...".format(config.dataset, best_acc))
def train(): ''' 定义训练的函数 ''' #加载模型 model = Network.MyDenseNet(name_num_dict=config.name_num_dict, cnn_weights_path=config.cnn_weights_path) #加载全部的模型权重 if config.all_weights_path: weights_dict = torch.load(config.all_weights_path) model.load_state_dict(state_dict=weights_dict) print("load {} weights succecced...".format(config.all_weights_path)) if torch.cuda.is_available() and use_gpu: model = model.cuda() #定义训练数据部分 tran = transforms.Compose( [transforms.ToTensor(), transforms.Resize(config.target_size)]) reader = ImageReader.MultiTaskImageReader( root_path=config.train_img_root_path, csv_path=config.train_img_csv, transform=tran, name_pos_dict=config.name_pos_dict, name_num_dict=config.name_num_dict, num_list=config.num_list) trainloader = torch.utils.data.DataLoader(reader, batch_size=config.batch_size, shuffle=True, num_workers=config.num_thread) #定义验证数据部分 val_reader = ImageReader.MultiTaskImageReader( root_path=config.val_img_root_path, csv_path=config.val_img_csv, transform=tran, name_pos_dict=config.name_pos_dict, name_num_dict=config.name_num_dict, num_list=config.num_list) validateloader = torch.utils.data.DataLoader(val_reader, batch_size=config.batch_size, shuffle=True, num_workers=config.num_thread) #定义优化器 optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9) for epoch in range(config.start_epoch, config.start_epoch + config.epochs): print("{} epoch start...".format(epoch)) #开始训练模式 model.train() #定义一轮中的评估指标 step = 0 #训练步数 total_loss = 0 #记录总的运行损失 total_loss_list = [0, 0, 0, 0, 0, 0, 0, 0] #记录各个大类的运行损失 total_acc = 0 #记录总的准确率 val_step = 0 val_total_acc = 0 val_total_loss = 0 val_total_loss_list = [0, 0, 0, 0, 0, 0, 0, 0] for data in trainloader: inputs, labels = data inputs = Variable(inputs) for i in range(len(labels)): labels[i] = Variable(labels[i]) if torch.cuda.is_available() and use_gpu: inputs = inputs.cuda() for i in range(len(labels)): labels[i] = labels[i].cuda() optimizer.zero_grad() #将梯度缓冲区清0 outputs = model(inputs) step_loss, step_loss_list = metrics.loss(outputs, labels) total_loss += step_loss.data[0] #更新总的损失 for i in range(len(total_loss_list)): #更新各个类的损失 total_loss_list[i] += step_loss_list[i] step_loss.backward() optimizer.step() if step % 10 == 0 and step != 0: step_acc = metrics.accuracy(outputs, labels) total_acc += step_acc print("{} epoch, {} step, step loss is {}, step acc is {}". format(epoch, step, step_loss.data[0], step_acc)) else: print("{} epoch, {} step, step loss is {}".format( epoch, step, step_loss.data[0])) #释放显存 del ([inputs, labels, outputs, step_loss, step_loss_list]) step += 1 #模型保存参数 print("start save model weights...") torch.save(model.state_dict(), config.save_weights_path.format(epoch)) model.eval() #开启验证模式 print("start validate ...") #解下来进行验证 for data in validateloader: inputs, labels = data inputs = Variable(inputs) for i in range(len(labels)): labels[i] = Variable(labels[i]) if torch.cuda.is_available() and use_gpu: inputs = inputs.cuda() for i in range(len(labels)): labels[i] = labels[i].cuda() #获取outputs outputs = model(inputs) step_loss, step_loss_list = metrics.loss(outputs, labels) step_acc = metrics.accuracy(outputs, labels) val_total_loss += step_loss.data[0] for i in range(len(val_total_loss_list)): val_total_loss_list[i] += step_loss_list[i] val_total_acc += step_acc val_step += 1 #释放显存 del ([inputs, labels, outputs, step_loss, step_loss_list]) print("{} epoch , validation loss is {}, validation accuracy is {}". format(epoch, val_total_loss / val_step, val_total_acc / val_step)) #训练完一轮之后将训练结果记录到文件中 print("start log train info...") utils.log_train(epoch, total_loss, total_loss_list, step, total_acc, val_total_loss, val_total_loss_list, val_total_acc, val_step) del (model) print("{} epoch train end ...".format(epoch))
def main(argv=None): keep_probability = tf.placeholder( tf.float32, name="keep_probabilty") #Dropout probability Sparse_Sampled_Image = tf.placeholder( tf.float32, shape=[None, None, None, 3], name="input_Sparse_image") #Input image sparsly sampled image ReconstructImage = BuildNet.inference( Sparse_Sampled_Image, keep_probability, 3, Vgg_Model_Dir) # Here the graph(net) is builded print("Reading images list") #---------------------Read list of image for recostruction------------------------------------------------------------ Images = [] #Train Image List Images += [ each for each in os.listdir(Image_Dir) if each.endswith('.PNG') or each.endswith('.JPG') or each.endswith( '.TIF') or each.endswith('.GIF') or each.endswith('.png') or each.endswith('.jpg') or each.endswith('.tif') or each.endswith('.gif') ] # Get list of training images print('Number of images=' + str(len(Images))) #-------------------------Load trained mode---------------------------------------------------------------------------------------------------------------------------- sess = tf.Session() #Start Tensorflow session print("Setting up Saver...") saver = tf.train.Saver() # summary_writer = tf.summary.FileWriter(logs_dir, sess.graph) sess.run(tf.global_variables_initializer()) #sess.run(tf.initialize_all_variables()) ckpt = tf.train.get_checkpoint_state(logs_dir) if ckpt and ckpt.model_checkpoint_path: # if trained model exist restore it saver.restore(sess, ckpt.model_checkpoint_path) print("Model restored...") else: print("Error no trained model found in log dir " + logs_dir + "For creating trained model see: Train.py") return #..............Start image reconstruction.................................................................... for itr in range(len(Images)): #.....................Load images for prediction------------------------------------- print(str(itr) + ") Reconstructing: " + Image_Dir + Images[itr]) FullImage, SparseSampledImage = ImageReader.LoadImages( Image_Dir + Images[itr], 0, 0, SamplingRate) #.......................Run one prediction............................................................................... feed_dict = { Sparse_Sampled_Image: SparseSampledImage, keep_probability: 1 } # Run one cycle of traning ReconImage = sess.run( ReconstructImage, feed_dict=feed_dict) # run image reconstruction using network #......................Save image.......................................................................... #ReconImage[ReconImage>255]=255 #ReconImage[ReconImage<0]=0 misc.imsave( OUTPUT_Dir + "/" + Images[itr][0:-4] + "_Reconstructed" + Images[itr][-4:], ReconImage[0]) misc.imsave( OUTPUT_Dir + "/" + Images[itr][0:-4] + "_Original" + Images[itr][-4:], FullImage[0]) misc.imsave( OUTPUT_Dir + "/" + Images[itr][0:-4] + "_Sampled" + Images[itr][-4:], SparseSampledImage[0])
target_small_value, target_small_class = torch.max( target_labels[big_class_list[i]][i].view([1, -1]), dim=1) res = (pred_small_class == target_small_class).data[0] if res: true_num += 1 return true_num / batch_size if __name__ == "__main__": tran = transforms.Compose( [transforms.ToTensor(), transforms.Resize((224, 224))]) reader = ImageReader.MultiTaskImageReader( root_path="../../ali_data/second_validate_data/Images/", csv_path="../../ali_data/second_validate_data/labels.csv", transform=tran, name_pos_dict=config.name_pos_dict, name_num_dict=config.name_num_dict, num_list=config.num_list) trainloader = torch.utils.data.DataLoader(reader, batch_size=1, shuffle=True, num_workers=4) for x, y in trainloader: break model = Network.MyDenseNet(config.name_num_dict) x = torch.autograd.Variable(x) output = model(x) for i in range(len(output)): y[i] = torch.autograd.Variable(y[i])
import sfr, ImageReader, config, Metrics import torch from torch.autograd import Variable import torch.nn as nn model = sfr.get_sfr(classes_num=config.classes_num, channel_size=config.channel_size, drop_rate=config.drop_rate, sr_rate=config.sr_rate, fr_rate=config.fr_rate) validate_loader = ImageReader.getLoader(config.dataset, "validate", config.validate_img_path) all_weights_path = "./weights/cub/sfr_resnet50_cub_best_acc.pth" if config.use_cuda: model = model.cuda() model.load_state_dict(torch.load(all_weights_path)) model.eval() val_loss = 0 val_step = 0 accuracy = Metrics.Accuracy() criterion = nn.CrossEntropyLoss() for x, y in validate_loader: x = Variable(x, requires_grad=False) y = Variable(y, requires_grad=False) if config.use_cuda: x = x.cuda() y = y.cuda(async=True) y_ = model.forward_validate(x) step_loss = criterion(y_, y) step_acc = accuracy(y_, y)
def train(): ''' 进行训练 ''' #定义记录部分 csv_path = config.csv_path tb_path = config.tb_path writer = SummaryWriter(log_dir=tb_path) #定义模型 if config.start_epoch == 1: model = net.get_net(classes_num=config.classes_num, channel_size=config.channel_size, cnn_weights_path=config.cnn_weights_path, drop_rate=config.drop_rate) else: model = net.get_net(classes_num=config.classes_num, channel_size=config.channel_size, drop_rate=config.drop_rate) print("model load succeed") if config.use_cuda: model = model.cuda() #将model转到cuda上 if config.use_parallel: model = nn.DataParallel(model, device_ids=config.device_ids) cudnn.benchmark = True if config.start_epoch != 1: all_weights_path = config.save_weights_path.format(config.start_epoch - 1) model.load_state_dict(torch.load(all_weights_path)) print("{} load succeed".format(all_weights_path)) #加载数据集 train_folder = config.train_img_path validate_folder = config.validate_img_path train_loader = ImageReader.getLoader(config.dataset, "train", train_folder) validate_loader = ImageReader.getLoader(config.dataset, "validate", validate_folder) #定义优化器和学习率调度器 optimizer = SGD(params=model.parameters(), lr=config.start_lr, momentum=0.9, weight_decay=config.weight_decay) scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=config.stones, gamma=0.1) #定义评估函数 criterion = nn.CrossEntropyLoss() accuracy = Metrics.Accuracy() #定义最好的准确率 best_acc = 0 for i in range(config.start_epoch, config.start_epoch + config.num_epoch): #分配学习率 scheduler.step(epoch=i) lr = scheduler.get_lr()[0] print("{} epoch start , lr is {}".format(i, lr)) #开始训练这一轮 model.train() accuracy.__init__() train_loss = 0 train_step = 0 for x, y in train_loader: x = Variable(x) y = Variable(y) if config.use_cuda: x = x.cuda() y = y.cuda(async=True) optimizer.zero_grad() #清空梯度值 y_ = model(x) #求y #求这一步的损失值和准确率 step_loss = criterion(y_, y) step_acc = accuracy(y_, y) train_loss += step_loss.data[0] #更新梯度值 step_loss.backward() optimizer.step() train_step += 1 #训练步数+1 #输出这一步的记录 print("{} epoch,{} step,step loss is {:.6f},step acc is {:.4f}". format(i, train_step, step_loss.data[0], step_acc)) del (step_loss, x, y, y_) #求这一轮训练情况 train_acc = accuracy.total_correct / (accuracy.total_sample + 1e-5) train_loss = train_loss / (train_step + 1e-5) #保存模型 weights_name = config.save_weights_path.format(i) torch.save(model.state_dict(), weights_name) del_weights_name = config.save_weights_path.format(i - 3) if os.path.exists(del_weights_name): os.remove(del_weights_name) print("{} save,{} delete".format(weights_name, del_weights_name)) #开始验证步骤 model.eval() accuracy.__init__() #将accuracy中total_sample和total_correct清0 val_loss = 0 val_step = 0 for x, y in validate_loader: x = Variable(x, requires_grad=False) y = Variable(y, requires_grad=False) if config.use_cuda: x = x.cuda() y = y.cuda(async=True) y_ = model(x) step_loss = criterion(y_, y) step_acc = accuracy(y_, y) val_loss += step_loss.data[0] val_step += 1 del (x, y, y_, step_loss) val_acc = accuracy.total_correct / (accuracy.total_sample + 1e-5) val_loss = val_loss / (val_step + 1e-5) print("validate end,log start") #保存最佳的模型 if best_acc < val_acc: weights_name = config.save_weights_path.format("best_acc") torch.save(model.state_dict(), weights_name) best_acc = val_acc #求model的正则化项 l2_reg = 0.0 for param in model.parameters(): l2_reg += torch.norm(param).data[0] #开始记录 with open(csv_path, "a", encoding="utf-8") as file: t = get_ctime() content = "{},{:.6f},{:.4f},{:.6f},{:.4f},{:.6f},{}".format( i, train_loss, train_acc, val_loss, val_acc, l2_reg, t) + "\n" file.write(content) writer.add_scalar("Train/acc", train_acc, i) writer.add_scalar("Train/loss", train_loss, i) writer.add_scalar("Val/acc", val_acc, i) writer.add_scalar("Val/loss", val_loss, i) writer.add_scalar("lr", lr, i) writer.add_scalar("l2_reg", l2_reg, i) print("log end ...") print( "{} epoch end, train loss is {:.6f},train acc is {:.4f},val loss is \ {:.6f},val acc is {:.4f},weight l2 norm is {:.6f}".format( i, train_loss, train_acc, val_loss, val_acc, l2_reg)) del (model) print("{} train end,best_acc is {}...".format(config.dataset, best_acc))
import ImageReader as ImReader import ClassificationDataReader as cdr import numpy as np import KNN # ImReader.saveMnistDataToTxtFile("Images\NumberImages") trainLabels = cdr.readFileToArray("trainLabelsMnist.csv") testLabels = cdr.readFileToArray("testLabelsMnist.csv") trainData = cdr.readFileToArray("trainDataMnist.csv") testData = cdr.readFileToArray("testDataMnist.csv") knn = KNN.KNN(trainData, trainLabels, 3) counter = 0 predictedLabels = [] for sample in testData: sample = np.asarray(sample) predictedLabels.append(knn.predict(sample)) if (counter % 100 == 0): print counter counter += 1 ImReader.createTxtFileWithData("createTxtFileWithData.csv", predictedLabels)
def main(argv=None): keep_probability = tf.placeholder( tf.float32, name="keep_probabilty") #Dropout probability Sparse_Sampled_Image = tf.placeholder( tf.float32, shape=[None, None, None, 3], name="input_Sparse_image") #Input image sparsly sampled image Full_Image = tf.placeholder( tf.float32, shape=[None, None, None, 3], name="Full_image") # Full image all pixels filled ReconstructImage = BuildNet.inference( Sparse_Sampled_Image, keep_probability, 3, Vgg_Model_Dir) # Here the graph(net) is builded loss = tf.reduce_mean( tf.abs(ReconstructImage - Full_Image, name="L1_Loss") ) # Define loss function for training as the difference between reconstruct image and ground truth image # tf.summary.scalar("L1_Loss", loss) trainable_var = tf.trainable_variables() train_op = train(loss, trainable_var) #print("Setting up summary op...") #summary_op = tf.summary.merge_all() print("Reading images list") TrainImages = [] #Train Image List TrainImages += [ each for each in os.listdir(Train_Image_Dir) if each.endswith('.PNG') or each.endswith('.JPG') or each.endswith( '.TIF') or each.endswith('.GIF') or each.endswith('.png') or each.endswith('.jpg') or each.endswith('.tif') or each.endswith('.gif') ] # Get list of training images print('Number of Train images=' + str(len(TrainImages))) #-------------------------Training Region----------------------------------------------------------------------------------------------------------------------------- sess = tf.Session() #Start Tensorflow session print("Setting up Saver...") saver = tf.train.Saver() # summary_writer = tf.summary.FileWriter(logs_dir, sess.graph) sess.run(tf.global_variables_initializer()) #sess.run(tf.initialize_all_variables()) ckpt = tf.train.get_checkpoint_state(logs_dir) if ckpt and ckpt.model_checkpoint_path: # if trained model exist restore it saver.restore(sess, ckpt.model_checkpoint_path) print("Model restored...") #---------------------------Start Training: Create loss files---------------------------------------------------------------------------------------------------------- Nimg = 0 f = open( TrainLossTxtFile, "w") # Create text file for writing the loss trough out the training f.write("Iteration\tTrain_Loss\t Learning Rate=" + str(learning_rate)) f.close() #----------------------------------------------------------------------------------------------------------------- Epoch = 0 #..............Start Training loop: Main Training.................................................................... for itr in range(1, MAX_ITERATION + 1): if Nimg >= len(TrainImages) - 1: # End of an epoch Nimg = 0 random.shuffle(TrainImages) #Suffle images every epoch Epoch += 1 print("Epoch " + str(Epoch) + " Completed") #.....................Load images for training batch_size = np.min([Batch_Size, len(TrainImages) - Nimg]) FullImages = np.zeros([batch_size, Im_Hight, Im_Width, 3], dtype=np.int) SparseSampledImages = np.zeros([batch_size, Im_Hight, Im_Width, 3], dtype=np.int) for fi in range(batch_size): FullImages[fi], SparseSampledImages[fi] = ImageReader.LoadImages( Train_Image_Dir + TrainImages[Nimg], Im_Hight, Im_Width, SamplingRate) Nimg += 1 #.......................Run one batch of training............................................................................... feed_dict = { Sparse_Sampled_Image: SparseSampledImages, Full_Image: FullImages, keep_probability: 0.4 + np.random.rand() * 0.6 } # Run one cycle of traning sess.run(train_op, feed_dict=feed_dict) #......................Write training set loss.......................................................................... if itr % 10 == 0: feed_dict = { Sparse_Sampled_Image: SparseSampledImages, Full_Image: FullImages, keep_probability: 1 } train_loss = sess.run(loss, feed_dict=feed_dict) print("Step: %d, Train_loss:%g " % (itr, train_loss)) # summary_writer.add_summary(summary_str, itr) with open(TrainLossTxtFile, "a") as f: #Write training loss for file f.write("\n" + str(itr) + "\t" + str(train_loss)) f.close() #....................Save Trained net (ones every 1000 training cycles............................................... if itr % 200 == 0: print("Saving Model") saver.save(sess, logs_dir + "model.ckpt", itr) # save trained model
def makemodel(X): convolutionlayer1=conv1(X) convolutionlayer2=conv2(convolutionlayer1) convolutionlayer3=conv3(convolutionlayer2) logits=fullyconnectedlayer(convolutionlayer3) return logits def getloss(Y, logits): #实用MSE loss = tf.reduce_mean(tf.square(Y-logits)) return loss images, label, direction = ImageReader.readImage(epoch=None) batch = ImageReader.getbatch(images, label, direction, 30) X = tf.placeholder("float", [None, 256, 256, 3], name='X') Y = tf.placeholder("float", [None, 2]) model=makemodel(X) loss=getloss(Y, model) train_op = tf.train.AdamOptimizer(learning_rate=1e-5).minimize(loss) saver=tf.train.Saver() tf.add_to_collection('pred_network',model) with tf.Session() as sess: # tf.train.string_input_producer定义了一个epoch变量,要对它进行初始化
default='pics/pic.png', help='The file name of picture or .npy file.') parser.add_argument('-n', type=int, default=1800, help='Steps of stepping motor.') args = parser.parse_args() mode = args.m filename = args.f work_size = args.n worker = wk.Worker(work_size) if mode == 'test': worker.test() elif mode == 'work': if filename[-3:] == 'npy': worker.actions.load(filename) else: reader = ir.ImageReader(filename) reader.set_mode(ir.MODE_CONTOURS) contours = reader.get_contours() worker.actions.add_contours(contours) worker.eval() else: print('Unknown mode')
from numpy import * import os def fprintMat(fname, x, row, col): f = open(fname, 'w') for i in range(row): s = '' for j in range(col): s = s + str(x[i, j]) + " " s = s + '\n' f.write(s) f.close if __name__ == "__main__": label, amount = ImageReader.readLabels('../../data/mnist/train-labels.idx1-ubyte') images, amount, row, col = ImageReader.readImages('../../data/mnist/train-images.idx3-ubyte') q_label, q_amount = ImageReader.readLabels('../../data/mnist/t10k-labels.idx1-ubyte') q_images, q_amount, row, col = ImageReader.readImages('../../data/mnist/t10k-images.idx3-ubyte') it = int(sys.argv[1]) teta = zeros((row*col + 1, 10), dtype = float64) best_it = -1 min_error = 1. if os.path.exists("out"): for i in os.listdir("out"): fn = "out/" + i os.remove(fn) os.removedirs("out") os.makedirs("out") for h in range(it): for i in range(amount):
def main(args): images = "textures" featureMethod = "cu" classMethod = "perc" ifDisplayImages = False ifClassify = True radiusSize = 7 imagesToClassify = PP.ImagesToClassify(images) featureExtactionMethod = PP.OtherImagesFeaturesType(featureMethod) classificationMethod = PP.ClassificationMethod(classMethod) if not ifClassify: if(imagesToClassify == PP.ImagesToClassify.NumberImages): print("Loading number images..") trainImages, testImages = ImRead.LoadNumbersImages() elif(imagesToClassify == PP.ImagesToClassify.OtherImages): print("Loading other images..") trainImages, testImages = ImRead.LoadOtherImages() print("Processing images..") imSeg.ExtractImages(trainImages) imSeg.ExtractImages(testImages) print("Computing shape descriptors..") Features.ComputeFeatures(trainImages, featureExtactionMethod) Features.ComputeFeatures(testImages, featureExtactionMethod) trainData = "OtherImages\\trainData.txt" trainLabels = "OtherImages\\trainLabels.txt" testData = "OtherImages\\testData.txt" testLabels = "OtherImages\\testLabels.txt" Features.SaveFeaturesToFile(trainImages, trainLabels, trainData) elif(imagesToClassify == PP.ImagesToClassify.Textures): print("Loading textures..") trainImages, testImages = ImRead.LoadTextures() print("Processing images..") imSeg.ExtractImages(trainImages, onlyConvertToGreyScale=True) imSeg.ExtractImages(testImages, onlyConvertToGreyScale=True) print("Computing image features..") trainThread = threading.Thread(target=Features.ComputeFeatures, args=(trainImages, radiusSize, featureExtactionMethod)) # Features.ComputeFeatures(trainImages, featureExtactionMethod) print("{0} Train feature extraction started!".format(datetime.datetime.now())) trainThread.start() Features.ComputeTexturePartFeatures(testImages, radiusSize, featureExtactionMethod) trainThread.join() print("{0} Train feature extraction finished!".format(datetime.datetime.now())) trainData = "Textures\\trainData.txt" trainLabels = "Textures\\trainLabels.txt" print("Saving features to file") Features.SaveFeaturesToFile(trainImages, trainLabels, trainData) Features.SaveImagePartsFeatures(testImages, radiusSize) elif ifClassify: print("Classification started!") featureFiles = ["test1.txt", "test2.txt", "test3.txt"] textureObjects = [] for featureFile in featureFiles: textureObjects.append(Features.ReadFeaturesOfImage(featureFile)) trainData = "Textures\\trainData.txt" trainLabels = "Textures\\trainLabels.txt" predictions = [] if(classificationMethod == PP.ClassificationMethod.OtoczenieKuliste): OtKul = OK.OtoczKul(trainData, trainLabels) for textureObj in textureObjects: predictions.append([]) for imageFeatures in textureObj.imageFeatures: predictions[-1].append(OtKul.PredictLabel(imageFeatures)) textureObj.CreateTexture(predictions[-1], radiusSize) Features.SaveImage(textureObj) elif(classificationMethod == PP.ClassificationMethod.KNN): knn = KNN.KNN(trainData, trainLabels, 3) for textureObj in textureObjects: predictions.append([]) for imageFeatures in textureObj.imageFeatures: predictions[-1].append(knn.predict(imageFeatures)) textureObj.CreateTexture(predictions[-1], radiusSize) Features.SaveImage(textureObj) elif(classificationMethod == PP.ClassificationMethod.Percepton): trainDataD, trainLabelsD = readTrainData("Output\\" + trainData, "Output\\" + trainLabels) hidden_layers = [10] myDNN = Percepton(trainDataD.shape[1], 4, hidden_layers, ifBias=True, batch_size=0) print("[%s] Training model.." %(datetime.datetime.now())) myDNN.train(trainDataD, trainLabelsD, l_rate=0.1, n_epochs=10000, epsilon=10e-12) print("[%s] Model has been trained!" %(datetime.datetime.now())) for textureObj in textureObjects: predictions = [] print("[%s] Predicting.." %(datetime.datetime.now())) predictions.append(myDNN.predict(np.array(textureObj.imageFeatures))) print("[%s] Saving.." %(datetime.datetime.now())) textureObj.CreateTexture(predictions[-1], radiusSize) Features.SaveImage(textureObj) if(ifDisplayImages): imDisp = ImDisp.ImageDisplayer(6) imDisp.DisplayOtherImagesAnimation(trainImages)