keras.md

srun -p ml --gres=gpu:1 -n 1 --pty --mem-per-cpu=8000 bash

module load modenv/ml                           #example output: The following have been reloaded with a version change:  1) modenv/scs5 => modenv/ml

mkdir python-virtual-environments
cd python-virtual-environments
module load TensorFlow                          #example output: Module TensorFlow/1.10.0-PythonAnaconda-3.6 and 1 dependency loaded.
which python
python3 -m venv --system-site-packages env      #create virtual environment "env" which inheriting with global site packages
source env/bin/activate                         #example output: (env) bash-4.2$
module load TensorFlow
python
import tensorflow as tf
from tensorflow.keras import layers

print(tf.VERSION)                               #example output: 1.10.0
print(tf.keras.__version__)                     #example output: 2.1.6-tf
import tensorflow as tf
from tensorflow.keras import layers
import numpy as np

# Numpy arrays to train and evaluate a model
data = np.random.random((50000, 32))
labels = np.random.random((50000, 10))

# Create a custom layer by subclassing
class MyLayer(layers.Layer):

  def __init__(self, output_dim, **kwargs):
    self.output_dim = output_dim
    super(MyLayer, self).__init__(**kwargs)

# Create the weights of the layer
  def build(self, input_shape):
    shape = tf.TensorShape((input_shape[1], self.output_dim))
# Create a trainable weight variable for this layer
    self.kernel = self.add_weight(name='kernel',
                                  shape=shape,
                                  initializer='uniform',
                                  trainable=True)
    super(MyLayer, self).build(input_shape)
# Define the forward pass
  def call(self, inputs):
    return tf.matmul(inputs, self.kernel)

# Specify how to compute the output shape of the layer given the input shape.
  def compute_output_shape(self, input_shape):
    shape = tf.TensorShape(input_shape).as_list()
    shape[-1] = self.output_dim
    return tf.TensorShape(shape)

# Serializing the layer
  def get_config(self):
    base_config = super(MyLayer, self).get_config()
    base_config['output_dim'] = self.output_dim
    return base_config

  @classmethod
  def from_config(cls, config):
    return cls(**config)
# Create a model using your custom layer
model = tf.keras.Sequential([
    MyLayer(10),
    layers.Activation('softmax')])

# The compile step specifies the training configuration
model.compile(optimizer=tf.compat.v1.train.RMSPropOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# Trains for 10 epochs(steps).
model.fit(data, labels, batch_size=32, epochs=10)
#!/bin/bash
#SBATCH --mem=4GB                         # specify the needed memory
#SBATCH -p ml                             # specify ml partition
#SBATCH --gres=gpu:1                      # use 1 GPU per node (i.e. use one GPU per task)
#SBATCH --nodes=1                         # request 1 node
#SBATCH --time=00:05:00                   # runs for 5 minutes
#SBATCH -c 16                             # how many cores per task allocated
#SBATCH -o HLR_Keras_example.out          # save output message under HLR_${SLURMJOBID}.out
#SBATCH -e HLR_Keras_example.err          # save error messages under HLR_${SLURMJOBID}.err

module load modenv/ml
module load TensorFlow

python Keras_example.py

## when finished writing, submit with:  sbatch <script_name>
......
Epoch 9/10
50000/50000 [==============================] - 2s 37us/sample - loss: 11.5159 - acc: 0.1000
Epoch 10/10
50000/50000 [==============================] - 2s 37us/sample - loss: 11.5159 - acc: 0.1020
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()                  #instead of "import tensorflow as tf"