Tensorflow with Jupyterhub

ODP adds the Tensorflow libraries to JupyterHub so you can start using Tensorflow in your notebooks without any additional setup.

For example:

import tensorflow as tf
 
def download_tiny_shakespeare():
 path = tf.keras.utils.get_file(
 "shakespeare.txt",
 "https://storage.googleapis.com/download.tensorflow.org/data/shakespeare.txt",
 )
 with open(path, "r", encoding="utf-8") as f:
 text = f.read()
 return text
 
def build_dataset(text, seq_length=100, batch_size=64, buffer_size=10000):
 vocab = sorted(set(text))
 char2idx = {u: i for i, u in enumerate(vocab)}
 idx2char = tf.constant(vocab)
 
 text_as_int = tf.constant([char2idx[c] for c in text], dtype=tf.int32)
 
 ds = tf.data.Dataset.from_tensor_slices(text_as_int)
 sequences = ds.batch(seq_length + 1, drop_remainder=True)
 
 def split_input_target(chunk):
 return chunk[:-1], chunk[1:]
 
 ds = sequences.map(split_input_target, num_parallel_calls=tf.data.AUTOTUNE)
 ds = ds.shuffle(buffer_size).batch(batch_size, drop_remainder=True).prefetch(tf.data.AUTOTUNE)
 return ds, char2idx, idx2char, len(vocab)
 
def build_model(vocab_size, embedding_dim=256, rnn_units=512, batch_size=64):
 return tf.keras.Sequential([
 tf.keras.layers.Input(batch_shape=(batch_size, None), dtype=tf.int32),
 tf.keras.layers.Embedding(vocab_size, embedding_dim),
 tf.keras.layers.GRU(
 rnn_units,
 return_sequences=True,
 stateful=True,
 recurrent_initializer="glorot_uniform",
 ),
 tf.keras.layers.Dense(vocab_size),
 ])
 
def generate_text(model, start_string, char2idx, idx2char, num_generate=600, temperature=0.9):
 input_eval = tf.expand_dims([char2idx.get(s, 0) for s in start_string], 0)
 
 text_generated = []
 
 for layer in model.layers:
 if hasattr(layer, "reset_states"):
 layer.reset_states()
 
 for _ in range(num_generate):
 predictions = model(input_eval) # (1, time, vocab)
 predictions = predictions[:, -1, :] # (1, vocab)
 predictions = predictions / temperature
 
 predicted_id = tf.random.categorical(predictions, num_samples=1)[0, 0].numpy()
 input_eval = tf.expand_dims([predicted_id], 0)
 
 text_generated.append(idx2char[predicted_id].numpy().decode("utf-8"))
 
 return start_string + "".join(text_generated)
 
def main():
 tf.get_logger().setLevel("ERROR")
 print("TensorFlow:", tf.__version__)
 
 text = download_tiny_shakespeare()
 dataset, char2idx, idx2char, vocab_size = build_dataset(text, seq_length=100, batch_size=64)
 
 model = build_model(vocab_size, embedding_dim=256, rnn_units=512, batch_size=64)
 model.compile(
 optimizer=tf.keras.optimizers.Adam(1e-3),
 loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
 )
 
 model.fit(dataset, epochs=5)
 
 gen_model = build_model(vocab_size, embedding_dim=256, rnn_units=512, batch_size=1)
 gen_model.set_weights(model.get_weights())
 
 print("\n--- Generated monologue ---\n")
 print(generate_text(
 gen_model,
 start_string="KING HENRY:\n",
 char2idx=char2idx,
 idx2char=idx2char,
 num_generate=700,
 temperature=0.85,
 ))
 
if __name__ == "__main__":
 main()

This gives the output something similar to the following.

Known Limitations

While using Tensorflow, you will see warnings when running the code:

This is a known issue with TensorFlow and the version of Protobuf it uses. The warnings can be safely ignored or can be filtered out by adding the following to your script:

# To get TF_CPP_MIN_LOG_LEVEL to work, you must set it before importing tensorflow
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' 
import tensorflow as tf
import warnings
 
warnings.filterwarnings("ignore", category=UserWarning)

Which makes the output look like this: