Tensorflow 2.0.1

# MNIST Dataset parameters.

num_features = 784 # data features (img shape: 28*28).

# Training parameters.

lr_generator = 0.0002

lr_discriminator = 0.0002

training_steps = 20000

batch_size = 128

report_step = 1000

display_step = 2500

# Network parameters.

noise_dim = 100 # Noise data points.

from __future__ import absolute_import, division, print_function

import tensorflow as tf

from tensorflow.keras import Model, layers

import numpy as np

# Prepare MNIST data.

from tensorflow.keras.datasets import mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Convert to float32.

x_train, x_test = np.array(x_train, np.float32), np.array(x_test, np.float32)

# Normalize images value from [0, 255] to [0, 1].

x_train, x_test = x_train / 255., x_test / 255.

# Use tf.data API to shuffle and batch data.

train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))

train_data = train_data.repeat().shuffle(10000).batch(batch_size).prefetch(1)

# Create TF Model.

class Generator(Model):

    # Set layers.

    def __init__(self):

        super(Generator, self).__init__()

        self.fc1 = layers.Dense(7 * 7 * 128)

        self.bn1 = layers.BatchNormalization()

        self.conv2tr1 = layers.Conv2DTranspose(64, 5, strides=2, padding='SAME')

        self.bn2 = layers.BatchNormalization()

        self.conv2tr2 = layers.Conv2DTranspose(1, 5, strides=2, padding='SAME')

    # Set forward pass.

    def call(self, x, is_training=False):

        x = self.fc1(x)

        x = self.bn1(x, training=is_training)

        x = tf.nn.leaky_relu(x)

        # Reshape to a 4-D array of images: (batch, height, width, channels)

        # New shape: (batch, 7, 7, 128)

        x = tf.reshape(x, shape=[-1, 7, 7, 128])

        # Deconvolution, image shape: (batch, 14, 14, 64)

        x = self.conv2tr1(x)

        x = self.bn2(x, training=is_training)

        x = tf.nn.leaky_relu(x)

        # Deconvolution, image shape: (batch, 28, 28, 1)

        x = self.conv2tr2(x)

        x = tf.nn.tanh(x)

        return x

# Generator Network

# Input: Noise, Output: Image

# Note that batch normalization has different behavior at training and inference time,

# we then use a placeholder to indicates the layer if we are training or not.

class Discriminator(Model):

    # Set layers.

    def __init__(self):

        super(Discriminator, self).__init__()

        self.conv1 = layers.Conv2D(64, 5, strides=2, padding='SAME')

        self.bn1 = layers.BatchNormalization()

        self.conv2 = layers.Conv2D(128, 5, strides=2, padding='SAME')

        self.bn2 = layers.BatchNormalization()

        self.flatten = layers.Flatten()

        self.fc1 = layers.Dense(1024)

        self.bn3 = layers.BatchNormalization()

        self.fc2 = layers.Dense(2)

    # Set forward pass.

    def call(self, x, is_training=False):

        x = tf.reshape(x, [-1, 28, 28, 1])

        x = self.conv1(x)

        x = self.bn1(x, training=is_training)

        x = tf.nn.leaky_relu(x)

        x = self.conv2(x)

        x = self.bn2(x, training=is_training)

        x = tf.nn.leaky_relu(x)

        x = self.flatten(x)

        x = self.fc1(x)

        x = self.bn3(x, training=is_training)

        x = tf.nn.leaky_relu(x)

        return self.fc2(x)

# Build neural network model.

generator = Generator()

discriminator = Discriminator()

# Losses.

def generator_loss(reconstructed_image):

    gen_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(

        logits=reconstructed_image, labels=tf.ones([batch_size], dtype=tf.int32)))

    return gen_loss

def discriminator_loss(disc_fake, disc_real):

    disc_loss_real = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(

        logits=disc_real, labels=tf.ones([batch_size], dtype=tf.int32)))

    disc_loss_fake = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(

        logits=disc_fake, labels=tf.zeros([batch_size], dtype=tf.int32)))

    return disc_loss_real + disc_loss_fake

