Puis-je utiliser TensorBoard avec Google Colab?

Question

Est-il possible d'utiliser TensorBoard lors de la formation d'un modèle TensorFlow sur Google Colab?

Answer 1

EDIT: Vous voulez sans doute donner officielles %tensorboard magie d'un go, disponibles à partir de TensorFlow 1.13 de l'avant.

---

Avant l'existence de l' %tensorboard de la magie, la manière standard de ce processus a été de proxy réseau de trafic de la Colab VM à l'aide de ngrok. Une Colab exemple peut être trouvé ici.

Ce sont les étapes (les extraits de code représentent les cellules de type "code" en colab):

1. Obtenir TensorBoard cours d'exécution en arrière-plan.
   Inspiré par cette réponse.

   LOG_DIR = '/tmp/log'
   get_ipython().system_raw(
       'tensorboard --logdir {} --host 0.0.0.0 --port 6006 &'
       .format(LOG_DIR)
   )
   

2. Téléchargez et décompressez ngrok.
   Remplacer le lien transmis wget avec le bon lien de téléchargement pour votre système d'exploitation.

   ! wget https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip
   ! unzip ngrok-stable-linux-amd64.zip
   

3. Lancement ngrok processus d'arrière-plan...

   get_ipython().system_raw('./ngrok http 6006 &')
   

   ...et de récupérer l'url publique. Source

   ! curl -s http://localhost:4040/api/tunnels | python3 -c \
       "import sys, json; print(json.load(sys.stdin)['tunnels'][0]['public_url'])"
   

Answer 2

Voici un moyen plus simple de faire la même méthode de tunneling ngrok sur Google Colab.

 !pip install tensorboardcolab
 

ensuite,

 from tensorboardcolab import TensorBoardColab, TensorBoardColabCallback

tbc=TensorBoardColab()
 

En supposant que vous utilisez Keras:

 model.fit(......,callbacks=[TensorBoardColabCallback(tbc)])
 

Vous pouvez lire le post original ici .

Answer 3

TensorBoard pour TensorFlow en cours d'exécution sur Google Colab à l'aide de tensorboardcolab. Il utilise ngrok en interne pour les tunnels.

1. Installer TensorBoardColab

!pip install tensorboardcolab

2. Créer un objet tensorboardcolab

tbc = TensorBoardColab()

Cela crée automatiquement un TensorBoard lien qui peut être utilisé. Cette Tensorboard est de la lecture des données de./Graph'

3. Créer un FileWriter pointant vers cet emplacement

summary_writer = tbc.get_writer()

tensorboardcolab bibliothèque a la méthode qui retourne FileWriter objet de pointage ci-dessus './Graphique de l'emplacement.

4. Commencer à ajouter des informations de résumé de l'Événement fichiers './Graphique de l'emplacement à l'aide de summary_writer objet

Vous pouvez ajouter des scalaires de l'info ou de graphiques ou de données d'histogramme.

Référence: https://github.com/taomanwai/tensorboardcolab

Answer 4

J'ai essayé mais je n'ai pas obtenu le résultat, mais j'ai utilisé les résultats ci-dessous.

 import tensorboardcolab as tb
tbc = tb.TensorBoardColab()
 

Après cela, ouvrez le lien depuis la sortie.

 import tensorflow as tf
import numpy as np
 

Créer explicitement un objet Graph

 graph = tf.Graph()
with graph.as_default()
 

Exemple complet:

 with tf.name_scope("variables"):
    # Variable to keep track of how many times the graph has been run
    global_step = tf.Variable(0, dtype=tf.int32, name="global_step")

    # Increments the above `global_step` Variable, should be run whenever the graph is run
    increment_step = global_step.assign_add(1)

    # Variable that keeps track of previous output value:
    previous_value = tf.Variable(0.0, dtype=tf.float32, name="previous_value")

