def build_transform(): CIFAR_MEAN = [0.5071, 0.4865, 0.4409] CIFAR_STD = [0.1942, 0.1918, 0.1958] train_transforms = Compose([ RandomCrop(32, padding=4), ContrastTransform(0.1), BrightnessTransform(0.1), RandomHorizontalFlip(), RandomRotation(15), ToArray(), Normalize(CIFAR_MEAN, CIFAR_STD), ]) test_transforms = Compose([ToArray(), Normalize(CIFAR_MEAN, CIFAR_STD)]) return train_transforms, test_transforms
def test_with_dataloader(self): for device in self.devices: paddle.set_device(device) # data loader transform = Compose( [Normalize( mean=[127.5], std=[127.5], data_format='CHW')]) train_dataset = paddle.vision.datasets.MNIST( mode='train', transform=transform) train_loader = paddle.io.DataLoader( train_dataset, batch_size=64, shuffle=True, drop_last=True, num_workers=0) for batch_id, (image, _) in enumerate(train_loader()): out = self.custom_ops[0](image) pd_out = paddle.nn.functional.relu(image) self.assertTrue( np.array_equal(out, pd_out), "custom op out: {},\n paddle api out: {}".format(out, pd_out)) if batch_id == 5: break
def compute_features(model, use_flip, batch_size, workers, data_path): ccrop = transforms.Compose([ ToArray(), Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], data_format='CHW'), ]) ref_dataset = EvalDataset( os.path.dirname(data_path), os.path.basename(data_path), ccrop) eval_loader = paddle.io.DataLoader( ref_dataset, batch_size=batch_size, shuffle=False, drop_last=False, num_workers=workers) batch_time = AverageMeter('Time', ':6.3f') progress = ProgressMeter( len(eval_loader), [batch_time]) outputs, targets = [], [] end = time.time() for i, (images, target) in enumerate(eval_loader): targets.extend(target) # compute output output = model(images, im_k=None, use_flip=use_flip, is_train=False) outputs.append(output) # measure elapsed time batch_time.update(time.time() - end) end = time.time() if i % 10 == 0: progress.display(i) embeddings = paddle.concat(outputs) return embeddings, targets
def build_aug(args): """build augmentation transforms Args: args: data augmentation config Return: transforms """ transforms = Compose([ RandomHorizontalFlip(), ToArray(), Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], data_format='CHW'), ]) return transforms
def predict_class(self, im, key): # 预测小关节的等级 from paddle.vision.transforms import Compose, Resize, Normalize, Transpose transforms = Compose([ Resize(size=(224, 224)), Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], data_format='HWC'), Transpose() ]) self.arthrosis[key][2].eval() im = np.expand_dims(im, 2) infer_data = transforms(im) infer_data = np.expand_dims(infer_data, 0) infer_data = paddle.to_tensor(infer_data, dtype='float32') result = self.arthrosis[key][2](infer_data)[0] # 关键代码,实现预测功能 result = np.argmax(result.numpy()) # 获得最大值所在的序号 return result
def __init__(self, cfg, train=True): super(ImageNet, self).__init__() self.cfg = cfg self.train = train self.data_infor = get_data(cfg.Data.dataset) self.traindir = os.path.join(cfg.Data.Dir, 'train') self.valdir = os.path.join(cfg.Data.Dir, 'val') self.catedict = dict( zip(sorted(os.listdir(self.valdir)[:1000]), range(1000))) # transform # assured inumpyut is CHW self.normalize = Normalize(mean=self.data_infor.mean, std=self.data_infor.std, data_format='CHW') self.transform_train = [ RandomResizedCrop(cfg.Trans.crop_size, scale=(cfg.Trans.min_area_ratio, 1.0), ratio=(3. / 4, cfg.Trans.aspect_ratio)) ] if self.data_infor.eigval is not None and self.data_infor.eigvec is not None \ and cfg.Trans.random_color: lighting = Lighting(0.1, self.data_infor.eigval, self.data_infor.eigvec) jitter = ColorJitter(0.4, 0.4, 0.4) self.transform_train.extend([jitter, lighting]) self.transform_train.extend( [RandomHorizontalFlip(), ToTensor(), self.normalize]) self.transform_train = Compose(self.transform_train) self.transform_val = Compose([ Resize(cfg.Trans.scale_size), CenterCrop(cfg.Trans.crop_size), ToTensor(), self.normalize ]) self.file_list = self.get_samples()
learning_rate=LinearWarmup( CosineAnnealingDecay(LR, MAX_EPOCH), 2000, 0., LR), momentum=MOMENTUM, parameters=model.parameters(), weight_decay=WEIGHT_DECAY), paddle.nn.CrossEntropyLoss(), paddle.metric.Accuracy(topk=(1, 5))) transforms = Compose([ RandomCrop(32, padding=4), RandomApply(BrightnessTransform(0.1)), RandomApply(ContrastTransform(0.1)), RandomHorizontalFlip(), RandomRotation(15), ToArray(), Normalize(CIFAR_MEAN, CIFAR_STD), ]) val_transforms = Compose([ToArray(), Normalize(CIFAR_MEAN, CIFAR_STD)]) train_set = Cifar100(DATA_FILE, mode='train', transform=transforms) test_set = Cifar100(DATA_FILE, mode='test', transform=val_transforms) callbacks = [LRSchedulerM(), callbacks.VisualDL( 'vis_logs/res20_3x3_lr0.1cos_e300_bs128_bri_con_aug')] model.fit( train_set, test_set, epochs=MAX_EPOCH, batch_size=BATCH_SIZE, shuffle=True, num_workers=4, verbose=1, callbacks=callbacks,
paddle.enable_static() paddle.set_device("gpu") # model image = static.data(shape=[None, 1, 28, 28], name='image', dtype='float32') label = static.data(shape=[None, 1], name='label', dtype='int64') net = LeNet() out = net(image) loss = nn.functional.cross_entropy(out, label) opt = paddle.optimizer.Adam(learning_rate=0.001) opt.minimize(loss) # data loader transform = Compose([Normalize(mean=[127.5], std=[127.5], data_format='CHW')]) train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=transform) train_loader = paddle.io.DataLoader(train_dataset, feed_list=[image, label], batch_size=BATCH_SIZE, shuffle=True, drop_last=True, num_workers=2) # prepare exe = static.Executor() exe.run(static.default_startup_program()) places = paddle.static.cuda_places() compiled_program = static.CompiledProgram( static.default_main_program()).with_data_parallel(loss_name=loss.name,
def inference(model, left_imgs, right_ims, LOG): stages = 4 model.eval() transform = Compose([ToTensor(), Normalize(mean=imagenet_stats["mean"], std=imagenet_stats["std"])]) for index in range(len(left_imgs)): # LOG.info("left = {}\tright = {}".format(left_imgs[index], right_ims[index])) left_img = cv2.imread(left_imgs[index], cv2.IMREAD_UNCHANGED) right_img = cv2.imread(right_ims[index], cv2.IMREAD_UNCHANGED) h, w, c = left_img.shape th, tw = 368, 1232 if h<th or w<tw: continue left_img = left_img[h - th:h, w - tw:w, :] right_img = right_img[h - th:h, w - tw:w, :] left_input = transform(left_img[:, :, ::-1]).unsqueeze(axis=0) right_input = transform(right_img[:, :, ::-1]).unsqueeze(axis=0) with paddle.no_grad(): start_time = time.time() outputs = model(left_input, right_input) cost_time = time.time()-start_time ss = "Inference 4 stages cost = {:.3f} sec, FPS = {:.1f}".format(cost_time, 1/cost_time) for stage in range(stages): outputs[stage] = outputs[stage].squeeze(axis=[0, 1]).numpy().astype(np.uint8) color_disp = cv2.applyColorMap(cv2.convertScaleAbs(outputs[stage], alpha=1, beta=0), cv2.COLORMAP_JET) if args.left_img: temp_path = args.left_img.split("/")[0:-1] temp_path = "/".join(temp_path) save_img_path = os.path.join(temp_path, str(stage+1)+".png") cv2.imwrite(save_img_path, color_disp) LOG.info("{}\t\tSave img = {}".format(ss, save_img_path)) if args.vis: concat_img = np.concatenate((left_img, color_disp), axis=0) # cv2.imshow("left_img", left_img) # cv2.imshow("raw_disp", outputs[stage]) # cv2.imshow("color_disp", color_disp) cv2.imshow("concat_img", concat_img) key = cv2.waitKey(0) if key == ord("q"): break if not args.left_img: img_name = left_imgs[index].split("/")[-1] save_img_path = os.path.join(args.save_path, img_name) cv2.imwrite(save_img_path, color_disp) LOG.info("{}\t\tSave img = {}".format(ss, save_img_path))
import paddle from paddle import nn from paddle import optimizer from paddle.vision.transforms import Compose, Normalize from paddle.vision.transforms import ToTensor import paddle.distributed as dist from model_zoo import Model transform_tuple = Compose([ToTensor(), Normalize()]) parallel_flag = False if __name__ == '__main__': if parallel_flag: dist.init_parallel_env() leakRelu_crossEntropy_adam = Model(transform_tuple, nn.LeakyReLU, nn.CrossEntropyLoss, optimizer.Adam) leakRelu_crossEntropy_adam.train() leakRelu_crossEntropy_adam.validate() relu_crossEntropy_sgd = Model(transform_tuple, nn.ReLU, nn.CrossEntropyLoss, optimizer.SGD) relu_crossEntropy_sgd.train() relu_crossEntropy_sgd.validate() leakReLuCrossEntropySgd = Model(transform_tuple, nn.LeakyReLU,
self.linear3 = paddle.nn.Linear(in_features=100, out_features=10) def forward(self, x): # x = x.reshape((-1, 1, 28, 28)) x = self.flatten(x) x = self.linear1(x) x = self.act1(x) x = self.linear2(x) x = self.act2(x) x = self.linear3(x) return x if __name__ == '__main__': print("load file") transform = Normalize(mean=[127.5], std=[127.5], data_format='CHW') # 使用transform对数据集做归一化 print('download training data and load training data') train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=transform) test_dataset = paddle.vision.datasets.MNIST(mode='test', transform=transform) print('load finished') print("show file") train_data0, train_label_0 = train_dataset[0][0], train_dataset[0][1] train_data0 = train_data0.reshape([28, 28]) plt.figure(figsize=(2, 2)) plt.imshow(train_data0, cmap=plt.cm.binary) print('train_data0 label is: ' + str(train_label_0))
class Discriminator(nn.layer): def __init__(self): super(Discriminator, self).__init__() self.dis == nn.Sequential( nn.Conv2D(1, 64, 4, 2, 1, bias_attr=False), nn.LeakyReLU(0.2), nn.Conv2D(64, 64 * 2, 4, 2, 1, bias_attr=False), nn.BatchNorm2D(64 * 2), nn.LeakyReLU(0.2), nn.Conv2D(64 * 2, 64 * 4, 4, 2, 1, bias_attr=False), nn.BatchNorm2D(64 * 4), nn.LeakyReLU(0.2), nn.Conv2D(64 * 4, 1, 4, 1, 0, bias_attr=False), nn.Sigmoid()) def forward(self, x): return self.dis(x) if __name__ == '__main__': train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=Compose([ Resize(size=(32, 32)), Normalize(mean=[127.5], std=[127.5]) ])) dataloader = paddle.io.DataLoader(dataset=train_dataset, batch_size=32, shuffle=True, num_workers=4) for data in dataloader: break print(data[0].shape)
URL = { "RN50": "https://bj.bcebos.com/paddleaudio/examples/clip/RN50.pdparams", "RN101": "https://bj.bcebos.com/paddleaudio/examples/clip/RN101.pdparams", "VIT": "https://bj.bcebos.com/paddleaudio/examples/clip/ViT-B-32.pdparam", } MEAN, STD = (0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711) _tokenizer = SimpleTokenizer() transform = Compose([ Resize(224, interpolation="bicubic"), CenterCrop(224), lambda image: image.convert("RGB"), ToTensor(), Normalize(mean=MEAN, std=STD), lambda t: t.unsqueeze_(0), ]) def tokenize(texts: Union[str, List[str]], context_length: int = 77): """ Returns the tokenized representation of given input string(s) Parameters ---------- texts : Union[str, List[str]] An input string or a list of input strings to tokenize context_length : int The context length to use; all CLIP models use 77 as the context length Returns -------
import paddle import paddle.nn as nn import paddle.nn.functional as F from paddle.io import Dataset from paddle.vision.transforms import Compose, Normalize from paddle.vision.models import LeNet import math import numpy as np import random import os from PIL import Image normalize = Normalize(mean=[127.5], std=[127.5], data_format='HWC') #创建数据集读取 class RandomDataset(Dataset): def __init__(self, root="data", mode="train"): self.mode = mode if mode == "train": self.txt_file = os.path.join(root, "train.txt") else: self.txt_file = os.path.join(root, "test.txt") self.records_list = [] self.parse_dataset() def __getitem__(self, idx): path = self.records_list[idx][0] img = Image.open(path) img = img.resize((28, 28), Image.BILINEAR) img = normalize(img)