In [1]:
import tensorflow as tf
device_name = tf.test.gpu_device_name()
if device_name != '/device:GPU:0':
raise SystemError('GPU device not found')
print('Found GPU at: {}'.format(device_name))
In [2]:
!apt install libnvrtc8.0
!pip install mxnet-cu80
import mxnet as mx
In [0]:
from __future__ import print_function
import numpy as np
import mxnet as mx
from mxnet import nd, autograd, gluon
data_ctx = mx.cpu()
model_ctx = mx.gpu(0)
In [0]:
batch_size = 64
num_inputs = 784
num_outputs = 10
num_examples = 60000
def transform(data, label):
return data.astype(np.float32)/255, label.astype(np.float32)
In [0]:
train_data = mx.gluon.data.DataLoader(mx.gluon.data.vision.MNIST(train=True, transform=transform),
batch_size, shuffle=True)
test_data = mx.gluon.data.DataLoader(mx.gluon.data.vision.MNIST(train=False, transform=transform),
batch_size, shuffle=False)
In [0]:
class MLP(gluon.Block):
def __init__(self, **kwargs):
super(MLP, self).__init__(**kwargs)
with self.name_scope():
self.dense0 = gluon.nn.Dense(64)
self.dense1 = gluon.nn.Dense(64)
self.dense2 = gluon.nn.Dense(10)
def forward(self, x):
x = nd.relu(self.dense0(x))
x = nd.relu(self.dense1(x))
x = self.dense2(x)
return x
In [0]:
net = MLP()
net.collect_params().initialize(mx.init.Normal(sigma=.01), ctx=model_ctx)
In [8]:
data = nd.ones((1,784))
net(data.as_in_context(model_ctx))
Out[8]:
In [9]:
class MLP(gluon.Block):
def __init__(self, **kwargs):
super(MLP, self).__init__(**kwargs)
with self.name_scope():
self.dense0 = gluon.nn.Dense(64, activation="relu")
self.dense1 = gluon.nn.Dense(64, activation="relu")
self.dense2 = gluon.nn.Dense(10)
def forward(self, x):
x = self.dense0(x)
print("Hidden Representation 1: %s" % x)
x = self.dense1(x)
print("Hidden Representation 2: %s" % x)
x = self.dense2(x)
print("Network output: %s" % x)
return x
net = MLP()
net.collect_params().initialize(mx.init.Normal(sigma=.01), ctx=model_ctx)
net(data.as_in_context(model_ctx))
Out[9]:
In [0]:
num_hidden = 64
net = gluon.nn.HybridSequential()
with net.name_scope():
net.add(gluon.nn.Dense(num_hidden, activation="relu"))
net.add(gluon.nn.Dense(num_hidden, activation="relu"))
net.add(gluon.nn.Dense(num_outputs))
net.hybridize()
In [0]:
net.collect_params().initialize(mx.init.Normal(sigma=.1), ctx=model_ctx)
In [0]:
softmax_cross_entropy = gluon.loss.SoftmaxCrossEntropyLoss()
In [0]:
trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': .01})
In [0]:
def evaluate_accuracy(data_iterator, net):
acc = mx.metric.Accuracy()
for i, (data, label) in enumerate(data_iterator):
data = data.as_in_context(model_ctx).reshape((-1, 784))
label = label.as_in_context(model_ctx)
output = net(data)
predictions = nd.argmax(output, axis=1)
acc.update(preds=predictions, labels=label)
return acc.get()[1]
In [15]:
!pip install mxboard
In [0]:
from mxboard import SummaryWriter
sw = SummaryWriter(logdir='logs', flush_secs=5)
In [20]:
epochs = 10
smoothing_constant = .01
# collect parameter names for logging the gradients of parameters in each epoch
params = net.collect_params()
param_names = params.keys()
global_step = 0
for e in range(epochs):
cumulative_loss = 0
for i, (data, label) in enumerate(train_data):
data = data.as_in_context(model_ctx).reshape((-1, 784))
label = label.as_in_context(model_ctx)
with autograd.record():
output = net(data)
loss = softmax_cross_entropy(output, label)
sw.add_scalar(tag='cross_entropy', value=loss.mean().asscalar(), global_step=global_step)
if i == 0:
sw.add_image('minist_first_minibatch', data.reshape((batch_size, 1, 28, 28)), e)
if e == 0:
sw.add_graph(net)
grads = [i.grad() for i in net.collect_params().values()]
for i, name in enumerate(param_names):
sw.add_histogram(tag=name, values=grads[i], global_step=e, bins=1000)
global_step += 1
loss.backward()
trainer.step(data.shape[0])
cumulative_loss += nd.sum(loss).asscalar()
test_accuracy = evaluate_accuracy(test_data, net)
train_accuracy = evaluate_accuracy(train_data, net)
sw.add_scalar(tag='accuracy_curves', value=('train_acc', train_accuracy), global_step=e)
sw.add_scalar(tag='accuracy_curves', value=('valid_acc', test_accuracy), global_step=e);
print ("Epoch %s. Loss: %s, Train_acc %s, Test_acc %s" % (e, cumulative_loss/num_examples, train_accuracy, test_accuracy))
In [22]:
!ls logs
In [0]:
!zip -r logs.zip logs/
In [0]:
from google.colab import files
files.download('logs.zip')
In [29]:
!ls -lhta logs.zip
In [36]:
!pwd
In [0]:
LOG_DIR = '/content/logs'
get_ipython().system_raw(
'tensorboard --logdir {} --host 127.0.0.1 --port 6006 & || echo failed'
.format(LOG_DIR)
)
In [33]:
! wget https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip
! unzip ngrok-stable-linux-amd64.zip
In [0]:
get_ipython().system_raw('./ngrok http 6006 &')
In [97]:
! curl -s http://localhost:4040/api/tunnels | python3 -c \
"import sys, json; print(json.load(sys.stdin)['tunnels'][0]['public_url'])"
In [98]:
!python /usr/local/lib/python2.7/dist-packages/tensorboard/main.py --logdir /content/logs --host 0.0.0.0 --port 6006 2>&1|grep -v Reloader