# Primary transformation Operations
with tf.name_scope("exercise_transformation"):

    # Separate input layer
    with tf.name_scope("input"):
        # Create input placeholder- takes in a Vector 
        a = tf.placeholder(tf.float32, shape=[None], name="input_placeholder_a")

    # Separate middle layer
    with tf.name_scope("intermediate_layer"):
        b = tf.reduce_prod(a, name="product_b")
        c = tf.reduce_sum(a, name="sum_c")

    # Separate output layer
    with tf.name_scope("output"):
        d = tf.add(b, c, name="add_d")
        output = tf.subtract(d, previous_value, name="output")
        update_prev = previous_value.assign(output)

# Summary Operations
with tf.name_scope("summaries"):
    tf.summary.scalar('output', output)  # Creates summary for output node
    tf.summary.scalar('product of inputs', b, )
    tf.summary.scalar('sum of inputs', c)

# Global Variables and Operations
with tf.name_scope("global_ops"):
    # Initialization Op
    init = tf.initialize_all_variables()
    # Collect all summary Ops in graph
    merged_summaries = tf.summary.merge_all()

# Start a Session, using the explicitly created Graph
sess = tf.Session(graph=graph)

# Open a SummaryWriter to save summaries
writer = tf.summary.FileWriter('./Graph', sess.graph)

# Initialize Variables
sess.run(init)

def run_graph(input_tensor):
    """
    Helper function; runs the graph with given input tensor and saves summaries
    """
    feed_dict = {a: input_tensor}
    output, summary, step = sess.run([update_prev, merged_summaries, increment_step], feed_dict=feed_dict)
    writer.add_summary(summary, global_step=step)


# Run the graph with various inputs
run_graph([2,8])
run_graph([3,1,3,3])
run_graph([8])
run_graph([1,2,3])
run_graph([11,4])
run_graph([4,1])
run_graph([7,3,1])
run_graph([6,3])
run_graph([0,2])
run_graph([4,5,6])

# Writes the summaries to disk
writer.flush()

# Flushes the summaries to disk and closes the SummaryWriter
writer.close()

# Close the session
sess.close()

# To start TensorBoard after running this file, execute the following command:
# $ tensorboard --logdir='./improved_graph'
 

Answer 5

Voici comment afficher vos modèles en ligne sur Google Colab. Voici un exemple très simple qui affiche un espace réservé:

 from IPython.display import clear_output, Image, display, HTML
import tensorflow as tf
import numpy as np
from google.colab import files

def strip_consts(graph_def, max_const_size=32):
    """Strip large constant values from graph_def."""
    strip_def = tf.GraphDef()
    for n0 in graph_def.node:
        n = strip_def.node.add() 
        n.MergeFrom(n0)
        if n.op == 'Const':
            tensor = n.attr['value'].tensor
            size = len(tensor.tensor_content)
            if size > max_const_size:
                tensor.tensor_content = "<stripped %d bytes>"%size
    return strip_def

def show_graph(graph_def, max_const_size=32):
    """Visualize TensorFlow graph."""
    if hasattr(graph_def, 'as_graph_def'):
        graph_def = graph_def.as_graph_def()
    strip_def = strip_consts(graph_def, max_const_size=max_const_size)
    code = """
        <script>
          function load() {{
            document.getElementById("{id}").pbtxt = {data};
          }}
        </script>
        <link rel="import" href="https://tensorboard.appspot.com/tf-graph-basic.build.html" onload=load()>
        <div style="height:600px">
          <tf-graph-basic id="{id}"></tf-graph-basic>
        </div>
    """.format(data=repr(str(strip_def)), id='graph'+str(np.random.rand()))

    iframe = """
        <iframe seamless style="width:1200px;height:620px;border:0" srcdoc="{}"></iframe>
    """.format(code.replace('"', '&quot;'))
    display(HTML(iframe))


"""Create a sample tensor"""
sample_placeholder= tf.placeholder(dtype=tf.float32) 
"""Show it"""
graph_def = tf.get_default_graph().as_graph_def()
show_graph(graph_def)
 

Actuellement, vous ne pouvez pas exécuter un service Tensorboard sur Google Colab de la manière dont vous l'exécutez localement. En outre, vous ne pouvez pas exporter l'intégralité de votre journal sur votre lecteur via un élément tel que summary_writer = tf.summary.FileWriter('./logs', graph_def=sess.graph_def) sorte que vous puissiez le télécharger et le consulter localement.