# Optimizers.

optimizer_gen = tf.optimizers.Adam(learning_rate=lr_generator)#, beta_1=0.5, beta_2=0.999)

optimizer_disc = tf.optimizers.Adam(learning_rate=lr_discriminator)#, beta_1=0.5, beta_2=0.999)

# Optimization process. Inputs: real image and noise.

def run_optimization(real_images):

    # Rescale to [-1, 1], the input range of the discriminator

    real_images = real_images * 2. - 1.

    # Generate noise.

    noise = np.random.normal(-1., 1., size=[batch_size, noise_dim]).astype(np.float32)

    with tf.GradientTape() as g:

        fake_images = generator(noise, is_training=True)

        disc_fake = discriminator(fake_images, is_training=True)

        disc_real = discriminator(real_images, is_training=True)

        disc_loss = discriminator_loss(disc_fake, disc_real)

    # Training Variables for each optimizer

    gradients_disc = g.gradient(disc_loss,  discriminator.trainable_variables)

    optimizer_disc.apply_gradients(zip(gradients_disc,  discriminator.trainable_variables))

    # Generate noise.

    noise = np.random.normal(-1., 1., size=[batch_size, noise_dim]).astype(np.float32)

    with tf.GradientTape() as g:

        fake_images = generator(noise, is_training=True)

        disc_fake = discriminator(fake_images, is_training=True)

        gen_loss = generator_loss(disc_fake)

    gradients_gen = g.gradient(gen_loss, generator.trainable_variables)

    optimizer_gen.apply_gradients(zip(gradients_gen, generator.trainable_variables))

    return gen_loss, disc_loss

import matplotlib.pyplot as plt

n_x, n_y = 10, 4

canvas = np.empty((28*n_y, 28*n_x))

# Run training for the given number of steps.

for step, (batch_x, _) in enumerate(train_data.take(training_steps + 1)):

  if step == 0:

    # Generate noise.

    noise = np.random.normal(-1., 1., 

                             size=[batch_size, noise_dim]).astype(np.float32)

    gen_loss = generator_loss(discriminator(generator(noise)))

    disc_loss = discriminator_loss(discriminator(batch_x), 

                                   discriminator(generator(noise)))

    print("initial: gen_loss: %f, disc_loss: %f" % (gen_loss, disc_loss))

    continue

  # Run the optimization.

  gen_loss, disc_loss = run_optimization(batch_x)

  # report

  if step % report_step == 0:

    print("step: %i, gen_loss: %f, disc_loss: %f" % 

          (step, gen_loss, disc_loss))

  # show a sample of generated images

  if step % display_step == 0 or step == 1:

    for i_y in range(n_y):

      # Noise input.

      z = np.random.normal(-1., 1., size=[n_x, noise_dim]).astype(np.float32)

      # Generate image from noise.

      g = generator(z).numpy()

      # Rescale to original [0, 1]

      g = (g + 1.) / 2

      # Reverse colours for better display

      g = -1 * (g - 1)

      for i_x in range(n_x):

        canvas[i_y * 28:(i_y + 1) * 28, 

               i_x * 28:(i_x + 1) * 28] = g[i_x].reshape([28, 28])

    plt.figure(figsize=(n_x, n_y))

    plt.imshow(canvas, origin="upper", cmap="gray")

    plt.suptitle("Step {}".format(step))

    plt.xticks([])

    plt.yticks([])

    plt.savefig("/results/step-{}.svg".format(step))

    plt.close()

from __future__ import print_function

import keras

from keras.datasets import mnist

from keras.models import Sequential

from keras.layers import Dense, Dropout

from keras.optimizers import RMSprop

batch_size = 128

num_classes = 10

epochs = 20

# the data, split between train and test sets

(x_train, y_train), (x_test, y_test) = mnist.load_data()

x_train = x_train.reshape(60000, 784)

x_test = x_test.reshape(10000, 784)

x_train = x_train.astype('float32')

x_test = x_test.astype('float32')

