Exemplo n.º 1
0
    def __init__(self, batch_size):
        self.mnist_train = gdata.vision.FashionMNIST(train=True)
        self.mnist_test = gdata.vision.FashionMNIST(train=False)

        print(f'len mnist_train : {len(self.mnist_train)}')
        print(f'len mnist_test : {len(self.mnist_test)}')

        features, label = self.mnist_train[0]
        print(
            f'check features data shape: {features.shape}, dtype: {features.dtype}'
        )
        print(
            f'check label data: {label}, type: {type(label)}, dtype: {label.dtype}'
        )

        self.train_iter, self.test_iter = d2l.load_data_fashion_mnist(
            batch_size)
Exemplo n.º 2
0
net.add(nn.Conv2D(channels=6, kernel_size=5, padding=2, activation='sigmoid'),
        nn.AvgPool2D(pool_size=2, strides=2),
        nn.Conv2D(channels=16, kernel_size=5, activation='sigmoid'),
        nn.AvgPool2D(pool_size=2, strides=2),
        nn.Dense(120, activation='sigmoid'),
        nn.Dense(84, activation='sigmoid'),
        nn.Dense(10))

X = nd.random.uniform(shape=(1, 1, 28, 28))
net.initialize()
for layer in net:
    X = layer(X)
    print(layer.name, 'output shape:\t', X.shape)

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)

def try_gpu():
    try:
        ctx = mx.gpu()
        _ = nd.zeros((1,), ctx=ctx)
    except mx.base.MXNetError:
        ctx = mx.cpu()
    return ctx

ctx = try_gpu()
ctx

def evaluate_accuracy(data_iter, net, ctx):
    acc_sum, n = nd.array([0], ctx=ctx), 0
    for X, y in data_iter:
Exemplo n.º 3
0
npx.set_np()

d2l.use_svg_display()

mnist_train = gluon.data.vision.FashionMNIST(train=True)
mnist_test = gluon.data.vision.FashionMNIST(train=False)

print("train length : {}, test length: {}".format(len(mnist_train),
                                                  len(mnist_test)))

X, y = mnist_train[:18]
# d2l.show_images(X.squeeze(axis=-1), 2, 9, titles=d2l.get_fashion_mnist_labels(y))
# plt.show()

batch_size = 256
transformer = gluon.data.vision.transforms.ToTensor()
train_iter = gluon.data.DataLoader(mnist_train.transform_first(transformer),
                                   batch_size,
                                   shuffle=True,
                                   num_workers=d2l.get_dataloader_workers())

timer = d2l.Timer()
for X, y in train_iter:
    continue
print("loading dada takes {:.2f} sec".format(timer.stop()))

train_iter, test_iter = d2l.load_data_fashion_mnist(32, (64, 64))
for X, y in train_iter:
    print(X.shape)
    break