label_species = int(self.file_info.iloc[idx]['species']) label_classes = int(self.file_info.iloc[idx]['classes']) sample = { 'image': image, 'species': label_species, 'classes': label_classes } if self.transform: sample['image'] = self.transform(image) return sample train_transforms = transforms.Compose([ transforms.Resize((500, 500)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), ]) #?0.5??????????PIL?? val_transforms = transforms.Compose( [transforms.Resize((500, 500)), transforms.ToTensor()]) train_dataset = MyDataset(root_dir=ROOT_DIR + TRAIN_DIR, annotations_file=TRAIN_ANNO, transform=train_transforms) test_dataset = MyDataset(root_dir=ROOT_DIR + VAL_DIR, annotations_file=VAL_ANNO, transform=val_transforms) train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
def corrupted_cifar_uncertainty(method, batch_size, use_extra_corruptions=False, dataset='cifar10', normalize=False): assert dataset in ['cifar100', 'cifar10'] if dataset == 'cifar10': dataset = CorruptedCifar10 t = [ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)) ] else: dataset = CorruptedCifar100 t = [ transforms.ToTensor(), transforms.Normalize((0.5071, 0.4867, 0.4408), (0.2675, 0.2565, 0.2761)) ] if use_extra_corruptions: corruptions = chain(BENCHMARK_CORRUPTIONS, EXTRA_CORRUPTIONS) else: corruptions = BENCHMARK_CORRUPTIONS scores = {name: {} for name in corruptions} entropy = {name: {} for name in corruptions} preds = {name: {} for name in corruptions} eces = {name: {} for name in corruptions} true_labels = None for name in corruptions: for severity in range(1, 6): # CIFAR 10 loader = torch.utils.data.DataLoader(dataset=dataset( './datasets/', download=True, corruption=name, severity=severity, transform=transforms.Compose(t)), batch_size=batch_size, shuffle=False, pin_memory=True, num_workers=4) ece, _, _, _ = ece_score(method, loader) eces[name][severity] = ece scores[name][severity] = eval_method(method, dataset=loader) probs, labels, predictions = get_logits(method, loader) if true_labels is None: true_labels = labels hs = [] for x, y in loader: # true.extend(y.tolist()) p, _ = method.predict_proba(x, y, True) plog = (p + 1e-12).log() h = plog * p if normalize: h = h / np.log(h.shape[-1]) h = -torch.sum(h, -1) hs.extend(h.tolist()) entropy[name][severity] = hs preds[name][severity] = predictions return entropy, preds, scores, true_labels
from sklearn.preprocessing import OneHotEncoder #图片路径 train_list = sorted([ os.path.join('dataset1/train/', img) for img in os.listdir('dataset1/train/') ]) trainGT_list = sorted([ os.path.join('dataset1/train_GT/SEG/', img) for img in os.listdir('dataset1/train_GT/SEG/') ]) imgsize = 628 #??? data_transforms = transforms.Compose([ #transforms.RandomHorizontalFlip() #transforms.Pad(92,padding_mode='symmetric'), transforms.ToTensor(), transforms.Normalize([0.5], [0.5]) ]) datalabel_transforms = transforms.Compose([ transforms.ToTensor(), ]) #numpy形式 def loadpro_img(file_names): images = [] for file_name in file_names: img = cv2.imread(file_name, -1) #读取时不做改变,默认参数1加载彩色图片 img = img.astype(np.uint8) #img = Image.fromarray(img) images.append(img)
if True: std = tch.exp(0.5 * logvar) eps = tch.randn_like(std) return eps.mul(std).add_(mu) else: return mu def loss_function(recon_x, x, mu, logvar): BCE = F.binary_cross_entropy(recon_x, x.view(-1, 784), size_average=False) KLD = -0.5 * tch.sum(1 + logvar - mu.pow(2) - logvar.exp()) return BCE + KLD tr = transforms.Compose([transforms.ToTensor()]) train = MNIST('./data', transform=tr, download=True) test = MNIST('./data', transform=tr, train=False, download=True) epoch = 10 batch_size = 30 train = DataLoader(train, batch_size, True) test = DataLoader(test, batch_size, False) vae = VAE((1, 28, 28), 12) sgd = tch.optim.RMSprop(vae.parameters()) mse = nn.MSELoss(size_average=False) for j in range(epoch): con = 0 dis = 0
def gen_transform_validation(crop_size=448): return transforms.Compose([ transforms.CenterCrop(crop_size), transforms.ToTensor(), transforms.Normalize(mean=[0.5], std=[0.5]) ])
def build_transforms(cfg): return transforms.Compose(transforms.ToTensor())
import argparse import pickle import numpy as np import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader from torchvision import datasets from torchvision.models import resnet18 from torchvision.transforms import transforms from tensorboardX import SummaryWriter writer = SummaryWriter() transform = transforms.Compose([ transforms.Resize(255), transforms.RandomCrop(224), transforms.ToTensor() ]) parser = argparse.ArgumentParser() parser.add_argument('--dataset-dir', type=str, default='PKUMMDv1', help='dataset directory') parser.add_argument('--gpu', default=False, action='store_true', help='whether to use gpus for training') parser.add_argument('--batch-size', type=int, default=128, help='batch size') parser.add_argument('--learning-rate', type=float,
def main(args, cfgs): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') logging.info(f'Using device {device}') ############################################ class_names = cfgs["class_names"] n_classes = cfgs["n_classes"] multi_gpu = cfgs["gpus"] Net = cfgs["net_name"] image_root = cfgs["image_root"] epochs = cfgs["epochs"] batch_size_train = cfgs["batch_size_train"] checkpoint_dir = cfgs["checkpoint_dir"] checkpoint_space = cfgs["checkpoint_space"] if not os.path.exists(checkpoint_dir): os.makedirs(checkpoint_dir) ############################################ validate_flag = args.validate model_load_path = args.checkpoint_path ############################################ try: if Net == "deeplab": net = DeepLab(num_classes = n_classes) elif Net == "resunet": net = ResUNet(3, n_classes) net.apply(weights_init) elif Net == "unet": net = UNet(n_channels = 3, n_classes = n_classes) elif Net == "R2U_Net": net = R2U_Net(img_ch=3,output_ch=n_classes,t=3) elif Net == "AttU_Net": net = AttU_Net(img_ch=3,output_ch=n_classes) elif Net == "R2AttU_Net": net = R2AttU_Net(img_ch=3,output_ch=n_classes,t=3) elif Net == "U_Net": net = U_Net(img_ch=3,output_ch=n_classes) net.to(device = device) if multi_gpu > 1: net = nn.parallel.DataParallel(net) ############################################ optimizer = optim.Adam(net.parameters()) if n_classes > 1: criterion = nn.CrossEntropyLoss() # criterion = MultiClassDiceLoss() else: criterion = nn.BCEWithLogitsLoss() ############################################ # todo transformer transform_train = transforms.Compose([ #transforms.Resize((307, 409)), transforms.ToTensor(), ]) transform_val = transforms.Compose([ #transforms.Resize((307, 409)), transforms.ToTensor(), ]) ############################################ n_folds = 4 imageDir = os.path.join(image_root, "digestpath_img_patch") #maskDir = os.path.join(image_root, "digestpath_mask_patch") typeNames = ["normal", "low level", "high level"] #typeNames = [ "high level"] trainImagePaths = [] validImagePaths = [] testImagePaths = [] for i in range(len(typeNames)): print(typeNames[i]) subDir = os.path.join(imageDir, typeNames[i]) subjectIds = os.listdir(subDir) tmpIndex1 = len(subjectIds) // n_folds tmpIndex2 = len(subjectIds) // n_folds * 2 for subjectId in subjectIds[tmpIndex2:]: subjectDir = os.path.join(subDir, subjectId) for fileName in os.listdir(subjectDir): filePath = os.path.join(subjectDir, fileName) trainImagePaths.append(filePath) for subjectId in subjectIds[:tmpIndex1]: subjectDir = os.path.join(subDir, subjectId) for fileName in os.listdir(subjectDir): filePath = os.path.join(subjectDir, fileName) validImagePaths.append(filePath) for subjectId in subjectIds[tmpIndex1:tmpIndex2]: #for subjectId in subjectIds: subjectDir = os.path.join(subDir, subjectId) for fileName in os.listdir(subjectDir): filePath = os.path.join(subjectDir, fileName) testImagePaths.append(filePath) trainMaskPaths = [p.replace("/digestpath_img_patch/", "/digestpath_mask_patch/")[:-4]+".npy" for p in trainImagePaths] validMaskPaths = [p.replace("/digestpath_img_patch/", "/digestpath_mask_patch/")[:-4]+".npy" for p in validImagePaths] testMaskPaths = [p.replace("/digestpath_img_patch/", "/digestpath_mask_patch/")[:-4]+".npy" for p in testImagePaths] print("train-set #", len(trainMaskPaths)) print("valid-set #", len(validMaskPaths)) print("test-set #", len(testMaskPaths)) ############################################ train_set = wsiDataset(trainImagePaths, trainMaskPaths, transform_train) train_loader = DataLoader(train_set, batch_size=batch_size_train, num_workers=4, shuffle=True) val_set = wsiDataset(validImagePaths, validMaskPaths, transform_val) val_loader = DataLoader(val_set, batch_size=1, num_workers=4, shuffle=False) test_set = wsiDataset(testImagePaths, testMaskPaths, transform_val) test_loader = DataLoader(test_set, batch_size=1, num_workers=4, shuffle=False) ############################################ if validate_flag: if os.path.exists(model_load_path): net.load_state_dict(torch.load(model_load_path, map_location = device)) logging.info(f'Checkpoint loaded from {model_load_path}') validate_args = {"n_classes":n_classes, "checkpoint_dir":checkpoint_dir, "checkpoint_space":checkpoint_space,} diceRes, iouRes = validate(test_loader, net, criterion, device, validate_args) logging.info(f'Test-dataset dice: {diceRes} !') logging.info(f'Test-dataset iou: {iouRes} !') else: logging.info(f'No such checkpoint !') else: # todo lr_scheduler train_args = {"n_classes":n_classes, "epochs":epochs, "checkpoint_dir":checkpoint_dir, "checkpoint_space":checkpoint_space,} train(train_loader, val_loader, net, criterion, optimizer, device, train_args) except KeyboardInterrupt: torch.save(net.state_dict(), os.path.join(checkpoint_dir,'INTERRUPTED.pth')) logging.info('Saved interrupt') try: sys.exit(0) except SystemExit: os._exit(0)
def __init__(self, root=r"C:\datasets\taco\tensors", augment_prob=0.0, reduce=0.0, image_size=84, tensors=True, random_seed=42, **kwargs): self.reduce = reduce self.tensors = tensors random.seed(random_seed) resize_train = transforms.Compose( [ transforms.Resize(image_size), transforms.CenterCrop(image_size), ] ) resize_test = transforms.Compose( [ transforms.Resize(image_size), transforms.CenterCrop(image_size), ] ) augment = transforms.Compose( [ # transforms.RandomRotation(degrees=15), transforms.RandomHorizontalFlip(p=0.5), # transforms.ColorJitter(), # transforms.RandomPerspective(p=0.2, distortion_scale=0.25), ] ) normalize = transforms.Compose( [ transforms.ToTensor(), transforms.Normalize(mean=MEAN, std=STD) ] ) self.test_transform = transforms.Compose( [ resize_test, normalize ] ) self.train_transform = transforms.Compose( [ resize_train, transforms.RandomApply([augment], p=augment_prob), normalize ] ) if not tensors: self.source_dataset_train = torchvision.datasets.ImageFolder(root=root) else: self.source_dataset_train = torchvision.datasets.DatasetFolder(root=root, loader=tensor_loader, extensions=('pt',)) self.dataset_train_size = len(self.source_dataset_train) items = [] labels = [] for i in range(self.dataset_train_size): items.append(ImageItem(self.source_dataset_train, i)) labels.append(self.source_dataset_train[i][1]) is_test = [0] * self.dataset_train_size super(TacoDataset, self).__init__(items, labels, is_test) self.train_subdataset, self.test_subdataset = self.subdataset.train_test_split() if reduce < 1: self.train_subdataset = self.train_subdataset.downscale(1 - reduce) else: self.train_subdataset = self.train_subdataset.balance(reduce)
query_dict[query_part] = np.random.choice([query_image for query_image in glob(os.path.join(query_folder, '%03d_*.png') %int(query_part))], arg.num_te) else: query_dict[query_part] = [query_image for query_image in glob(os.path.join(query_folder, '%03d_*.png') %int(query_part))] else: query_part_set = set([part_image.split('_')[0] for part_image in os.listdir(query_folder)]) query_dict = dict() for query_part in query_part_set: query_dict[query_part] = [query_image for query_image in glob(os.path.join(cad_base, furniture, query_part, '*.png'))] ## Input surface vs Query surface (Similarity Comparison) # Transformation transform_input = transforms.Compose([ transform_.Padded(), transform_.RandomResize(max_size=512, ratio=1.5), transforms.Resize([512, 512]), transform_.Binary(criterion=150), transforms.ToTensor(), transform_.MintoMax() ]) transform_query = transforms.Compose([ transforms.Resize([512, 512]), transform_.Binary(criterion=150), transforms.ToTensor(), transform_.MintoMax() ]) transform3D = transforms.Compose([ transforms.Resize([512, 512]), transforms.ToTensor(),])
import os import glob import cv2 import numpy as np import torch from torchvision.transforms import transforms from natsort import natsorted from models import resmasking_dropout1 from utils.datasets.fer2013dataset import EMOTION_DICT from barez import show transform = transforms.Compose( [ transforms.ToPILImage(), transforms.ToTensor(), ] ) def activations_mask(tensor): tensor = torch.squeeze(tensor, 0) tensor = torch.mean(tensor, 0) tensor = tensor.detach().cpu().numpy() tensor = np.maximum(tensor, 0) tensor = cv2.resize(tensor, (224, 224)) tensor = tensor - np.min(tensor) tensor = tensor / np.max(tensor) heatmap = cv2.applyColorMap(np.uint8(255 * tensor), cv2.COLORMAP_JET) return heatmap
# Title: 测试Dsb2018CellDataset数据集. # URL: # Date: 2020-12-23 # import torch from torch.utils.data import DataLoader from torchvision.transforms import transforms from unetzoo.dataset.dataset import DSB2018CellDataset if __name__ == '__main__': device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') x_transforms = transforms.Compose([ transforms.ToTensor(), # -> [0,1] transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) # ->[-1,1] ]) # mask只需要转换为tensor y_transforms = transforms.ToTensor() train_dataset = DSB2018CellDataset(r"train", transform=x_transforms, target_transform=y_transforms) train_dataloaders = DataLoader(train_dataset, batch_size=8) val_dataset = DSB2018CellDataset(r"val", transform=x_transforms, target_transform=y_transforms) val_dataloaders = DataLoader(val_dataset, batch_size=1) test_dataloaders = val_dataloaders print(len(train_dataloaders.dataset)) for x, y, _, mask in train_dataloaders: inputs = x
os.environ["CUDA_VISIBLE_DEVICES"] = '0' init_seeds(0) model = SVHN_Model1().cuda() test_path = sorted(glob.glob('D:/Projects/wordec/input/test/*.png')) # test_json = json.load(open('../input/test.json')) test_label = [[1]] * len(test_path) # print(len(test_path), len(test_label)) test_loader = torch.utils.data.DataLoader( SVHNDataset(test_path, test_label, transforms.Compose([ transforms.Resize((70, 140)), # transforms.RandomCrop((60, 120)), # transforms.ColorJitter(0.3, 0.3, 0.2), # transforms.RandomRotation(5), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [ 0.229, 0.224, 0.225]) ])), batch_size=40, shuffle=False, num_workers=0, ) # 加载保存的最优模型 model.load_state_dict(torch.load('D:/Projects/wordec/model.pt')) test_predict_label = predict(test_loader, model, 1) print(test_predict_label.shape) print('test_predict_label', test_predict_label)
def main(): args = parse_args() FRAME_LIMIT = args.frame_limit VIDEO_FILE = args.video_file DRAW_BOXES = args.draw_boxes SCORES_FILE = args.scores_file FOLDER = args.output_folder OUTPUT_VIDEO = args.output_video FACE_DETECTOR = args.face_detector USE_WEBCAM = args.use_webcam TRACK_BOXES = args.track_boxes THRESHOLD = args.threshold # load configs and set random seed configs = json.load(open("./configs/fer2013_config.json")) image_size = (configs["image_size"], configs["image_size"]) transform = transforms.Compose([transforms.ToPILImage(), transforms.ToTensor()]) detector = load_face_detector(FACE_DETECTOR) model = load_model() vid = cv2.VideoCapture(0) with torch.no_grad(): if USE_WEBCAM: while True: ret, img = vid.read() if img is None or ret is not True: continue faces = detector.detect_faces(img, THRESHOLD) img, _ = detect_emotions(model, img, faces, image_size, transform, DRAW_BOXES, TRACK_BOXES) cv2.imshow("img", img) if cv2.waitKey(1) == ord("q"): break cv2.destroyAllWindows() else: print(f">> Reading video from {VIDEO_FILE}") frames = collect_frames(VIDEO_FILE, FRAME_LIMIT) if TRACK_BOXES: df = pd.read_csv(SCORES_FILE, header=None, index_col=None, names=[ "track_id", "frame_id", "box_id", "x", "y", "x2", "y2"] + list(range(80))) df["abs_frame_id"] = df.frame_id + df.track_id - 128 df_faces = [] print(">> Detecting emotions") for i, frame in tqdm(enumerate(frames), total=len(frames)): faces = match_faces_bodies( frame, df[df.abs_frame_id == i], detector=detector, threshold=THRESHOLD ) frames[i], new_df_faces = detect_emotions(model, frame, faces, image_size, transform, DRAW_BOXES, TRACK_BOXES) df_faces += new_df_faces df_faces = pd.DataFrame(df_faces) print(f">> Saving box files at {FOLDER}") if os.path.exists(FOLDER): shutil.rmtree(FOLDER) os.mkdir(FOLDER) box_ids = df_faces.box_id.unique() for box_id in tqdm(box_ids, total=len(box_ids)): with open(os.path.join(FOLDER, f"person{box_id}.txt"), "w") as f: for _, frame in df_faces[df_faces.box_id == box_id].iterrows(): bbox = str([frame.x, frame.y, frame.x2, frame.y2]).replace(" ", "").strip("[]") emotion = list(frame.emotion.keys())[0] f.write(f"{frame.frame_id},{bbox},{emotion},{frame.emotion[emotion]}\n") else: print(">> Detecting emotions") for i, frame in tqdm(enumerate(frames), total=len(frames)): faces = detector.detect_faces(frame, THRESHOLD) frames[i], _ = detect_emotions(model, frame, faces, image_size, transform, DRAW_BOXES, TRACK_BOXES) print(f">> Creating video at {OUTPUT_VIDEO}") height, width, _ = frames[0].shape out = cv2.VideoWriter(OUTPUT_VIDEO, cv2.VideoWriter_fourcc(*"mp4v"), 25, (width, height), True) for frame in tqdm(frames, total=len(frames)): out.write(frame) cv2.destroyAllWindows() out.release()
"xresnet18": xresnet18ssa, "xresnet34": xresnet34ssa } Model = model_dict[args.model] train_df = pd.read_csv(args.train_df_path) processed = pickle.load(open(args.train_processed_path, "rb")) test_fns = sorted(os.listdir(args.test_dir)) test_df = pd.DataFrame() test_df["File"] = test_fns processed_test = pickle.load(open(args.test_processed_path, "rb")) transforms_dict = { 'train': transforms.Compose([ transforms.RandomHorizontalFlip(0.5), transforms.ToTensor(), ]), 'test': transforms.Compose([ transforms.RandomHorizontalFlip(0.5), transforms.ToTensor(), ]), } x_train = processed y_train = train_df.Label.values.astype(np.long) x_test = processed_test splits = list( StratifiedKFold(n_splits=5, shuffle=True, random_state=SEED).split(x_train, y_train))
def get_transforms(config, image_size=None): config = config.get_dictionary() if image_size is not None: image_size = image_size elif config['estimator'] not in resize_size_dict: image_size = 32 else: image_size = resize_size_dict[config['estimator']] val_transforms = transforms.Compose([ transforms.Resize(image_size), transforms.CenterCrop(image_size), transforms.ToTensor(), ]) if parse_bool(config['aug']): if parse_bool(config['auto_aug']): # from .transforms import AutoAugment data_transforms = { 'train': transforms.Compose([ # AutoAugment(), transforms.Resize(image_size), transforms.RandomCrop(image_size, padding=int(image_size / 8)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), ]), 'val': val_transforms, } else: transform_list = [] if parse_bool(config['jitter']): transform_list.append( transforms.ColorJitter(brightness=config['brightness'], saturation=config['saturation'], hue=config['hue'])) if parse_bool(config['affine']): transform_list.append( transforms.RandomAffine(degrees=config['degree'], shear=config['shear'])) transform_list.append(transforms.RandomResizedCrop(image_size)) transform_list.append(transforms.RandomCrop(image_size, padding=4)) if parse_bool(config['random_flip']): transform_list.append(transforms.RandomHorizontalFlip()) transform_list.append(transforms.ToTensor()) data_transforms = { 'train': transforms.Compose(transform_list), 'val': val_transforms } else: data_transforms = { 'train': transforms.Compose([ transforms.Resize(image_size), transforms.CenterCrop(image_size), transforms.ToTensor(), ]), 'val': val_transforms, } return data_transforms
def __init__( self, c, nof_joints, checkpoint_path, model_name='HRNet', resolution=(384, 288), interpolation=cv2.INTER_CUBIC, multiperson=True, return_heatmaps=False, return_bounding_boxes=False, max_batch_size=32, yolo_model_def="./models/detectors/yolo/config/yolov3.cfg", yolo_class_path="./models/detectors/yolo/data/coco.names", yolo_weights_path="./models/detectors/yolo/weights/yolov3.weights", device=torch.device("cpu")): """ Initializes a new SimpleHRNet object. HRNet (and YOLOv3) are initialized on the torch.device("device") and its (their) pre-trained weights will be loaded from disk. Args: c (int): number of channels (when using HRNet model) or resnet size (when using PoseResNet model). nof_joints (int): number of joints. checkpoint_path (str): path to an official hrnet checkpoint or a checkpoint obtained with `train_coco.py`. model_name (str): model name (HRNet or PoseResNet). Valid names for HRNet are: `HRNet`, `hrnet` Valid names for PoseResNet are: `PoseResNet`, `poseresnet`, `ResNet`, `resnet` Default: "HRNet" resolution (tuple): hrnet input resolution - format: (height, width). Default: (384, 288) interpolation (int): opencv interpolation algorithm. Default: cv2.INTER_CUBIC multiperson (bool): if True, multiperson detection will be enabled. This requires the use of a people detector (like YOLOv3). Default: True return_heatmaps (bool): if True, heatmaps will be returned along with poses by self.predict. Default: False return_bounding_boxes (bool): if True, bounding boxes will be returned along with poses by self.predict. Default: False max_batch_size (int): maximum batch size used in hrnet inference. Useless without multiperson=True. Default: 16 yolo_model_def (str): path to yolo model definition file. Default: "./models/detectors/yolo/config/yolov3.cfg" yolo_class_path (str): path to yolo class definition file. Default: "./models/detectors/yolo/data/coco.names" yolo_weights_path (str): path to yolo pretrained weights file. Default: "./models/detectors/yolo/weights/yolov3.weights.cfg" device (:class:`torch.device`): the hrnet (and yolo) inference will be run on this device. Default: torch.device("cpu") """ self.c = c self.nof_joints = nof_joints self.checkpoint_path = checkpoint_path self.model_name = model_name self.resolution = resolution # in the form (height, width) as in the original implementation self.interpolation = interpolation self.multiperson = multiperson self.return_heatmaps = return_heatmaps self.return_bounding_boxes = return_bounding_boxes self.max_batch_size = max_batch_size self.yolo_model_def = yolo_model_def self.yolo_class_path = yolo_class_path self.yolo_weights_path = yolo_weights_path self.device = device if model_name in ('HRNet', 'hrnet'): self.model = HRNet(c=c, nof_joints=nof_joints) elif model_name in ('PoseResNet', 'poseresnet', 'ResNet', 'resnet'): self.model = PoseResNet(resnet_size=c, nof_joints=nof_joints) else: raise ValueError('Wrong model name.') checkpoint = torch.load(checkpoint_path, map_location=self.device) if 'model' in checkpoint: self.model.load_state_dict(checkpoint['model']) else: self.model.load_state_dict(checkpoint) if 'cuda' in str(self.device): print("device: 'cuda' - ", end="") if 'cuda' == str(self.device): # if device is set to 'cuda', all available GPUs will be used print("%d GPU(s) will be used" % torch.cuda.device_count()) device_ids = None else: # if device is set to 'cuda:IDS', only that/those device(s) will be used print("GPU(s) '%s' will be used" % str(self.device)) device_ids = [int(x) for x in str(self.device)[5:].split(',')] self.model = torch.nn.DataParallel(self.model, device_ids=device_ids) elif 'cpu' == str(self.device): print("device: 'cpu'") else: raise ValueError('Wrong device name.') self.model = self.model.to(device) self.model.eval() if not self.multiperson: self.transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) else: self.detector = YOLOv3(model_def=yolo_model_def, class_path=yolo_class_path, weights_path=yolo_weights_path, classes=('person', ), max_batch_size=self.max_batch_size, device=device) self.transform = transforms.Compose([ transforms.ToPILImage(), transforms.Resize((self.resolution[0], self.resolution[1])), # (height, width) transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ])
x = self.layerblock3(x) x = self.layerblock4(x) x = self.layerblock5(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x if __name__ == "__main__": filepath = './CIFAR10_dataset' #data loading and augmentation #cifar 10 normalization parameter https://arxiv.org/pdf/1909.12205.pdf train_transformations = transforms.Compose([ transforms.RandomHorizontalFlip(), transforms.RandomCrop(32, padding=4), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261)) ]) test_transformations = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261)) ]) train_dataset = CIFAR10(root=filepath, train=True, download=True, transform=train_transformations) test_dataset = CIFAR10(root=filepath, train=False, download=True, transform=test_transformations) batch_size = 100
plt.subplot(sqrtn, sqrtn, index+1) plt.imshow(image.reshape(28, 28)) device = 'cuda:0' if torch.cuda.is_available() else 'cpu' print('GPU State:', device) G = generator().to(device) D = discriminator().to(device) print(G) print(D) epochs = 200 lr = 0.0002 batch_size = 64 g_optimizer = optim.Adam(G.parameters(), lr=lr, betas=(0.5, 0.999)) d_optimize = optim.Adam(D.parameters(), lr=lr, betas=(0.5, 0.999)) transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))]) train_set = datasets.MNIST('mnist/', train=True, download=False, transform=transform) test_set = datasets.MNIST('mnist/', train=False, download=False, transform=transform) train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True) test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False) # Train for epoch in range(epochs): epoch += 1 for time, data in enumerate(train_loader): time += 1 true_input = data[0].to(device) test = 255 * (0.5 * true_input[0] + 0.5)
from pfrl import replay_buffers, explorers, experiments, q_functions from pfrl.agents import DQN from pfrl.q_functions import DiscreteActionValueHead from torch import nn, optim from torchvision.datasets import CIFAR10 from torchvision.transforms import transforms import numpy as np from tqdm import tqdm, trange from rl.env_d import AttackEnv if __name__ == '__main__': transform = transforms.Compose((transforms.ToTensor(), transforms.Normalize(0.5, 0.5, 0.5))) test_dataset = CIFAR10('data', train=False, transform=transform, download=False) image_size = 32 * 32 n_classes = 10 max_episodes = 20 max_episode_len = 1000 env = AttackEnv() obs_space = env.observation_space action_space = env.action_space obs_size = obs_space.low.size n_actions = action_space.n
('arch', 'lenet5'), ('n_classes', 10), ('input_shape', (1, 28, 28)), ]) data_config = OrderedDict([ ('dataset', 'SplitFashionMNIST'), ('valid', 0.0), ('num_workers', 4), ( 'train_transform', transforms.Compose([ lambda x: np.array(x).reshape((1, 28, 28)), lambda x: np.pad(x, ( (0, 0), (2, 2), (2, 2)), mode='minimum'), # Padding is only required by LeNet lambda x: torch.FloatTensor(x), lambda x: x / 255.0, transforms.Normalize(np.array([0.1307]), np.array([0.3081])) ])), ( 'test_transform', transforms.Compose([ lambda x: np.array(x).reshape((1, 28, 28)), lambda x: np.pad(x, ( (0, 0), (2, 2), (2, 2)), mode='minimum'), # Padding is only required by LeNet lambda x: torch.FloatTensor(x), lambda x: x / 255.0, transforms.Normalize(np.array([0.1307]), np.array([0.3081])) ])),
format_string = self.__class__.__name__ + '(size={0}'.format(self.size) format_string += ', xscale={0}'.format( tuple(round(s, 4) for s in self.xscale)) format_string += ', yscale={0}'.format( tuple(round(r, 4) for r in self.xscale)) format_string += ', interpolation={0})'.format(interpolate_str) return format_string transform = { 'train': transforms.Compose([ transforms.RandomRotation(12, resample=Image.BILINEAR), CenterRandomCrop(size, xscale=(0.6, 1.0), aspect_ratio=(1, 1.4)), transforms.ColorJitter(0.2, 0.1, 0.1, 0.04), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.ToTensor(), transforms.Normalize(mean, std) ]), 'val': transforms.Compose([ transforms.CenterCrop((512, 640)), transforms.Resize(size, interpolation=Image.BILINEAR), transforms.ToTensor(), transforms.Normalize(mean, std) ]) } if torch.cuda.is_available(): device = torch.device("cuda:0")
from data_loader.DataPath import DataPath from framework.loss import Loss from config import ParallelConfig from framework.segmentation.Mask import Mask from segmentation.loss.neighbour_diff import NeighbourDiffLoss from framework.segmentation.unet import UNetSegmentation from viz.visualization import show_segmentation, show_images LABELS_URL = 'https://s3.amazonaws.com/mlpipes/pytorch-quick-start/labels.json' labels = {int(key):value for (key, value) in requests.get(LABELS_URL).json().items()} transform = transforms.Compose([ #[1] transforms.Resize(128), #[2] transforms.CenterCrop(128), #[3] transforms.ToTensor(), #[4] transforms.Normalize( #[5] mean=[0.485, 0.456, 0.406], #[6] std=[0.229, 0.224, 0.225] #[7] )]) mask_transform = transforms.Compose([ #[1] transforms.Resize(128), #[2] transforms.CenterCrop(128), #[3] transforms.ToTensor() #[4] ]) # trainset = CocoStuff10k(root="/home/nazar/PycharmProjects/coco", transform=transform) trainset = Cityscapes(DataPath.HOME_STREET, transform=transform, target_transform=mask_transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=20, shuffle=True, num_workers=12)
F.cuda() # load saved models G.load_state_dict(torch.load('../save/G.pth')) F.load_state_dict(torch.load('../save/F.pth')) # set to eval states G.eval() F.eval() Tensor = torch.cuda.FloatTensor if cuda else torch.Tensor input_X = Tensor(batch_size, input_nc, image_size, image_size) input_Y = Tensor(batch_size, output_nc, image_size, image_size) transforms = transforms.Compose([ transforms.Resize((image_size, image_size)), transforms.ToTensor(), ]) dataset = ImageDataset(dataroot=dataroot, transforms=transforms, mode='test') dataloader = DataLoader(dataset=dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers) output_dir_X = '../output/X' output_dir_Y = '../output/Y' output_dir_recover = '../output/recover' if not os.path.exists(output_dir_X): os.makedirs(output_dir_X) if not os.path.exists(output_dir_Y): os.makedirs(output_dir_Y) if not os.path.exists(output_dir_recover): os.makedirs(output_dir_recover)
def gen_transform_test_multi(crop_size=448): return transforms.Compose([ transforms.RandomCrop(crop_size), transforms.ToTensor(), transforms.Normalize(mean=[0.5], std=[0.5]) ])
#save = "/DB/VCDB/all_frames/resnet50-rmac" if not os.path.exists(base): print("base '{}' is not exist.".format(base)) exit() if not os.path.exists(save): os.makedirs(os.path.join(save, 'v-features')) os.makedirs(os.path.join(save, 'f-features')) os.makedirs(os.path.join(save2, 'v-features')) os.makedirs(os.path.join(save2, 'f-features')) videos = os.listdir(base) videos.sort(key=int) normalize = trn.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) video_trn = trn.Compose([trn.Resize(224), trn.ToTensor(), normalize]) model2 = resnet50(pretrained=True) model2 = torch.nn.Sequential(*list(model2.children())[:-1]) # 2048 - dimension model2.cuda() model2 = torch.nn.DataParallel(model2) summary(model2, (3, 224, 224)) model2.eval() model = Resnet50_RMAC() model.cuda() model = torch.nn.DataParallel(model) summary(model, (3, 224, 224)) model.eval() with torch.no_grad():
def __getitem__(self, index): ''' over-writing the __getitem__ method to return the index along with img and target ''' img, target = super().__getitem__(index) # print(f"mnist index: {index}") return img, target, index if __name__ == "__main__": transform = transforms.Compose([ # you can add other transformations in this list transforms.ToTensor() ]) temp_MNIST = CustomMNIST(root='./data', train=True, download=True, transform=transform) train_split_percentage = 0.2 initial_train_set_size = len(temp_MNIST) needed_train_set_size = int(train_split_percentage * initial_train_set_size) needed_val_set_size = initial_train_set_size - needed_train_set_size print(needed_train_set_size, needed_val_set_size) train_set, val_set = torch.utils.data.random_split( temp_MNIST, (needed_train_set_size, needed_val_set_size))
def encode(img, bottleneck): transform = transforms.Compose([transforms.ToTensor()]) inputs = transform(img).unsqueeze(0) encoder = Encoder() binarizer = Binarizer(int(bottleneck / 512)) decoder = Decoder(int(bottleneck / 512)) if torch.cuda.is_available(): encoder = Encoder().cuda() binarizer = Binarizer(int(bottleneck / 512)).cuda() decoder = Decoder(int(bottleneck / 512)).cuda() encoder.load_state_dict( torch.load('./project/models/model_LSTM_' + str(bottleneck) + '/encoder')) binarizer.load_state_dict( torch.load('./project/models/model_LSTM_' + str(bottleneck) + '/binarizer')) decoder.load_state_dict( torch.load('./project/models/model_LSTM_' + str(bottleneck) + '/decoder')) else: encoder.load_state_dict( torch.load('./project/models/model_LSTM_' + str(bottleneck) + '/encoder', map_location=torch.device('cpu'))) binarizer.load_state_dict( torch.load('./project/models/model_LSTM_' + str(bottleneck) + '/binarizer', map_location=torch.device('cpu'))) decoder.load_state_dict( torch.load('./project/models/model_LSTM_' + str(bottleneck) + '/decoder', map_location=torch.device('cpu'))) encoder.eval() binarizer.eval() decoder.eval() if torch.cuda.is_available(): e_1 = (torch.zeros(1, 256, 64, 64).cuda(), torch.zeros(1, 256, 64, 64).cuda()) e_2 = (torch.zeros(1, 512, 32, 32).cuda(), torch.zeros(1, 512, 32, 32).cuda()) e_3 = (torch.zeros(1, 512, 16, 16).cuda(), torch.zeros(1, 512, 16, 16).cuda()) d_1 = (torch.zeros(1, 512, 16, 16).cuda(), torch.zeros(1, 512, 16, 16).cuda()) d_2 = (torch.zeros(1, 512, 32, 32).cuda(), torch.zeros(1, 512, 32, 32).cuda()) d_3 = (torch.zeros(1, 256, 64, 64).cuda(), torch.zeros(1, 256, 64, 64).cuda()) d_4 = (torch.zeros(1, 128, 128, 128).cuda(), torch.zeros(1, 128, 128, 128).cuda()) residual = inputs.cuda() else: e_1 = (torch.zeros(1, 256, 64, 64), torch.zeros(1, 256, 64, 64)) e_2 = (torch.zeros(1, 512, 32, 32), torch.zeros(1, 512, 32, 32)) e_3 = (torch.zeros(1, 512, 16, 16), torch.zeros(1, 512, 16, 16)) d_1 = (torch.zeros(1, 512, 16, 16), torch.zeros(1, 512, 16, 16)) d_2 = (torch.zeros(1, 512, 32, 32), torch.zeros(1, 512, 32, 32)) d_3 = (torch.zeros(1, 256, 64, 64), torch.zeros(1, 256, 64, 64)) d_4 = (torch.zeros(1, 128, 128, 128), torch.zeros(1, 128, 128, 128)) residual = inputs binary = [] for t in range(rnn_num): e_result, e_1, e_2, e_3 = encoder(residual, e_1, e_2, e_3) b_result = binarizer(e_result) outputs, d_1, d_2, d_3, d_4 = decoder(b_result, d_1, d_2, d_3, d_4) residual = residual - outputs binary.append( (torch.Tensor.cpu(b_result).detach().numpy().astype(np.int8) + 1) // 2) binary = np.stack(binary, axis=0) binary = np.packbits(binary, axis=-1) return binary
print("Checking ......") args = get_args() check_args(args) print("Initializaion ......") normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) #prepare data train_traisform = transforms.Compose([ transforms.RandomResizedCrop(args.img_size), #transforms.Resize((args.img_size,args.img_size)), transforms.RandomHorizontalFlip(), #transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), transforms.ToTensor(), normalize, ]) if args.crop: val_traisform = transforms.Compose([ transforms.Resize(args.img_size), transforms.CenterCrop(args.img_size), #transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), transforms.ToTensor(), normalize, ]) else: val_traisform = transforms.Compose([ transforms.Resize((args.img_size, args.img_size)),
def __init__( self, dataset_path='./drive/MyDrive/datasets/car classification/train_data', batch_size=1, model_name='tf_efficientnet_b3_ns', test_csv='./train_labels.csv', unique_csv='./train_labels.csv', output_dir='../drive/MyDrive/ckpt/grapheme/submission.csv', ckpt='../drive/MyDrive/ckpt/grapheme/20.pth'): # initialize attributes self.dataset_path = dataset_path self.batch_size = batch_size self.model_name = model_name self.test_csv = test_csv self.unique_csv = unique_csv self.output_dir = output_dir self.ckpt = ckpt if model_name == 'tf_efficientnet_b0_ns': self.input_size = (224, 224) elif model_name == 'tf_efficientnet_b3_ns': self.input_size = (300, 300) elif model_name == 'tf_efficientnet_b4_ns': scaleelf.input_size = (380, 380) elif model_name == 'tf_efficientnet_b6_ns': self.input_size = (528, 528) else: raise Exception('non-valid model name') # Compose transforms transform = [] transform += [transforms.Resize(self.input_size)] self.transform = transforms.Compose(transform) self.test_dataset = BengaliDataset(self.test_csv, self.unique_csv, self.dataset_path, self.transform, cache=True) self.names = self.test_dataset.names self.test_dataloader = DataLoader(self.test_dataset, batch_size=self.batch_size, num_workers=0, shuffle=False) self.device = torch.device( 'cuda' if torch.cuda.is_available() else 'cpu') self.model_root = MyModel(self.input_size, self.model_name, 168, pretrained=True, dropout=0).to('cuda') self.model_consonant = MyModel(self.input_size, self.model_name, 11, pretrained=True, dropout=0).to('cuda') self.model_vowel = MyModel(self.input_size, self.model_name, 18, pretrained=True, dropout=0).to('cuda') self.model_multihead = MultiHeadModel(self.input_size, self.model_name, pretrained=True, dropout=0).to('cuda') ckpt = torch.load(self.ckpt) self.model_root.load_state_dict(ckpt['model_root_state_dict']) self.model_consonant.load_state_dict( ckpt['model_consonant_state_dict']) self.model_vowel.load_state_dict(ckpt['model_vowel_state_dict']) self.model_multihead.load_state_dict( ckpt['model_multihead_state_dict'])