x_train /= 255

x_test /= 255

print(x_train.shape[0], 'train samples')

print(x_test.shape[0], 'test samples')

# convert class vectors to binary class matrices

y_train = keras.utils.to_categorical(y_train, num_classes)

y_test = keras.utils.to_categorical(y_test, num_classes)

model = Sequential()

model.add(Dense(512, activation='relu', input_shape=(784,)))

model.add(Dropout(0.2))

model.add(Dense(512, activation='relu'))

model.add(Dropout(0.2))

model.add(Dense(num_classes, activation='softmax'))

model.summary()

model.compile(loss='categorical_crossentropy',

              optimizer=RMSprop(),

              metrics=['accuracy'])

history = model.fit(x_train, y_train,

                    batch_size=batch_size,

                    epochs=epochs,

                    verbose=1,

                    validation_data=(x_test, y_test))

model.save("/results/mnist.kerasave")

import keras

from keras.datasets import mnist

from keras.models import load_model

num_classes = 10

(_,_), (x_test, y_test) = mnist.load_data()

x_test = x_test.reshape(10000, 784)

x_test = x_test.astype('float32')

x_test /= 255

y_test = keras.utils.to_categorical(y_test, num_classes)

model = load_model(
mnist.kerasave)

score = model.evaluate(x_test, y_test, verbose=0)

print('Test loss:', score[0])

print('Test accuracy:', score[1])

apt-get -qq update

apt-get install --no-install-recommends \

  xutils-dev zlib1g-dev libjemalloc-dev

update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-7 25

update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-7 25

echo "/usr/local/cuda/extras/CUPTI/lib64" > /etc/ld.so.conf.d/cupti.conf

ldconfig

conda install \

  absl-py astor gast google-pasta opt_einsum protobuf termcolor wrapt \

  tensorboard tensorflow-estimator keras-applications keras-preprocessing

cd /usr/local

tar -zxf 
TensorRT-7.0.0.11.Ubuntu-18.04.x86_64-gnu.cuda-10.2.cudnn7.6.tar.gz

ln -sf TensorRT* tensorrt

echo '/usr/local/tensorrt/lib' > /etc/ld.so.conf.d/tensorrt.conf

ldconfig

cd /usr/local/tensorrt

pip install python/tensorrt*cp37*.whl \

  uff/uff*.whl graphsurgeon/graphsurgeon*.whl

mkdir -p /usr/local/nccl_redir

cd /usr/local/nccl_redir

for i in `ls /usr/local/cuda`; do ln -s /usr/local/cuda/$i ./; done

ln -s lib64 lib

export BAZEL_VERSION=0.26.1

export BAZEL_FILE=bazel-${BAZEL_VERSION}-installer-linux-x86_64.sh

wget --progress=dot:giga \

  https://github.com/bazelbuild/bazel/releases/download/$BAZEL_VERSION/$BAZEL_FILE

chmod +x $BAZEL_FILE

./$BAZEL_FILE

git clone https://github.com/tensorflow/tensorflow

cd tensorflow

git checkout v2.0.1

cd /tensorflow

export TF_ROOT="/opt/tensorflow"

export PYTHON_BIN_PATH="/opt/conda/bin/python"

export PYTHON_LIB_PATH="$($PYTHON_BIN_PATH -c 'import site; print(site.getsitepackages()[0])')"

export PYTHONPATH=${TF_ROOT}/lib

export PYTHON_ARG=${TF_ROOT}/lib

export TF_NEED_GCP=1   # Google Cloud

export TF_NEED_HDFS=1  # Hadoop Filesystem access

export TF_NEED_S3=1    # Amazon S3

export TF_NEED_AWS=0   # Amazon AWS

export TF_NEED_IGNITE=1

export TF_NEED_KAFKA=1 # Apache KAFKA

export TF_NEED_JEMALLOC=1 # Alternative malloc

export TF_NEED_GDR=0   # GPU Direct RDMA

export TF_NEED_VERBS=0 # VERBS RDMA

export TF_NEED_CUDA=1

