def build_model(network='resnet101', base_model_cfg='resnet'): feature_aggregation_module = [] for i in range(5): feature_aggregation_module.append(FAModule()) upsampling = [] for i in range(0, 4): upsampling.append([]) for j in range(0, i + 1): upsampling[i].append( nn.ConvTranspose2d(k, k, kernel_size=2**(j + 2), stride=2**(j + 1), padding=2**(j))) if base_model_cfg == 'resnet': parameter = [3, 4, 23, 3] if network == 'resnet101' else [3, 4, 6, 3] backbone = ResNet(Bottleneck, parameter) return JL_DCF(base_model_cfg, JLModule(backbone), CMLayer(), feature_aggregation_module, ScoreLayer(k), ScoreLayer(k), upsampling) elif base_model_cfg == 'vgg': backbone = vgg(network=network) return JL_DCF(base_model_cfg, JLModuleVGG(backbone), CMLayer(), feature_aggregation_module, ScoreLayer(k), ScoreLayer(k), upsampling) elif base_model_cfg == 'densenet': backbone = densenet161() return JL_DCF(base_model_cfg, JLModuleDensenet(backbone), CMLayer(), feature_aggregation_module, ScoreLayer(k), ScoreLayer(k), upsampling)
def train(generator, discriminator, train_ds, valid_ds, steps=2000, lr_rate=1e-4): generator_optimizer = Adam(learning_rate=lr_rate) discriminator_optimizer = Adam(learning_rate=lr_rate) vgg = vgg() pls_metric = tf.keras.metrics.Mean() dls_metric = tf.keras.metrics.Mean() steps = steps step = 0 for lr, hr in train_ds.take(steps): step += 1 with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape: lr = tf.cast(lr, tf.float32) hr = tf.cast(hr, tf.float32) # Forward pass sr = generator(lr, training=True) hr_output = discriminator(hr, training=True) sr_output = discriminator(sr, training=True) # Compute losses con_loss = content_loss(vgg, hr, sr) gen_loss = generator_loss(sr_output) perc_loss = con_loss + 0.001 * gen_loss disc_loss = discriminator_loss(hr_output, sr_output) # Compute gradient of perceptual loss w.r.t. generator weights gradients_of_generator = gen_tape.gradient( perc_loss, generator.trainable_variables) # Compute gradient of discriminator loss w.r.t. discriminator weights gradients_of_discriminator = disc_tape.gradient( disc_loss, discriminator.trainable_variables) # Update weights of generator and discriminator generator_optimizer.apply_gradients( zip(gradients_of_generator, generator.trainable_variables)) discriminator_optimizer.apply_gradients( zip(gradients_of_discriminator, discriminator.trainable_variables)) pl, dl = perc_loss, disc_loss pls_metric(pl) dls_metric(dl) print( f'{step}/{steps}, perceptual loss = {pls_metric.result():.4f}, discriminator loss = {dls_metric.result():.4f}' ) pls_metric.reset_states() dls_metric.reset_states() generator.save_weights('pre-trained/generator.h5') discriminator.save_weights('pre-trained/discriminator.h5')
def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") data_transform = transforms.Compose( [transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) # load image img_path = "../1.jpeg" assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path) img = Image.open(img_path) plt.imshow(img) # [N, C, H, W] img = data_transform(img) # expand batch dimension img = torch.unsqueeze(img, dim=0) # read class_indict json_path = './class_indices.json' assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path) json_file = open(json_path, "r") class_indict = json.load(json_file) # create model, 记得修改num_classes=类别数 model = vgg(model_name="vgg16", num_classes=3).to(device) # load model weights weights_path = "./vgg16Net.pth" assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path) model.load_state_dict(torch.load(weights_path, map_location=device)) model.eval() with torch.no_grad(): # predict class output = torch.squeeze(model(img.to(device))).cpu() predict = torch.softmax(output, dim=0) predict_cla = torch.argmax(predict).numpy() print_res = "class: {} prob: {:.3}".format(class_indict[str(predict_cla)], predict[predict_cla].numpy()) print(str(predict_cla)) print(class_indict[str(predict_cla)]) print(print_res) plt.rcParams['font.sans-serif'] = ['SimHei'] # 显示中文标签 plt.rcParams['axes.unicode_minus'] = False # 这两行需要手动设置 plt.title(print_res) print(print_res) plt.show()
def main(): im_height = 224 im_width = 224 num_classes = 5 # load image img_path = "../tulip.jpg" assert os.path.exists(img_path), "file: '{}' dose not exist.".format( img_path) img = Image.open(img_path) # resize image to 224x224 img = img.resize((im_width, im_height)) plt.imshow(img) # scaling pixel value to (0-1) img = np.array(img) / 255. # Add the image to a batch where it's the only member. img = (np.expand_dims(img, 0)) # read class_indict json_path = './class_indices.json' assert os.path.exists(json_path), "file: '{}' dose not exist.".format( json_path) json_file = open(json_path, "r") class_indict = json.load(json_file) # create model model = vgg("vgg16", im_height=im_height, im_width=im_width, num_classes=num_classes) weights_path = "./save_weights/myVGG.h5" assert os.path.exists(img_path), "file: '{}' dose not exist.".format( weights_path) model.load_weights(weights_path) # prediction result = np.squeeze(model.predict(img)) predict_class = np.argmax(result) print_res = "class: {} prob: {:.3}".format( class_indict[str(predict_class)], result[predict_class]) plt.title(print_res) for i in range(len(result)): print("class: {:10} prob: {:.3}".format(class_indict[str(i)], result[i].numpy())) plt.show()
def main(): gpus = tf.config.experimental.list_physical_devices("GPU") if gpus: try: for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True) except RuntimeError as e: print(e) exit(-1) data_root = os.path.abspath(os.path.join(os.getcwd(), "../..")) # get data root path image_path = os.path.join(data_root, "data_set", "flower_data") # flower data set path train_dir = os.path.join(image_path, "train") validation_dir = os.path.join(image_path, "val") assert os.path.exists(train_dir), "cannot find {}".format(train_dir) assert os.path.exists(validation_dir), "cannot find {}".format( validation_dir) # create direction for saving weights if not os.path.exists("save_weights"): os.makedirs("save_weights") im_height = 224 im_width = 224 batch_size = 32 epochs = 10 # class dict data_class = [ cla for cla in os.listdir(train_dir) if os.path.isdir(os.path.join(train_dir, cla)) ] class_num = len(data_class) class_dict = dict((value, index) for index, value in enumerate(data_class)) # reverse value and key of dict inverse_dict = dict((val, key) for key, val in class_dict.items()) # write dict into json file json_str = json.dumps(inverse_dict, indent=4) with open('class_indices.json', 'w') as json_file: json_file.write(json_str) # load train images list train_image_list = glob.glob(train_dir + "/*/*.jpg") random.shuffle(train_image_list) train_num = len(train_image_list) assert train_num > 0, "cannot find any .jpg file in {}".format(train_dir) train_label_list = [ class_dict[path.split(os.path.sep)[-2]] for path in train_image_list ] # load validation images list val_image_list = glob.glob(validation_dir + "/*/*.jpg") random.shuffle(val_image_list) val_num = len(val_image_list) assert val_num > 0, "cannot find any .jpg file in {}".format( validation_dir) val_label_list = [ class_dict[path.split(os.path.sep)[-2]] for path in val_image_list ] print("using {} images for training, {} images for validation.".format( train_num, val_num)) def process_path(img_path, label): label = tf.one_hot(label, depth=class_num) image = tf.io.read_file(img_path) image = tf.image.decode_jpeg(image) image = tf.image.convert_image_dtype(image, tf.float32) image = tf.image.resize(image, [im_height, im_width]) return image, label AUTOTUNE = tf.data.experimental.AUTOTUNE # load train dataset train_dataset = tf.data.Dataset.from_tensor_slices( (train_image_list, train_label_list)) train_dataset = train_dataset.shuffle(buffer_size=train_num)\ .map(process_path, num_parallel_calls=AUTOTUNE)\ .repeat().batch(batch_size).prefetch(AUTOTUNE) # load train dataset val_dataset = tf.data.Dataset.from_tensor_slices( (val_image_list, val_label_list)) val_dataset = val_dataset.map(process_path, num_parallel_calls=tf.data.experimental.AUTOTUNE)\ .repeat().batch(batch_size) # 实例化模型 model = vgg("vgg16", 224, 224, 5) model.summary() # using keras low level api for training loss_object = tf.keras.losses.CategoricalCrossentropy(from_logits=False) optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001) train_loss = tf.keras.metrics.Mean(name='train_loss') train_accuracy = tf.keras.metrics.CategoricalAccuracy( name='train_accuracy') test_loss = tf.keras.metrics.Mean(name='test_loss') test_accuracy = tf.keras.metrics.CategoricalAccuracy(name='test_accuracy') @tf.function def train_step(images, labels): with tf.GradientTape() as tape: predictions = model(images, training=True) loss = loss_object(labels, predictions) gradients = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) train_loss(loss) train_accuracy(labels, predictions) @tf.function def test_step(images, labels): predictions = model(images, training=False) t_loss = loss_object(labels, predictions) test_loss(t_loss) test_accuracy(labels, predictions) best_test_loss = float('inf') train_step_num = train_num // batch_size val_step_num = val_num // batch_size for epoch in range(1, epochs + 1): train_loss.reset_states() # clear history info train_accuracy.reset_states() # clear history info test_loss.reset_states() # clear history info test_accuracy.reset_states() # clear history info t1 = time.perf_counter() for index, (images, labels) in enumerate(train_dataset): train_step(images, labels) if index + 1 == train_step_num: break print(time.perf_counter() - t1) for index, (images, labels) in enumerate(val_dataset): test_step(images, labels) if index + 1 == val_step_num: break template = 'Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, Test Accuracy: {}' print( template.format(epoch, train_loss.result(), train_accuracy.result() * 100, test_loss.result(), test_accuracy.result() * 100)) if test_loss.result() < best_test_loss: model.save_weights("./save_weights/myVGG.ckpt".format(epoch), save_format='tf')
def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(device) data_transform = { "train": transforms.Compose([transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]), "val": transforms.Compose([transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])} data_root = os.path.abspath(os.path.join(os.getcwd(), "../..")) # get data root path image_path = data_root + "/data_set/flower_data/" # flower data set path train_dataset = datasets.ImageFolder(root=image_path+"train", transform=data_transform["train"]) train_num = len(train_dataset) # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4} flower_list = train_dataset.class_to_idx cla_dict = dict((val, key) for key, val in flower_list.items()) # write dict into json file json_str = json.dumps(cla_dict, indent=4) with open('class_indices.json', 'w') as json_file: json_file.write(json_str) batch_size = 32 train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=0) validate_dataset = datasets.ImageFolder(root=image_path + "val", transform=data_transform["val"]) val_num = len(validate_dataset) validate_loader = torch.utils.data.DataLoader(validate_dataset, batch_size=batch_size, shuffle=False, num_workers=0) # test_data_iter = iter(validate_loader) # test_image, test_label = test_data_iter.next() model_name = "vgg16" net = vgg(model_name=model_name, num_classes=5, init_weights=True) net.to(device) loss_function = nn.CrossEntropyLoss() optimizer = optim.Adam(net.parameters(), lr=0.0001) best_acc = 0.0 save_path = './{}Net.pth'.format(model_name) for epoch in range(30): # train net.train() running_loss = 0.0 for step, data in enumerate(train_loader, start=0): images, labels = data optimizer.zero_grad() outputs = net(images.to(device)) loss = loss_function(outputs, labels.to(device)) loss.backward() optimizer.step() # print statistics running_loss += loss.item() # print train process rate = (step + 1) / len(train_loader) a = "*" * int(rate * 50) b = "." * int((1 - rate) * 50) print("\rtrain loss: {:^3.0f}%[{}->{}]{:.3f}".format(int(rate * 100), a, b, loss), end="") print() # validate net.eval() acc = 0.0 # accumulate accurate number / epoch with torch.no_grad(): for val_data in validate_loader: val_images, val_labels = val_data optimizer.zero_grad() outputs = net(val_images.to(device)) predict_y = torch.max(outputs, dim=1)[1] acc += (predict_y == val_labels.to(device)).sum().item() val_accurate = acc / val_num if val_accurate > best_acc: best_acc = val_accurate torch.save(net.state_dict(), save_path) print('[epoch %d] train_loss: %.3f test_accuracy: %.3f' % (epoch + 1, running_loss / step, val_accurate)) print('Finished Training')
def main(): data_root = os.path.abspath(os.path.join(os.getcwd(), "../..")) # get data root path image_path = os.path.join(data_root, "data_set", "flower_data") # flower data set path train_dir = os.path.join(image_path, "train") validation_dir = os.path.join(image_path, "val") assert os.path.exists(train_dir), "cannot find {}".format(train_dir) assert os.path.exists(validation_dir), "cannot find {}".format( validation_dir) # create direction for saving weights if not os.path.exists("save_weights"): os.makedirs("save_weights") im_height = 224 im_width = 224 batch_size = 32 epochs = 10 # data generator with data augmentation train_image_generator = ImageDataGenerator(rescale=1. / 255, horizontal_flip=True) validation_image_generator = ImageDataGenerator(rescale=1. / 255) train_data_gen = train_image_generator.flow_from_directory( directory=train_dir, batch_size=batch_size, shuffle=True, target_size=(im_height, im_width), class_mode='categorical') total_train = train_data_gen.n # get class dict class_indices = train_data_gen.class_indices # transform value and key of dict inverse_dict = dict((val, key) for key, val in class_indices.items()) # write dict into json file json_str = json.dumps(inverse_dict, indent=4) with open('class_indices.json', 'w') as json_file: json_file.write(json_str) val_data_gen = validation_image_generator.flow_from_directory( directory=validation_dir, batch_size=batch_size, shuffle=False, target_size=(im_height, im_width), class_mode='categorical') total_val = val_data_gen.n print("using {} images for training, {} images for validation.".format( total_train, total_val)) model = vgg("vgg16", 224, 224, 5) model.summary() # using keras high level api for training model.compile( optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001), loss=tf.keras.losses.CategoricalCrossentropy(from_logits=False), metrics=["accuracy"]) callbacks = [ tf.keras.callbacks.ModelCheckpoint(filepath='./save_weights/myVGG.h5', save_best_only=True, save_weights_only=True, monitor='val_loss') ] # tensorflow2.1 recommend to using fit history = model.fit(x=train_data_gen, steps_per_epoch=total_train // batch_size, epochs=epochs, validation_data=val_data_gen, validation_steps=total_val // batch_size, callbacks=callbacks)
x_train = x_train.reshape(x_train.shape[0],48,48,1) x_val = x_val.reshape(x_val.shape[0],48,48,1) datagen = ImageDataGenerator( featurewise_center=False, samplewise_center=False, featurewise_std_normalization=False, samplewise_std_normalization=False, rotation_range=0, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=True, vertical_flip=True) datagen.fit(x_train) emotion_classifier = model.vgg() emotion_classifier.summary() history = model.History() tbCallBack = TensorBoard(log_dir=os.path.join('./','logs'), write_graph=True, write_images=False) emotion_classifier.fit_generator(datagen.flow(x_train, y_train, batch_size=100), steps_per_epoch=len(x_train) / 100, epochs=80, validation_data=(x_val,y_val), callbacks=[history, tbCallBack]) dump_history('./',history) emotion_classifier.save('model.h5') score = emotion_classifier.evaluate(x_train,y_train) print ('Train Acc:', score[1])
def main(): data_root = os.path.abspath(os.path.join(os.getcwd(), '../')) # get data root path print("data_root:" + str(data_root)) image_path = os.path.join(data_root, "flower_data") # flower data set path train_dir = os.path.join(image_path, "train") validation_dir = os.path.join(image_path, "val") assert os.path.exists(train_dir), "cannot find {}".format(train_dir) assert os.path.exists(validation_dir), "cannot find {}".format( validation_dir) # create direction for saving weights if not os.path.exists("save_weights"): os.makedirs("save_weights") # create direction for saving weights im_height = 224 im_width = 224 batch_size = 32 epochs = 10 # Average of Imagenet datasets with transfering learning _R_MEAN = 123.68 _G_MEAN = 116.78 _B_MEAN = 103.94 def pre_function(img): # transfering learning img = img - [_R_MEAN, _G_MEAN, _B_MEAN] return img # data generator with data augmentation train_image_generator = ImageDataGenerator( horizontal_flip=True, preprocessing_function=pre_function) validation_image_generator = ImageDataGenerator( preprocessing_function=pre_function) train_data_gen = train_image_generator.flow_from_directory( directory=train_dir, batch_size=batch_size, shuffle=True, target_size=(im_height, im_width), class_mode='categorical') total_train = train_data_gen.n # get class dict class_indices = train_data_gen.class_indices # transform valud and key of dict inverse_dict = dict((val, key) for key, val in class_indices.items()) # write dict into json file json_str = json.dumps(inverse_dict, indent=4) with open('class_indices.json', 'w') as json_file: json_file.write(json_str) val_data_gen = validation_image_generator.flow_from_directory( directory=validation_dir, batch_size=batch_size, shuffle=False, target_size=(im_height, im_width), class_mode='categorical') total_val = val_data_gen.n print("using {} images for training, {} images for validation.".format( total_train, total_val)) model = vgg('vgg16', 224, 224, 5) """ load pre trained model from directory """ # pre_weights_path='/pretain_weights.ckpt' # assert len(glob.glob(pre_weights_path+"*")), "cannot find{}".format(pre_weights_path) # model.load_weights(pre_weights_path) # for layer_t in model.layers: # if layer_t.name=='feature': # layer_t.trainable=False # break model.summary() # using keras high level api to trainning model.compile( optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001), loss=tf.keras.losses.CategoricalCrossentropy(from_logits=False), metrics=['accuracy']) callbacks = [ tf.keras.callbacks.ModelCheckpoint( filepath='./save_weights/myVgg_{epoch}.h5', save_best_only=True, save_weights_only=True, monitor='val_loss') ] history = model.fit(x=train_data_gen, steps_per_epoch=total_train // batch_size, epochs=epochs, validation_data=val_data_gen, validation_steps=total_val // batch_size, callbacks=callbacks) history_dict = history.history train_loss = history_dict["loss"] train_accuracy = history_dict["accuracy"] val_loss = history_dict["val_loss"] val_accuracy = history_dict["val_accuracy"] # figure 1 plt.figure() plt.plot(range(epochs), train_loss, label='train_loss') plt.plot(range(epochs), val_loss, label='val_loss') plt.legend() plt.xlabel('epochs') plt.ylabel('loss') # figure 2 plt.figure() plt.plot(range(epochs), train_accuracy, label='train_accuracy') plt.plot(range(epochs), val_accuracy, label='val_accuracy') plt.legend() plt.xlabel('epochs') plt.ylabel('accuracy') plt.show()
train_data = CifarData(train_filename, True) test_data = CifarData(test_filename, False) # 设计计算图 # 形状 [None, 3072] 3072 是 样本的维数, None 代表位置的样本数量 x = tf.placeholder(tf.float32, [None, 3072]) # 形状 [None] y的数量和x的样本数是对应的 y = tf.placeholder(tf.int64, [None]) # [None, ], eg: [0, 5, 6, 3] x_image = tf.reshape(x, [-1, 3, 32, 32]) # 将最开始的向量式的图片,转为真实的图片类型 x_image = tf.transpose(x_image, perm=[0, 2, 3, 1]) # conv1:神经元 feature_map 输出图像 图像大小: 32 * 32 y_ = model.vgg(x_image) # 使用交叉熵 设置损失函数 loss = tf.losses.sparse_softmax_cross_entropy(labels=y, logits=y_) # 该api,做了三件事儿 1. y_ -> softmax 2. y -> one_hot 3. loss = ylogy # 预测值 获得的是 每一行上 最大值的 索引.注意:tf.argmax()的用法,其实和 np.argmax() 一样的 predict = tf.argmax(y_, 1) # 将布尔值转化为int类型,也就是 0 或者 1, 然后再和真实值进行比较. tf.equal() 返回值是布尔类型 correct_prediction = tf.equal(predict, y) # 比如说第一行最大值索引是6,说明是第六个分类.而y正好也是6,说明预测正确 # 将上句的布尔类型 转化为 浮点类型,然后进行求平均值,实际上就是求出了准确率 accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float64)) with tf.name_scope('train_op'): # tf.name_scope() 这个方法的作用不太明白(有点迷糊!)
# load train dataset train_dataset = tf.data.Dataset.from_tensor_slices( (train_image_list, train_label_list)) train_dataset = train_dataset.shuffle(buffer_size=train_num)\ .map(process_path, num_parallel_calls=AUTOTUNE)\ .repeat().batch(batch_size).prefetch(AUTOTUNE) # load train dataset val_dataset = tf.data.Dataset.from_tensor_slices( (val_image_list, val_label_list)) val_dataset = val_dataset.map(process_path, num_parallel_calls=tf.data.experimental.AUTOTUNE)\ .repeat().batch(batch_size) # 实例化模型 model = vgg("vgg16", 224, 224, 5) model.summary() # using keras low level api for training loss_object = tf.keras.losses.CategoricalCrossentropy(from_logits=False) optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001) train_loss = tf.keras.metrics.Mean(name='train_loss') train_accuracy = tf.keras.metrics.CategoricalAccuracy(name='train_accuracy') test_loss = tf.keras.metrics.Mean(name='test_loss') test_accuracy = tf.keras.metrics.CategoricalAccuracy(name='test_accuracy') @tf.function def train_step(images, labels):
# load image img = Image.open("../tulip.jpg") plt.imshow(img) # [N, C, H, W] img = data_transform(img) # expand batch dimension img = torch.unsqueeze(img, dim=0) # read class_indict try: json_file = open('./class_indices.json', 'r') class_indict = json.load(json_file) except Exception as e: print(e) exit(-1) # create model model = vgg(model_name="vgg16", num_classes=3) # load model weights model_weight_path = "./vgg16Net.pth" model.load_state_dict(torch.load(model_weight_path)) model.eval() with torch.no_grad(): # predict class output = torch.squeeze(model(img)) predict = torch.softmax(output, dim=0) predict_cla = torch.argmax(predict).numpy() print(class_indict[str(predict_cla)]) plt.show()
print("Using {} images for training and {} images for validation.".format( train_num, val_num)) # val_loader val_loader = torch.utils.data.DataLoader(val_set, batch_size=4, shuffle=False, num_workers=nw) # 创建并保存分类对应表 flower_list = train_set.class_to_idx class_dict = dict((num, name) for name, num in flower_list.items()) class_json = json.dumps(class_dict, indent=4) with open('num_classes.json', 'w') as json_file: json_file.write(class_json) # 实例化net, loss_function, optimizer model_name = 'vgg13' net = vgg(model_name=model_name, num_classes=5, init_weights=True) loss_function = nn.CrossEntropyLoss() optimizer = optim.Adam(net.parameters(), lr=0.0001) # 设置当前训练模型所得参数的保存路径 save_path = './VGGNet_{}.pth'.format(model_name) best_acc = 0.0 for epoch in range(10): net.train() running_loss = 0.0 t1 = time.perf_counter() for step, data in enumerate(train_loader, start=0): images, labels = data optimizer.zero_grad() # t2 = time.perf_counter() outputs = net(images.to(device)) # images 是batch: [N, C, H, W]
import cv2 import numpy as np import os import model import torch from skimage import io import torchvision.transforms as transforms labels={'0':'anudeep','1':'saikrishna','2':'sricharan','3':'varun','4':'unknown'} cap = cv2.VideoCapture(0) vgg = model.vgg() vgg.load_state_dict(torch.load('./params/params.pth')) face_cascade = cv2.CascadeClassifier('cascades/data/haarcascade_frontalface_alt2.xml') while(True): # Capture frame-by-frame ret, test_img= cap.read() gray = cv2.cvtColor(test_img, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, scaleFactor=1.32, minNeighbors=5) transform = transforms.ToTensor() #image = io.imread(test_img) for (x, y, w, h) in faces: img = test_img[y:y + h, x:x + w] image = np.array(img, "uint8") image = transform(image) reshaped = image.permute(0, 1, 2).unsqueeze(0) print('processing........') out = vgg(reshaped) print('generating output....\nPlease wait...') _, pred = out.max(1) txt = labels[str(int(pred[0]))]
num_workers=0) validate_dataset = datasets.ImageFolder(root=image_path + "val", transform=data_transform["val"]) val_num = len(validate_dataset) validate_loader = torch.utils.data.DataLoader(validate_dataset, batch_size=batch_size, shuffle=False, num_workers=0) # test_data_iter = iter(validate_loader) # test_image, test_label = test_data_iter.next() model_name = "vgg16" # 定义网络 net = vgg(model_name=model_name, class_num=3, init_weights=True) # 加载预先训练的权重 # model_weight_path = "./vgg11(chest3)Net2.pth" # missing_keys, unexpected_keys = net.load_state_dict(torch.load(model_weight_path), strict=False) # 部署到设备上 net.to(device) # 定义损失函数 loss_function = nn.CrossEntropyLoss() # 定义优化器,优化对象是网络中所有可训练的参数 optimizer = optim.Adam(net.parameters(), lr=0.0001) # 定义最佳准确率,为了在之后训练过程中保存准确率最高的训练模型 best_acc = 0.0 # save_path = './{}Net.pth'.format(model_name)
def main(): data_root = os.path.abspath(os.path.join(os.getcwd(), "../..")) # get data root path image_path = os.path.join(data_root, "data_set", "flower_data") # flower data set path train_dir = os.path.join(image_path, "train") validation_dir = os.path.join(image_path, "val") assert os.path.exists(train_dir), "cannot find {}".format(train_dir) assert os.path.exists(validation_dir), "cannot find {}".format( validation_dir) # create direction for saving weights if not os.path.exists("save_weights"): os.makedirs("save_weights") im_height = 224 im_width = 224 batch_size = 32 epochs = 10 _R_MEAN = 123.68 _G_MEAN = 116.78 _B_MEAN = 103.94 def pre_function(img): # img = im.open('test.jpg') # img = np.array(img).astype(np.float32) img = img - [_R_MEAN, _G_MEAN, _B_MEAN] return img # data generator with data augmentation train_image_generator = ImageDataGenerator( horizontal_flip=True, preprocessing_function=pre_function) validation_image_generator = ImageDataGenerator( preprocessing_function=pre_function) train_data_gen = train_image_generator.flow_from_directory( directory=train_dir, batch_size=batch_size, shuffle=True, target_size=(im_height, im_width), class_mode='categorical') total_train = train_data_gen.n # get class dict class_indices = train_data_gen.class_indices # transform value and key of dict inverse_dict = dict((val, key) for key, val in class_indices.items()) # write dict into json file json_str = json.dumps(inverse_dict, indent=4) with open('class_indices.json', 'w') as json_file: json_file.write(json_str) val_data_gen = validation_image_generator.flow_from_directory( directory=validation_dir, batch_size=batch_size, shuffle=False, target_size=(im_height, im_width), class_mode='categorical') total_val = val_data_gen.n print("using {} images for training, {} images for validation.".format( total_train, total_val)) model = vgg("vgg16", 224, 224, 5) pre_weights_path = './pretrain_weights.ckpt' assert len(glob.glob(pre_weights_path + "*")), "cannot find {}".format(pre_weights_path) model.load_weights(pre_weights_path) for layer_t in model.layers: if layer_t.name == 'feature': layer_t.trainable = False break model.summary() # using keras high level api for training model.compile( optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001), loss=tf.keras.losses.CategoricalCrossentropy(from_logits=False), metrics=["accuracy"]) callbacks = [ tf.keras.callbacks.ModelCheckpoint( filepath='./save_weights/myAlex_{epoch}.h5', save_best_only=True, save_weights_only=True, monitor='val_loss') ] # tensorflow2.1 recommend to using fit history = model.fit(x=train_data_gen, steps_per_epoch=total_train // batch_size, epochs=epochs, validation_data=val_data_gen, validation_steps=total_val // batch_size, callbacks=callbacks)
(valid_images, valid_labels, valid_att), valid_iters = data.data_test(FLAGS.real_path, FLAGS.valid_label, FLAGS.batch_size) (test_images, test_labels, test_att), test_iters = data.data_test(FLAGS.real_path, FLAGS.test_label, FLAGS.batch_size) batch_images = tf.placeholder(tf.float32, [None, 128, 128, 3]) batch_labels = tf.placeholder(tf.int32, [ None, ]) is_training = tf.placeholder(tf.bool) lr_ph = tf.placeholder(tf.float32) lr = FLAGS.lr Y_score = model.vgg(batch_images, FLAGS.n_class, is_training) Y_hat = tf.nn.softmax(Y_score) Y_pred = tf.argmax(Y_hat, 1) Y_label = tf.to_float(tf.one_hot(batch_labels, FLAGS.n_class)) cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=Y_score, labels=Y_label) loss_op = tf.reduce_mean(cross_entropy) correct_prediction = tf.equal(tf.argmax(Y_hat, 1), tf.argmax(Y_label, 1)) acc_op = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) update_op = tf.train.MomentumOptimizer(lr_ph, FLAGS.momentum).minimize(loss_op) init = tf.global_variables_initializer() print("================\n\n", train_iters, fake_iters) with tf.Session() as sess:
def main(): device = torch.device( "cuda:0" if torch.cuda.is_available() else "cpu") ##优先使用GPU设备 print("using {} device.".format(device)) data_transform = { "train": transforms.Compose([ transforms.RandomResizedCrop(224), ##随机裁剪 transforms.RandomHorizontalFlip(), ##随机水平翻转 transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]), "val": transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) } data_root = os.path.abspath(os.path.join(os.getcwd(), "../..")) # get data root path image_path = os.path.join(data_root, "data_set", "FACEA") # flower data set path assert os.path.exists(image_path), "{} path does not exist.".format( image_path) train_dataset = datasets.ImageFolder(root=os.path.join( image_path, "Train"), transform=data_transform["train"]) train_num = len(train_dataset) # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4} flower_list = train_dataset.class_to_idx cla_dict = dict((val, key) for key, val in flower_list.items()) # write dict into json file json_str = json.dumps(cla_dict, indent=4) with open('class_indices.json', 'w') as json_file: ##写入json文件 json_file.write(json_str) batch_size = 16 nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8]) # number of workers print('Using {} dataloader workers every process'.format(nw)) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=nw) validate_dataset = datasets.ImageFolder(root=os.path.join( image_path, "Validation"), transform=data_transform["val"]) val_num = len(validate_dataset) validate_loader = torch.utils.data.DataLoader(validate_dataset, batch_size=batch_size, shuffle=False, num_workers=nw) print("using {} images for training, {} images fot validation.".format( train_num, val_num)) test_data_iter = iter(validate_loader) test_image, test_label = test_data_iter.next() print(validate_loader) model_name = "vgg13" net = vgg(model_name=model_name, num_classes=85, init_weights=True) net.to(device) loss_function = nn.CrossEntropyLoss() optimizer = optim.Adam(net.parameters(), lr=0.00005) epochs = 500 best_acc = 0.0 save_path = './{}Net.pth'.format(model_name) train_steps = len(train_loader) KL = nn.KLDivLoss(size_average=True, reduce=True) for epoch in range(epochs): # train net.train() ##开启dropout方法 running_loss = 0.0 train_bar = tqdm(train_loader) for step, data in enumerate(train_bar): images, labels = data images = images.to(device) labels = labels.to(device) optimizer.zero_grad() outputs = net(images) #loss = loss_function(outputs, labels) labels = labels.cpu().numpy() label_tensor = [] for i in labels: label_dis, _ = generate_label(i) label_tensor.append(label_dis) label_tensor = torch.Tensor( label_tensor) ## data put to cuda memory label_tensor = label_tensor.to(device) outputs = F.log_softmax(outputs, dim=-1) # label_dis, _ = generate_label(labels) # print(label_tensor) loss = KL(outputs, label_tensor) criterion = nn.L1Loss(reduction='mean') loss2 = criterion(outputs, label_tensor) #loss=loss1+loss2 loss.backward() optimizer.step() # print statistics running_loss += loss.item() train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format( epoch + 1, epochs, loss) # read class_indict json_path = './class_indices.json' assert os.path.exists(json_path), "file: '{}' dose not exist.".format( json_path) json_file = open(json_path, "r") class_indict = json.load(json_file) # validate net.eval() ##关闭dropout方法 acc = 0.0 # accumulate accurate number / epoch with torch.no_grad(): for data_test in validate_loader: val_images, val_labels = data_test outputs = net(val_images.to(device)) predict_y = torch.max(outputs, dim=1)[1] predict = torch.softmax(outputs, dim=1) # acc += torch.eq(predict_y, val_labels.to(device)).sum().item() list_tensor = predict.cpu().numpy().tolist() pre_list = [] for i in range(len(list_tensor)): res = 0 zz = (np.sum(list_tensor[i])) for index, j in enumerate(list_tensor[i]): p = class_indict[str(index)] res = res + int(class_indict[str(index)]) * j pre_list.append((res)) val_list = val_labels.numpy().tolist() error = [] for i in range(len(val_list)): error.append(pre_list[i] - val_list[i]) absError = [] for val in error: absError.append(abs(val)) acc += sum(absError) val_accurate = acc / val_num print('[epoch %d] train_loss: %.3f val_accuracy: %.3f' % (epoch + 1, running_loss / train_steps, val_accurate)) if val_accurate > best_acc: best_acc = val_accurate torch.save(net.state_dict(), save_path) print('Finished Training')
# load image img = Image.open("测试图片(病毒性肺炎).jpeg").convert('RGB') plt.imshow(img) # [N, C, H, W] img = data_transform(img) # expand batch dimension img = torch.unsqueeze(img, dim=0) # read class_indict try: json_file = open('class_indices(chest3).json', 'r') class_indict = json.load(json_file) except Exception as e: print(e) exit(-1) # create model model = vgg(model_name="vgg11", class_num=3) # load model weights model_weight_path = "vgg11(chest3)Net.pth" model.load_state_dict(torch.load(model_weight_path)) model.eval() with torch.no_grad(): # predict class output = torch.squeeze(model(img)) predict = torch.softmax(output, dim=0) predict_cla = torch.argmax(predict).numpy() print(class_indict[str(predict_cla)]) plt.title = class_indict[str(predict_cla)] plt.show()
def content_loss(vgg, hr, sr): sr = tf.keras.applications.vgg19.preprocess_input(sr) hr = tf.keras.applications.vgg19.preprocess_input(hr) sr_features = vgg(sr) / 12.75 hr_features = vgg(hr) / 12.75 return mean_squared_error(hr_features, sr_features)
def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print("using {} device.".format(device)) data_transform = { "train": transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]), "val": transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) } data_root = os.path.abspath(os.path.join(os.getcwd(), "../..")) # get data root path image_path = os.path.join(data_root, "data_set", "flower_data") # flower data set path assert os.path.exists(image_path), "{} path does not exist.".format( image_path) train_dataset = datasets.ImageFolder(root=os.path.join( image_path, "train"), transform=data_transform["train"]) train_num = len(train_dataset) # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4} flower_list = train_dataset.class_to_idx cla_dict = dict((val, key) for key, val in flower_list.items()) # write dict into json file json_str = json.dumps(cla_dict, indent=4) with open('class_indices.json', 'w') as json_file: json_file.write(json_str) batch_size = 32 nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8]) # number of workers print('Using {} dataloader workers every process'.format(nw)) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=nw) validate_dataset = datasets.ImageFolder(root=os.path.join( image_path, "val"), transform=data_transform["val"]) val_num = len(validate_dataset) validate_loader = torch.utils.data.DataLoader(validate_dataset, batch_size=batch_size, shuffle=False, num_workers=nw) print("using {} images for training, {} images fot validation.".format( train_num, val_num)) # test_data_iter = iter(validate_loader) # test_image, test_label = test_data_iter.next() model_name = "vgg16" net = vgg(model_name=model_name, num_classes=5, init_weights=True) net.to(device) loss_function = nn.CrossEntropyLoss() optimizer = optim.Adam(net.parameters(), lr=0.0001) epochs = 30 best_acc = 0.0 save_path = './{}Net.pth'.format(model_name) train_steps = len(train_loader) for epoch in range(epochs): # train net.train() running_loss = 0.0 train_bar = tqdm(train_loader) for step, data in enumerate(train_bar): images, labels = data optimizer.zero_grad() outputs = net(images.to(device)) loss = loss_function(outputs, labels.to(device)) loss.backward() optimizer.step() # print statistics running_loss += loss.item() train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format( epoch + 1, epochs, loss) # validate net.eval() acc = 0.0 # accumulate accurate number / epoch with torch.no_grad(): val_bar = tqdm(validate_loader, colour='green') for val_data in val_bar: val_images, val_labels = val_data outputs = net(val_images.to(device)) predict_y = torch.max(outputs, dim=1)[1] acc += torch.eq(predict_y, val_labels.to(device)).sum().item() val_accurate = acc / val_num print('[epoch %d] train_loss: %.3f val_accuracy: %.3f' % (epoch + 1, running_loss / train_steps, val_accurate)) if val_accurate > best_acc: best_acc = val_accurate torch.save(net.state_dict(), save_path) print('Finished Training')
testset = torchvision.datasets.CIFAR100(root='./data', train=False, download=True, transform=transform_test) testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=2) classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') logging.info("Train Net:{}".format(args.model)) if args.model == 'preresnet': net = preresnet(depth=40) elif args.model == 'vgg': net = vgg() elif args.model == 'refine': refine_model = 'model_result/vgg19_prun_best_ckpt.t7' checkpoint = torch.load(refine_model) net = vgg(cfg=checkpoint['cfg']) net.load_state_dict(checkpoint['state_dict']) net.to(device) # if device == 'cuda': # #model = nn.DataParallel(net, device_ids=[0, 1]) # multi-GPU # net = torch.nn.DataParallel(net) # cudnn.benchmark = True # if args.resume: # # Load checkpoint. # print('==> Resuming from checkpoint..') # assert os.path.isdir('checkpoint'), 'Error: no checkpoint directory found!'