# # For single channel images, don't forget the trailing commas as seen below. # # `transforms.Normalize((0.5,),(0.5,))` # # We normalize the MNIST images in this manner to ensure that pixel values lie between -0.5 and 0.5. This allows us to use a sigmoid when predicting pixel values. # In[5]: batch_size = 128 my_transforms = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5, ), (0.5, ))]) dataset = MNIST('../datasets', transform=my_transforms, download=True) dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True) # Lets check out the data # In[6]: print('Size of dataset: ', len(dataset)) idx = np.random.choice(len(dataset)) x, y = dataset[idx] plt.figure() plt.imshow(x.squeeze()) plt.title('idx = {}, Label = {}'.format(idx, y)) # Method `to_img` is the opposite of what `Normalize` above does to an MNIST image.
model_args = vars(model_args) model_args['loss_type'] = LOSS_DICT[model_args['loss_type']] if MODEL_DICT[train_args.model] == ModelType.Triplet: model = TripletNet(input_shape=input_shape, lr=train_args.lr, device=device, **model_args) return model if __name__ == "__main__": model_args, train_args, data_args = parse_args() # data loaders train_dataset = MNIST(os.getcwd(), train=True, download=True, transform=Compose([ToTensor(), Normalize((0.1307,), (0.3081,))])) train_loader = DataLoader(train_dataset, batch_size=train_args.batch_size, shuffle=True) test_dataset = MNIST(os.getcwd(), train=False, download=True, transform=Compose([ToTensor(), Normalize((0.1307,), (0.3081,))])) test_loader = DataLoader(test_dataset, batch_size=train_args.batch_size, shuffle=False) # Initialize a trainer trainer = pl.Trainer(gpus=1, max_epochs=train_args.epochs, progress_bar_refresh_rate=20) device = torch.device(f"cuda:{trainer.root_gpu}") if trainer.on_gpu and trainer.root_gpu is not None else torch.device('cpu') # Init Model # get input shape x_train, _ = next(iter(train_loader))
os.mkdir("./img") def to_img(x): out = 0.5 * (x + 1) out = out.clamp(0, 1) out = out.view(-1, 1, 28, 28) return out img_transformer = transforms.Compose( [transforms.ToTensor(), transforms.Normalize([0.5], [0.5])]) dataset = MNIST(root='./data/MNIST', train=True, transform=img_transformer, download=False) dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True) # =======================Model======================= class autoencoder(nn.Module): def __init__(self): super(autoencoder, self).__init__() self.encoder = nn.Sequential(nn.Linear(img_size, 128), nn.ReLU(True), nn.Linear(128, 64), nn.ReLU(True), nn.Linear(64, 12), nn.ReLU(True), nn.Linear(12, 3)) self.decoder = nn.Sequential(nn.Linear(3, 12), nn.ReLU(True),
plt.legend() plt.show() def draw_accuracy_plot(train_accuracy, test_accuracy, epochs): plt.plot(epochs, train_accuracy, label="train") plt.plot(epochs, test_accuracy, label="test") plt.xlabel('epochs') plt.ylabel('accuracy') plt.title('training / test accuracy') plt.legend() plt.show() if args.dataset == 'MNIST': train_data = MNIST('../data/MNIST', train=True, download=True) if args.dataset == 'EMNIST': train_data = EMNIST('../data/EMNIST', split='balanced', train=True, download=True) # 47 balanced classes all_labels = list(dict.fromkeys(train_data.train_labels.numpy())) _train_data = {} for label in all_labels: train_indexes = np.where(train_data.train_labels == label)[0] label_list = [] for index in train_indexes: label_list.append(train_data[index][0]) _train_data[label] = label_list
def prepare_data(self): transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (1.0,))]) _ = MNIST(root=self.hparams.data_root, train=True, transform=transform, download=True)
return self.decoder(z), mu, logvar # Defining the loss functions. def loss_function(preds, beta=1): x_hat, x, mu, logvar = preds BCE = nn.functional.binary_cross_entropy(x_hat, x.view(-1, 784), reduction="sum") KLD = 0.5 * torch.sum(logvar.exp() - logvar - 1 + mu.pow(2)) return BCE + beta * KLD if __name__ == "__main___": # Creating dataloaders. train_dataset = MNIST( root="./mnist_data/", train=True, transform=transforms.ToTensor(), download=True ) test_dataset = MNIST( root="./mnist_data/", train=False, transform=transforms.ToTensor(), download=False ) train_dataset, val_dataset = torch.utils.data.random_split(train_dataset, [50000, 10000]) bs = 64 train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=bs, shuffle=True) val_loader = torch.utils.data.DataLoader(dataset=val_dataset, batch_size=bs, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=bs, shuffle=False) # Defining config for experiment. config = ModelConfig( nn_module=VAE,
img_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) transform_train = transforms.Compose([ transforms.ToTensor(), transforms.Normalize( (0.5, ), (0.5, )) #image = (image - mean) / std makes it between -1 and 1 ]) #trainset= MNIST(root='./data', download=True, transform=transform_train) train_dataset = MNIST(root='./data', download=True, transform=transform_train) valid_dataset = MNIST(root='./data', train=False, download=True, transform=transform_train) print(len(train_dataset)) print(len(valid_dataset)) #test_ds, valid_ds = torch.utils.data.random_split(train_dataset, (50000, 10000)) #print(len(test_ds)) #print(len(valid_ds)) #validation_set = torch.utils.data.random_split(trainset, 0.6)
def load_mnist(root=None, transform=None, target_transform=None, download=True): root = root or Path("~/.learner/dataset").expanduser() train_ds = MNIST(root, train=True, download=download, transform=transform, target_transform=target_transform) test_ds = MNIST(root, train=False, download=download, transform=transform, target_transform=target_transform) data = Data(train_ds, test_ds=test_ds, auto_split=True) return data
""" from pathlib import Path from torchvision import models from torchvision.datasets import MNIST, CIFAR10 from .notebooks import my_datasets from notebooks.utils import ptitle if __name__ == "__main__": ROOT = Path("data/raw") ROOT.mkdir(parents=True, exist_ok=True) ptitle("Downloading DogsCatsDataset") _ds = my_datasets.DogsCatsDataset(ROOT, "train", download=True) print() ptitle("Downloading MNIST") _ds = MNIST(ROOT, train=True, download=True) _ds = MNIST(ROOT, train=False, download=True) print() ptitle("Downloading CIFAR10") _ds = CIFAR10(ROOT, train=True, download=True) _ds = CIFAR10(ROOT, train=False, download=True) print() ptitle("Downloading models") _model = models.resnet18(pretrained=True) _model = models.squeezenet1_1(pretrained=True)
def main(): MNIST(data_path, train=True, download=True)
def main(): # Init DataLoader from MNIST Dataset dataset = MNIST(os.getcwd(), train=True, download=True, transform=transforms.ToTensor()) mnist_test = MNIST(os.getcwd(), train=False, download=True, transform=transforms.ToTensor()) mnist_train, mnist_val = random_split(dataset, [55000, 5000])
import torch as T import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torchvision.datasets import MNIST from torchvision.transforms import ToTensor from torch import cuda import numpy as np import matplotlib.pyplot as plt device = 'cuda' if cuda.is_available() else 'cpu' batch_size = 64 mnist_train = MNIST('mnist', train=True, download=True, transform=ToTensor()) train_data_loader = T.utils.data.DataLoader(mnist_train, batch_size=64, shuffle=True) mnist_test = MNIST('mnist', train=False, download=True, transform=ToTensor()) test_data_loader = T.utils.data.DataLoader(mnist_test, batch_size=64, shuffle=True) class CNN(nn.Module): def __init__(self): super(CNN, self).__init__() self.conv1 = nn.Conv2d(1, 10, kernel_size=5) self.conv2 = nn.Conv2d(10, 20, kernel_size=5) self.conv3 = nn.Conv2d(20, 40, kernel_size=3) self.mp = nn.MaxPool2d(2) self.fc = nn.Linear(160, 10)
def get_dl(hparams, ds_types='all'): """ Args: hparams: ds_types: one of [train_val, all, test] Returns: """ dataloaders = None # make a tuple. if ds_types == 'all': ds_types = ('train', 'val', 'test') elif ds_types == 'train_val': ds_types = ('train', 'val') elif ds_types == 'test': ds_types = ('test', ) else: raise NotImplementedError train_dataset = None val_dataset = None test_dataset = None if hparams.dataset == 'mnist': dataset = MNIST('~/datasets/mnist', train=True, download=True, transform=transforms.ToTensor()) val_size = int(hparams.val_split * len(dataset)) train_dataset, val_dataset = random_split( dataset, [len(dataset) - val_size, val_size]) if 'test' in ds_types: test_dataset = MNIST('~/datasets/mnist', train=False, download=True, transform=transforms.ToTensor()) elif hparams.dataset == 'cifar10': dataset = CIFAR10('~/datasets/cifar10', train=True, download=True, transform=transforms.ToTensor()) val_size = int(hparams.val_split * len(dataset)) train_dataset, val_dataset = random_split( dataset, [len(dataset) - val_size, val_size]) if 'test' in ds_types: test_dataset = CIFAR10('~/datasets/cifar10', train=False, download=True, transform=transforms.ToTensor()) elif hparams.dataset == 'cifar100': dataset = CIFAR100('~/datasets/cifar100', train=True, download=True, transform=transforms.ToTensor()) val_size = int(hparams.val_split * len(dataset)) train_dataset, val_dataset = random_split( dataset, [len(dataset) - val_size, val_size]) if 'test' in ds_types: test_dataset = CIFAR100('~/datasets/cifar100', train=False, download=True, transform=transforms.ToTensor()) else: raise NotImplementedError dataloaders = dict( train_dataloader=None if 'train' not in ds_types else DataLoader( train_dataset, batch_size=hparams.batch_size, shuffle=hparams.shuffle, num_workers=hparams.dl_num_workers), val_dataloaders=None if 'val' not in ds_types else DataLoader( val_dataset, batch_size=hparams.batch_size, shuffle=False, num_workers=hparams.dl_num_workers), test_dataloaders=None if 'test' not in ds_types else DataLoader( test_dataset, batch_size=hparams.batch_size, shuffle=False, num_workers=hparams.dl_num_workers), ) return {k: v for k, v in dataloaders.items() if v is not None}
import torch import torch.nn as nn import torch.nn.functional as F from torch.utils.data import random_split from torch.utils.data.dataloader import DataLoader from torchvision.datasets import MNIST from torchvision.transforms import ToTensor from torchutils import BaseModel from torchutils.utils import * from torchutils.callbacks.callbacks import ModelCheckpoint from torchutils.losses.losses import cross_entropy_focal_loss from torchutils.metrics.metrics import accuraty dataset = MNIST(root='data/', download=True, transform=ToTensor()) val_size = 10000 train_size = len(dataset) - val_size train_ds, val_ds = random_split(dataset, [train_size, val_size]) len(train_ds), len(val_ds) labels = [y for _, y in train_ds] batch_size = 128 train_loader = DataLoader(train_ds, # batch_size, batch_sampler=RandomBalancedSampler(list(range(len(labels))), labels, batch_size=batch_size), # shuffle=True, num_workers=0, pin_memory=True) val_loader = DataLoader(val_ds, batch_size * 2, num_workers=4, pin_memory=True)
default=2) parser.add_argument( '--data_parallel', type=bool, help='whether to parallelise based on data (default: False)', default=False) args = parser.parse_args() # Define dataset transform = transforms.Compose([ transforms.ToTensor(), transforms.Lambda(lambda x: torch.bernoulli(x)) ]) dataset = MNIST(root=args.data_dir, train=True, download=True, transform=transform) # Create model and optimizer model = DRAW(x_dim=784, h_dim=256, z_dim=16, T=10).to(device) model = nn.DataParallel(model) if args.data_parallel else model optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, betas=(0.5, 0.999)) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 10, 0.5) # Load the dataset kwargs = {'num_workers': args.workers, 'pin_memory': True} if cuda else {} loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True,
total = output.shape[0] _, pred_label = output.max(1) num_correct = (pred_label == label).sum().item() return num_correct / total data_tf = tfs.Compose([ tfs.ToTensor(), tfs.Normalize([0.5], [0.5]) # 标准化 ]) num_epoch = 10 batch_size = 64 train_set = MNIST('C:/Users/Jet Zhang/Desktop/pytorch/mnist', train=True, transform=data_tf) test_set = MNIST('C:/Users/Jet Zhang/Desktop/pytorch/mnist', train=False, transform=data_tf) train_data = DataLoader(train_set, batch_size, True, num_workers=0) test_data = DataLoader(test_set, batch_size * 2, False, num_workers=0) net = LinerSVM(10) optimzier = torch.optim.Adadelta(net.parameters(), 1e-3) criterion = multiClassHingeLoss() for epoch in range(num_epoch):
def prepare_data(self): transform = self._get_transform() _ = MNIST(root=self.config['data_root'], train=True, transform=transform, download=True)
def forward(self, x): return torch.relu(self.l1(x.view(x.size(0), -1))) def training_step(self, batch, batch_idx): x, y = batch y_hat = self(x) loss = F.cross_entropy(y_hat, y) self.log('train_loss', loss) return loss def configure_optimizers(self): return torch.optim.Adam(self.parameters(), lr=PARAMS['learning_rate']) # DataLoader train_loader = DataLoader(MNIST(os.getcwd(), download=True, transform=transforms.ToTensor()), batch_size=PARAMS['batch_size']) # Step 4: Create NeptuneLogger from pytorch_lightning.loggers.neptune import NeptuneLogger neptune_logger = NeptuneLogger( api_key="ANONYMOUS", project_name="shared/pytorch-lightning-integration", params=PARAMS) # Step 5: Pass NeptuneLogger to the Trainer trainer = pl.Trainer(max_epochs=PARAMS['max_epochs'], logger=neptune_logger)
def prepare_data(self): MNIST(os.getcwd(), train=True, download=True, transform=transforms.ToTensor())
def load_mnist(path, batch_size): return DataLoader(MNIST(path, download=True, transform=transforms.ToTensor()), batch_size=batch_size, shuffle=True)
def download_data(data_dir): transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ]) return MNIST(data_dir, train=True, download=True, transform=transform)
def download_mnist(data_dir): # Original URL: http://yann.lecun.com/exdb/mnist/ full_path = stage_path(data_dir, "MNIST") MNIST(full_path, download=True)
# To add a new cell, type '# %%' # To add a new markdown cell, type '# %% [markdown]' # %% from IPython import get_ipython # %% import torch import torchvision from torchvision.datasets import MNIST # %% dataset = MNIST(root='data/', download=True) # %% len(dataset) # %% dataset[0] # %% import matplotlib.pyplot as plt get_ipython().run_line_magic('matplotlib', 'inline') # %% image, label = dataset[0] plt.imshow(image)
from torch.utils.data import DataLoader import torch.nn as nn import torch.cuda as cuda #Transformations and data augmentation train_transformations = transforms.Compose([ transforms.Resize(28), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) batch_size = 64 # Load the training set train_set = MNIST(root="./data", train=True, transform=train_transformations, download=True) train_data = DataLoader(train_set, batch_size=batch_size, shuffle=True, num_workers=4) #Create an instance of the NormalDistribution source = tfgan.NormalDistribution(length=len(train_set), size=(100)) source_data = DataLoader(source, batch_size=batch_size, shuffle=True, num_workers=4) #Create an instance of the Generator and Discriminator
def get_dataset(train): return MNIST('.', train=train, transform=lambda x: ToTensor()(x).view(-1))
import torch import torch.nn as nn from torch.utils.data import random_split from torchvision.datasets import MNIST from torchvision.transforms import ToTensor from poutyne import Model, EpochMetric # Instanciate the MNIST dataset train_valid_dataset = MNIST('./datasets', train=True, download=True, transform=ToTensor()) test_dataset = MNIST('./datasets', train=False, download=True, transform=ToTensor()) train_dataset, valid_dataset = random_split( train_valid_dataset, [50_000, 10_000], generator=torch.Generator().manual_seed(42)) # Select CUDA device if available cuda_device = 0 device = torch.device('cuda:%d' % cuda_device if torch.cuda.is_available() else 'cpu') # Define the network network = nn.Sequential(nn.Flatten(), nn.Linear(28 * 28, 100), nn.ReLU(), nn.Linear(100, 10)) epochs = 5
import torch from torchvision import transforms from torch.utils.data import DataLoader from torchvision.datasets import MNIST, CIFAR10, ImageFolder a = torch.cuda.is_available() print(a) ngpu = 1 # Decide which device we want to run on device = torch.device("cuda:0" if ( torch.cuda.is_available() and ngpu > 0) else "cpu") print(device) print(torch.cuda.get_device_name(0)) print(torch.rand(3, 3)) transform = transforms.Compose([ transforms.Resize(32), transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ]) train_ds = MNIST(root='./data', train=True, download=True, transform=transform) train_dl = DataLoader(dataset=train_ds, batch_size=32, shuffle=True, drop_last=True) for data in train_dl: print(data[0])
def __init__(self, data_root, noise_level): MNIST_db = MNIST(root = data_root,train = True, download = True, transform=torchvision.transforms.ToTensor()) self.getitem = MNIST_db.__getitem__ self.len = MNIST_db.__len__() self.noise_level = noise_level
x = 0.5 * (x + 1) x = x.clamp(0, 1) x = x.view(x.size(0), 1, 28, 28) return x num_epochs = 100 batch_size = 128 learning_rate = 1e-3 img_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) dataset = MNIST('./data', transform=img_transform) dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True) class autoencoder(nn.Module): def __init__(self): super(autoencoder, self).__init__() self.encoder = nn.Sequential( nn.Linear(28 * 28, 128), nn.ReLU(True), nn.Linear(128, 64), nn.ReLU(True), nn.Linear(64, 12), nn.ReLU(True), nn.Linear(12, 3)) self.decoder = nn.Sequential( nn.Linear(3, 12), nn.ReLU(True), nn.Linear(12, 64),
def main(): # 画像を変換の構成 transform = transforms.Compose( # 画像をTensor型に変換 [ transforms.ToTensor(), # モノクロ画像の平均値と標準偏差によって正規化する transforms.Normalize((0.5, ), (0.5, )) ]) # 学習用データセット trainset = MNIST( root='./data', # データパス train=True, # 学習用データか否か download=True, # ダウンロードするか否か transform=transform) # 上記の画像変換の構成で画像変換する # テスト用データセット testset = MNIST( root='./data', # データパス train=False, # 学習用データか否か download=True, # ダウンロードするか否か transform=transform) # 上記の画像変換の構成で画像変換する trainloader = DataLoader( trainset, # データセット batch_size=128, # バッチ数 shuffle=True, # 学習世代ごとにシャッフルする num_workers=2) # データを読み込むサブプロセスの数(CPUが強ければ大きくしてもいいかも?) testloader = DataLoader( testset, # データセット batch_size=128, # バッチ数 shuffle=False, # 学習世代ごとにシャッフルする num_workers=2) # データを読み込むサブプロセスの数(CPUが強ければ大きくしてもいいかも?) # タプルで(0,1,2,3,4,5,6,7,8,9)の等差数列(np.linspace)を作る classes = tuple(np.linspace(0, 9, 10, dtype=np.uint8)) # ネットワークモデルの読み込み device = torch.device("cuda" if torch.cuda.is_available() else "cpu") net = Net().to(device) #net.to(device) # 基準となる損失関数の指定 criterion = nn.CrossEntropyLoss() # 最適化のためにネットワークのパラメータと学習率、勾配の勢い、Nesterov加速勾配の有効化 optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.99, nesterov=True) # 10世代学習させる for epoch in range(10): running_loss = 0.0 # 1バッチ分のループ for i, (inputs, labels) in enumerate(trainloader, 0): # 勾配の初期化 optimizer.zero_grad() # ネットワークにトレーニングデータを読み込ませる #outputs = net(inputs) inputs = inputs.to(device) labels = labels.to(device) outputs = net(inputs) # 誤差 loss = criterion(outputs, labels) # 誤差伝搬 loss.backward() # パラメータ更新 optimizer.step() # 1バッチ回ったらロスを表示する running_loss += loss.item() if i % 100 == 99: print('[{:d}, {:5d}] loss: {:.3f}'.format( epoch + 1, i + 1, running_loss / 100)) running_loss = 0.0 print('Finished Training') # 検証 correct = 0 total = 0 with torch.no_grad(): # テストデータを読み込み for (images, labels) in testloader: # imageをネットワークに読み込ませる images = images.to(device) labels = labels.to(device) outputs = net(images) # 予測正確性と予測した種類を数値で返す _, predicted = torch.max(outputs.data, 1) # 1バッチのデータ分に相当=>100 total += labels.size(0) # 1バッチのテストデータ正解の個数をカウント correct += (predicted == labels).sum().item() print('Accuracy: {:.2f} %'.format(100 * float(correct / total))) # モデルの保存 torch.save(net.state_dict(), "./mnist_model.pth")