export CUDA_TOOLKIT_PATH=/usr/local/cuda

export TF_CUDA_VERSION="$($CUDA_TOOLKIT_PATH/bin/nvcc --version | sed -n 's/^.*release \(.*\),.*/\1/p')"

export TF_CUDA_COMPUTE_CAPABILITIES=7.0,6.1,6.0,3.7 # V100, P100, P4, K80

export CUDNN_INSTALL_PATH=/usr/local/cuda

export TF_CUDNN_VERSION="$(sed -n 's/^#define CUDNN_MAJOR\s*\(.*\).*/\1/p' $CUDNN_INSTALL_PATH/include/cudnn.h)"

export TF_NEED_TENSORRT=1  # Nvidia TensorRT

export TENSORRT_INSTALL_PATH=/usr/local/tensorrt

export NCCL_INSTALL_PATH=/usr/local/nccl_redir # Nvidia NCCL

export TF_NCCL_VERSION="$(sed -n 's/^#define NCCL_MAJOR\s*\(.*\).*/\1/p' $NCCL_INSTALL_PATH/include/nccl.h)"

export TF_CUDA_CLANG=0    # Use clang compiler instead of nvcc

export TF_NEED_OPENCL=0

export TF_NEED_OPENCL_SYCL=0

export TF_NEED_ROCM=0

export TF_ENABLE_XLA=0    # Accelerated Linear Algebra JIT compiler

export TF_NEED_MKL=0       # Intel Math Kernel Library

export TF_DOWNLOAD_MKL=0

export TF_NEED_MPI=0       # Message Passing Interface

export TF_SET_ANDROID_WORKSPACE=0

export GCC_HOST_COMPILER_PATH=$(which gcc)

export CC_OPT_FLAGS="-march=sandybridge"

./configure

export LD_LIBRARY_PATH="/usr/local/cuda/lib64:/usr/local/nvidia/lib64"

export CUDNN_INCLUDE_DIR="/usr/local/cuda/include"

export CUDNN_LIBRARY="/usr/local/cuda/lib64/libcudnn.so"

export TMP="/tmp"

cd /tensorflow

bazel build --experimental_ui_limit_console_output=0 \

  --config=v2 --config=avx_linux \

  --config=opt --config=cuda --verbose_failures --jobs="auto" \

  --action_env="LD_LIBRARY_PATH=${LD_LIBRARY_PATH}" \

  --action_env="CUDNN_INCLUDE_DIR=${CUDNN_INCLUDE_DIR}" \

  --action_env="CUDNN_LIBRARY=${CUDNN_LIBRARY}" \

  //tensorflow/tools/pip_package:build_pip_package 

cd /tensorflow

bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg

cp /tmp/tensorflow_pkg/tensorflow*.whl /results/

conda install \

  absl-py astor google-pasta opt_einsum protobuf termcolor wrapt \

  mock pbr h5py grpcio markdown werkzeug cython jemalloc \

  pyyaml graphviz pydot # for use with Keras

conda clean -qtipy

echo "/usr/local/cuda/extras/CUPTI/lib64" > /etc/ld.so.conf.d/cupti.conf

cd /usr/local

tar -zxf 
TensorRT-7.0.0.11.Ubuntu-18.04.x86_64-gnu.cuda-10.2.cudnn7.6.tar.gz

ln -sf TensorRT* tensorrt

echo '/usr/local/tensorrt/lib' > /etc/ld.so.conf.d/tensorrt.conf

ldconfig

python -V

python -c 'print("blah")'

pip list > /dev/null

conda list > /dev/null

cd /usr/local/tensorrt

pip install python/tensorrt*cp37*.whl \

            uff/uff*.whl graphsurgeon/graphsurgeon*.whl

pip install 
tensorflow-2.0.1-cp37-cp37m-linux_x86_64.whl \

  'tensorboard>=2,<2.1' 'tensorflow-estimator>=2,<2.1' \

  'tensorflow-datasets>=2' \

  keras keras-applications keras-preprocessing

du -hsx /