def generate_data(data_folder, filename): data_folder = 'D:\CharsFont\Bmp' transform = { 'train': transforms.Compose([ transforms.Resize([28, 28]), transforms.Grayscale(num_output_channels=1), transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ]), 'test': transforms.Compose([ transforms.Resize([28, 28]), transforms.Grayscale(num_output_channels=1), transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ]) } data = datasets.ImageFolder(root=data_folder, transform=transform['train']) data_loader = torch.utils.data.DataLoader(data, batch_size=len(data), shuffle=True) test_dataset_array = next(iter(data_loader)) images = test_dataset_array[0].numpy() labels = test_dataset_array[1].numpy() store_many_hdf5(images, labels, filename)
def importDataset(): shutil.copy('/content/drive/My Drive/bg_fg_bg_mask_2.zip','bg_fg_bg_mask_2.zip') shutil.copy('/content/drive/My Drive/Session15/copy_depth_output.zip','copy_depth_output.zip') zip = ZipFile('bg_fg_bg_mask_2.zip') zip.extractall('./') zip = ZipFile('copy_depth_output.zip') zip.extractall('./') data_root = Path('.') f1, f2, f3 ,f4 = data_root/'bg', data_root/'fg_bg', data_root/'mask_fg_bg', data_root/'depth' print(len(list(f1.iterdir()))) print(len(list(f2.iterdir()))) print(len(list(f3.iterdir()))) print(len(list(f4.iterdir()))) scale_transform = transforms.Compose([ transforms.Resize((128, 128)), #transforms.ColorJitter(brightness=0.2, contrast = 0.2, saturation = 0.2, hue = 0.2), transforms.ToTensor(), ]) grayTransform = transforms.Compose([ transforms.Grayscale(num_output_channels=1), transforms.Resize((128, 128)), #transforms.ColorJitter(brightness=0.2, contrast = 0.2, saturation = 0.2, hue = 0.2), transforms.ToTensor(), ]) mean, std = torch.tensor([0.485, 0.456, 0.406])*255, torch.tensor([0.229, 0.224, 0.225])*255 train_transforms = transforms.Compose([ transforms.Resize((128, 128)), transforms.ColorJitter(brightness=0.15, contrast=0.15, saturation=0.15, hue= 0.15), transforms.ToTensor(), transforms.Normalize(mean, std) ]) train_ds = MasterData(data_root, train_transforms, scale_transform) train_d1 = DataLoader(train_ds, batch_size=16, shuffle=True, pin_memory=True) return train_d1
def get_transform(): return transforms.Compose([ transforms.ToPILImage(), transforms.Grayscale(num_output_channels=1), transforms.Resize(image_dims), transforms.ToTensor(), ])
def __init__(self, root_dir): self.samples = glob.glob(os.path.join(root_dir, '*')) self.transforms = transforms.Compose([ transforms.Grayscale(), transforms.Resize((128, 128)), transforms.ToTensor() ])
def set_transform(resize=112, crop=112, normalize=None, additional=None): if normalize is None or normalize is True: normalize = [[0.485, 0.456, 0.406], [0.229, 0.224, 0.225]] transform_list = [ transforms.Resize(resize), transforms.CenterCrop(crop), transforms.Grayscale(3) ] if additional is not None: transform_list.extend(additional) transform_list.extend([transforms.ToTensor()]) if normalize is None or normalize is True: normalize = [[0.485, 0.456, 0.406], [0.229, 0.224, 0.225]] transform_list.extend( [transforms.Normalize(mean=normalize[0], std=normalize[1])]) elif normalize is not False: transform_list.extend( [transforms.Normalize(mean=normalize[0], std=normalize[1])]) else: pass return transforms.Compose(transform_list)
def predict_image(img): print("Prediction in progress") # Define transformations for the image, should (note that imagenet models are trained with image size 224) transformation = transforms.Compose([ transforms.Grayscale(), transforms.ToTensor(), transforms.Normalize((0.5, ), (0.5, )) ]) # Preprocess the image image_tensor = transformation(img).float() # Add an extra batch dimension since pytorch treats all images as batches image_tensor = image_tensor.unsqueeze_(0) # Turn the input into a Variable image = Variable(image_tensor) # Predict the class of the image output = model(image) index = output.data.numpy().argmax() return index
def __init__(self): ## these are the potential labels for objects self.labels = ['1','2','3','A','B', 'C'] ## This try/except statement is if you are running the file itself to run the test method or importing it. The model.pt will be different location based on the context of who calls it. try: ## Loading model self.model = torch.hub.load('pytorch/vision:v0.5.0', 'alexnet', pretrained=True) self.model.load_state_dict(torch.load('model_handler/model.pt')) self.model.eval() except Exception: try: ## Loading model self.model = torch.hub.load('pytorch/vision:v0.5.0', 'alexnet', pretrained=True) self.model.load_state_dict(torch.load('model.pt')) self.model.eval() except: print('System model not detected, please assure that "model.pt" is downloaded..') sys.exit(1) ## Creates a transformer object. ## This transformer does the following, resizes the image and crops to the resize. Grayscales it. transforms it to a tensor object and normalizes the pixel values self.trans = transforms.Compose([ transforms.Resize(224), transforms.Grayscale(num_output_channels=3), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([.5, 0.5, 0.5], [0.5, 0.5, 0.5]) ])
def get_imager_folder(folder='/mnt/sdb1/datasets/mammoset/exp5-2_aug'): # Normalizacao utilizada no paper da ResNet https://arxiv.org/abs/1512.03385 normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) scale = 224 transform = transforms.Compose([ # transforms.RandomResizedCrop(200), # transforms.RandomHorizontalFlip(), # transforms.RandomRotation(45), transforms.Resize([scale, scale]), # transforms.CenterCrop(scale), transforms.Grayscale(1), transforms.ToTensor(), normalize, ]) train_data, val_data = ImageFolder(folder, transform).get_split(train_perc=0.8) num_classes = len(train_data.class_counts) print('Tamanho conjuto de treino %s' % len(train_data)) print('Tamanho conjuto de teste %s' % len(val_data)) print('Classes Ids %s' % train_data.class_to_idx) print('Classes Counts %s' % train_data.class_counts) return train_data, val_data, num_classes
def predict_images(img): print("Prediction in progress") # Define transformations for the image, should (note that imagenet models are trained with image size 224) transformation = transforms.Compose([ transforms.Grayscale(), transforms.ToTensor(), transforms.Normalize((0.5, ), (0.5, )) ]) index = [] # Preprocess the image for im in img: image_tensor = transformation(im.image).float().unsqueeze_(0) # Turn the input into a Variable image = Variable(image_tensor) # Predict the class of the image output = model(image) index.append(output.data.numpy().argmax()) #fig,ax = plt.subplots() #ax.imshow(np.asarray(im.image),cmap='gray') #if output.data.numpy().argmax()==0: # ax.set_title("Class = Noise") #else: # ax.set_title("Class = Data") return index
def __init__(self, data_path, mode): if mode == "train" or mode == "val": img_paths = sorted(glob.glob(os.path.join(data_path, '*.jpg'))) random.shuffle(img_paths) else: img_paths = sorted(glob.glob(os.path.join(data_path, '*.jpg')), key=get_name) split = int(len(img_paths) * 0.75) if mode == "train": self.img_paths = img_paths[:split] elif mode == "val": self.img_paths = img_paths[split:] else: self.img_paths = img_paths if mode == "train" or mode == "val": self.labels = [ path.split("/")[-1].split(".")[0] for path in self.img_paths ] self.labels = [int(label == "cat") for label in self.labels] else: self.img_ids = [ path.split("/")[-1].split(".")[0] for path in self.img_paths ] if mode == "train": transforms = [ T.Grayscale(), T.Resize((RE_HEIGHT, RE_WIDTH)), T.RandomHorizontalFlip(), T.ToTensor() ] else: # "val" and "test" transforms = [ T.Grayscale(), T.Resize((RE_HEIGHT, RE_WIDTH)), T.ToTensor() ] self.transforms = T.Compose(transforms) self.mode = mode
def get_train_set(path, part): trans_train = transforms.Compose([ transforms.Grayscale(1), # this also convert pixel value from [0,255] to [0,1] transforms.ToTensor(), transforms.Normalize(mean=0.4638, std=0.1889), ]) train_set = GazeMe(path, part, transform=trans_train) print("dataset successfully read!") return train_set
def set_dataset_images(self): transform_list = [transforms.ToTensor()] if self.resize: transform_list.append(transforms.Resize(256)) transform_list.append(transforms.CenterCrop(224)) if not self.rgb: transform_list.append(transforms.Grayscale(num_output_channels=3)) transform = transforms.Compose(transform_list) self.dataset_images = datasets.ImageNet(location=self.location, transform=transform)
def img_open(path): data = PIL.Image.open(path) height = 32 width = int(data.size[0] / (data.size[1] / height)) data = data.resize((width, height)) Transform = transforms.Compose([ transforms.Grayscale(), transforms.ToTensor(), transforms.Lambda(lambda x: torch.unsqueeze(x, 0)) ]) data = Transform(data) return data
def CreateImageTensors(IMAGE_PATH,TENSOR_PATH,sampletensor,labeltensor): # INPUTS REQUIREMENTS # Path to one folder containing a subfolder for each category # Path to one folder where torch tensors will be saved # Name of sample and label tensors # OUTPUT # train and test data # input channels # input size # ID of categories used # Choose image size (all image will be resized to this size) inputsize=[299,299] # 3 channels for colors, 1 for grayscale chan=3 trans = transforms.Compose([ # transforms.Resize(inputsize), transforms.Grayscale(num_output_channels=chan), transforms.ToTensor(), transforms.Normalize((0,),(0.5,)) ]) # Read folders dataset = datasets.ImageFolder(root=IMAGE_PATH, transform=trans) # Create samples and label tensors samples=torch.empty([len(dataset),*list(dataset[0][0].size())]) labels=torch.empty(len(dataset)) for i in range(len(dataset)): samples[i]=dataset[i][0] labels[i]=dataset[i][1] # # This places all pixel value between 0 and 1, treating channels (colors) separately for i in range(chan): samples[:,i,:,:]=(samples[:,i,:,:]-torch.min(samples[:,i,:,:]))/torch.max(samples[:,i,:,:]) torch.save(samples, TENSOR_PATH + sampletensor) torch.save(labels, TENSOR_PATH + labeltensor)
def get_fashion_mnist(bs, size=32, train=True, mu=0.5, std=0.5, root=DATA_ROOT): fatrans = transforms.Compose([ transforms.Grayscale(3), transforms.Resize(size), transforms.ToTensor(), transforms.Normalize((mu, mu, mu), (std, std, std)) ]) fmset = torchvision.datasets.FashionMNIST(root, train=train, transform=fatrans, download=True) fmloader = DataLoader(fmset, batch_size=bs, shuffle=True, num_workers=2) return fmset, fmloader
def predict_for_frame(model, cv_img): """ Crop face on img, preprocess, make prediction If several face on image, chose one. :return: [ {"prediction": prediction vector, "position": (x, y, w, h)} ] """ faces = crop_faces([cv_img], only_one=False, using_bundled_library=True)[0] if len(faces) == 0: return [] pre_processing = transforms.Compose([ transforms.Grayscale(num_output_channels=1), transforms.Resize(tuple(config["resolution"])), transforms.ToTensor(), transforms.Normalize(mean=[0.5], std=[0.5]), ]) pre_processed_faces = [] faces_coords = [] for face in faces: (x, y, w, h) = face face_cv = crop_cv_img(cv_img, x, y, w, h) face_pil = pre_processing(pl.Image.fromarray(face_cv)) pre_processed_faces.append(face_pil) faces_coords.append((x, y, w, h)) x = torch.stack(pre_processed_faces) predictions = torch.nn.Softmax(dim=1)(model.forward(x)) output = [] for prediction, coords in zip(predictions, faces_coords): output.append({ "prediction": prediction, "position": coords }) return output
def __init__(self) -> None: self._greyscale = transforms.Grayscale()
def make_video(fps): """ Make video from model predictions on the youtube faciale expression video: https://www.youtube.com/watch?v=B0ouAnmsO1Y - Take one frame over 3 on the original 60fps video - Detect face on the frame and draw rectangle delimiter. - If a face is detected, run the model on it and write the results on the frame. :param fps: :return: """ cap = cv2.VideoCapture('./videos/facial_expressions_demo.mov') out = cv2.VideoWriter( './videos/output.avi', cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), fps, (int(cap.get(3)), int(cap.get(4))) ) model = Custom_vgg(1, len(config["catslist"]), device=torch.device('cpu')) model.load_state_dict(torch.load(config["current_best_model"], map_location=torch.device('cpu'))) pre_process = transforms.Compose( [transforms.Grayscale(num_output_channels=1), transforms.ToTensor(), transforms.Normalize(mean=[0.5], std=[0.5])]) if not cap.isOpened(): print("Error opening video stream or file") i = 0 while cap.isOpened(): i += 1 ret, frame = cap.read() # process one frame over 3. if i % 3 == 0: if ret: # detect face on the frame face = crop_faces([frame])[0] if face is None: out.write(frame) else: (x, y, w, h) = face # draw rectangle face delimiter cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0)) # compute model predictions pil_frame = pl.Image.fromarray(frame) pil_frame = pil_frame.resize(config["resolution"]) # TODO add that in pre-processing x = pre_process(pil_frame).unsqueeze(0) predictions = model.predict_single(x) # write predictions on the output frame for index, proba in enumerate(predictions): text = "{}: {}%".format(config["catslist"][index], proba) cv2.putText(frame, text, (10, 130 + 32 * index), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2, cv2.LINE_AA) out.write(frame) else: break if i % 60 == 0: print("Processed {} seconds of video".format(i / 60)) cap.release() out.release() cv2.destroyAllWindows()
def Grayscale(self, **args): return self._add(transforms.Grayscale(**args))
import torch.nn as nn from torch import optim from torch.autograd import Variable import datas from models.v2_net import KitModel import torchvision.transforms.transforms as transforms import importlib from torch.nn.modules.distance import PairwiseDistance from eval_metrics import evaluate, plot_roc l2_dist = PairwiseDistance(2) use_cuda = torch.cuda.is_available() total_epoch = 150 transform = transforms.Compose([ transforms.Grayscale(), transforms.Resize([32, 32]), transforms.ToTensor() ]) trainset = datas.fec_data.FecData(transform) trainloader = data.DataLoader(trainset, batch_size=256, num_workers=16) # net = KitModel() # load model which converted from caffe model using MMdnn tool MainModel = imp.load_source('MainModel', "./models/v2_net.py") net = torch.load("./models/v2_net.pth") net.fc8_1 = nn.Linear(net.fc8_1.in_features, 4) for param in net.parameters():
import torch import glob import torch.nn as nn from torchvision.transforms import transforms from torch.utils.data import DataLoader from torch.optim import Adam from torch.autograd import Variable import torchvision import pathlib from tqdm import tqdm import user_set transformer = transforms.Compose([ transforms.Resize((256, 256)), transforms.RandomHorizontalFlip(), transforms.Grayscale(num_output_channels=1), transforms.ToTensor(), #0-255 to 0-1, numpy to tensors transforms.Normalize( [0.5], # 0-1 to [-1,1] , formula (x-mean)/std [0.5]) ]) class ConvNet(nn.Module): def __init__(self, num_classes=6): super(ConvNet, self).__init__() #Input shape= (3,256,256) self.conv1 = nn.Conv2d(in_channels=1, out_channels=32,
# ---------------Tensor上的操作--------------------------------- # transforms2 = transforms.Compose([transforms.Normalize(mean=(0.5, 0.5, #0.5), std=(0.5, 0.5, 0.5))]) # img2 = transforms2(img1) # print('img2 = ', img2) # ---------------PIL.Image上的操作--------------------------------- transforms3 = transforms.Compose([transforms.Resize(256)]) img3 = transforms3(img) print('img3 = ', img3) img3.show() transforms4 = transforms.Compose([transforms.CenterCrop(256)]) img4 = transforms4(img) print('img4 = ', img4) img4.show() transforms5 = transforms.Compose([transforms.RandomCrop(224, padding=0)]) img5 = transforms5(img) print('img5 = ', img5) img5.show() transforms6 = transforms.Compose([transforms.Grayscale(num_output_channels=1)]) img6 = transforms6(img) print('img6 = ', img6) img6.show() transforms7 = transforms.Compose([transforms.ColorJitter()]) img7 = transforms7(img) img7.show()
def __init__(self, gpu=False): models_directory = os.path.dirname(os.path.abspath(__file__)) # DENSENET self.N_CLASSES = 14 self.CLASS_NAMES = [ 'Atelectasis', 'Cardiomegaly', 'Effusion', 'Infiltration', 'Mass', 'Nodule', 'Pneumonia', 'Pneumothorax', 'Consolidation', 'Edema', 'Emphysema', 'Fibrosis', 'Pleural_Thickening', 'Hernia' ] if gpu: import torch.backends.cudnn as cudnn cudnn.benchmark = True device = torch.device("cuda:0") else: device = torch.device("cpu") # initialize and load the model model_dense = DenseNet121(self.N_CLASSES).to(device).eval() if gpu: model_dense = torch.nn.DataParallel(model_dense).to(device).eval() checkpoint = torch.load( os.path.join(models_directory, "gpu_weight.pth")) else: checkpoint = torch.load(os.path.join(models_directory, "cpu_weight.pth"), map_location=device) model_dense.load_state_dict(checkpoint) self.normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) self.transform_dense = transforms.Compose([ transforms.Resize(256), transforms.FiveCrop(224), transforms.Lambda(lambda crops: torch.stack( [transforms.ToTensor()(crop) for crop in crops])), transforms.Lambda(lambda crops: torch.stack( [self.normalize(crop) for crop in crops])) ]) self.model_dense = model_dense.to(device).eval() self.device = device # EFFNET model_eff = EfficientNet.from_name(model_name="efficientnet-b0", params=[1.0, 1.0, 224, 0.2], override_params={'num_classes': 2}) state_dict = torch.load(os.path.join(models_directory, "effnet_weight.pth"), map_location=device) model_eff.load_state_dict(state_dict) self.model_eff = model_eff.to(device).eval() self.transform_eff = transforms.Compose([ transforms.Resize(224), transforms.Grayscale(3), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) #Resnet for detecting xray out of random images resnet_state_dict = torch.load(os.path.join(models_directory, "nonxray.pth"), map_location=device) model_resnet = resnet18() model_resnet.fc = torch.nn.Linear(model_resnet.fc.in_features, 2) model_resnet.load_state_dict(resnet_state_dict) self.model_resnet = model_resnet.to(device).eval() self.transform_resnet = transforms.Compose([ transforms.Resize(100), transforms.CenterCrop(64), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ])
from torchvision.transforms import transforms as VT from torchvision.transforms import functional as VF valid_tmft = VT.Compose([ VT.Resize((256, 256)), VT.Grayscale(), VT.ToTensor(), ])
device = "cuda" if T.cuda.is_available() else "cpu" print("device:", device) v = 0 a = 0.95 # SETUP DATA TRANSFORMS if args.random: r = args.random train_transforms = transforms.Compose([ transforms.ToTensor(), #transforms.RandomApply([ # transforms.GaussianBlur(3, sigma=(0.1, 2.0)) #], p=0.2), transforms.RandomApply( [transforms.Grayscale(num_output_channels=3)], p=0.2), transforms.RandomApply([ transforms.ColorJitter(brightness=r, contrast=r, saturation=r, hue=r) ]), transforms.RandomApply( [transforms.RandomAffine(r * 10, shear=r * 10)]), transforms.RandomResizedCrop((32, 32), scale=(1 - r, 1.0)), transforms.RandomHorizontalFlip(p=0.5), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), ]) test_transforms = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
from OmniglotDataset import OmniglotData from models.SiameseNetwork import SiameseNetwork from torchvision.transforms import transforms import torch.optim as optim import torch.nn as nn import torch if __name__ == "__main__": transform_pipeline = transforms.Compose( [transforms.Grayscale(), transforms.ToTensor()]) train_data = OmniglotData(root='./data/Omniglot/images_background', transform=transform_pipeline) train_loader = torch.utils.data.DataLoader(train_data, batch_size=32, shuffle=True, num_workers=0) net = SiameseNetwork() optimizer = optim.Adam(net.parameters(), lr=1e-3) criterion = nn.BCELoss() for e in range(4): running_loss = 0.0 batch_size = 0 for i, data in enumerate(train_loader): img1, img2, similar = data optimizer.zero_grad() output = net(img1, img2) loss = criterion(output, similar) loss.backward() optimizer.step()
train_labels=range(split_labels), eval_labels=range(split_labels), batch_size=batch_size, ) # Defining unseen evaluation set if type_of_unseen == 'random': _, _, evalloader_unseen = get_random(number_of_channels=dim_channels, img_dim=dim_input, number_of_classes=10) if type_of_unseen == 'unseen_classes': _, _, evalloader_unseen = get_trainset(train_labels=(), eval_labels=range(split_labels, 10, ), ) res['split_labels'] = split_labels if type_of_unseen == 'unseen_dataset': res['unseen_dataset'] = unseen_evalset assert trainset != unseen_evalset, 'Train Set must be different from Unseen Test Set' transform = transforms.Compose([ transforms.Grayscale(num_output_channels=dim_channels), transforms.Resize(dim_input), transforms.ToTensor(), ]) if unseen_evalset == 'cifar10': _, _, evalloader_unseen = get_cifar10(transform=transform) if unseen_evalset == 'mnist': _, _, evalloader_unseen = get_mnist(transform=transform) if unseen_evalset == 'omniglot': _, _, evalloader_unseen = get_omniglot(transform=transform, download=False) seed_model = set_and_print_random_seed() bay_net = GaussianClassifier(rho=rho, stds_prior=stds_prior, dim_input=dim_input, number_of_classes=10, dim_channels=dim_channels) bay_net.to(device) criterion = CrossEntropyLoss()