Refactor examples

examples/frameworks/autokeras/autokeras_imdb_example.py

@@ -0,0 +1,55 @@
+import autokeras as ak
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+
+from trains import Task
+
+task = Task.init(project_name="autokeras", task_name="autokeras imdb example with scalars")
+
+
+def imdb_raw():
+    max_features = 20000
+    index_offset = 3  # word index offset
+
+    (x_train, y_train), (x_test, y_test) = tf.keras.datasets.imdb.load_data(
+        num_words=max_features,
+        index_from=index_offset)
+    x_train = x_train
+    y_train = y_train.reshape(-1, 1)
+    x_test = x_test
+    y_test = y_test.reshape(-1, 1)
+
+    word_to_id = tf.keras.datasets.imdb.get_word_index()
+    word_to_id = {k: (v + index_offset) for k, v in word_to_id.items()}
+    word_to_id["<PAD>"] = 0
+    word_to_id["<START>"] = 1
+    word_to_id["<UNK>"] = 2
+
+    id_to_word = {value: key for key, value in word_to_id.items()}
+    x_train = list(map(lambda sentence: ' '.join(
+        id_to_word[i] for i in sentence), x_train))
+    x_test = list(map(lambda sentence: ' '.join(
+        id_to_word[i] for i in sentence), x_test))
+    x_train = np.array(x_train, dtype=np.str)
+    x_test = np.array(x_test, dtype=np.str)
+    return (x_train, y_train), (x_test, y_test)
+
+
+# Prepare the data.
+(x_train, y_train), (x_test, y_test) = imdb_raw()
+print(x_train.shape)  # (25000,)
+print(y_train.shape)  # (25000, 1)
+print(x_train[0][:50])  # <START> this film was just brilliant casting <UNK>
+
+# Initialize the TextClassifier
+clf = ak.TextClassifier(max_trials=3)
+
+tensorboard_callback_train = keras.callbacks.TensorBoard(log_dir='log')
+tensorboard_callback_test = keras.callbacks.TensorBoard(log_dir='log')
+
+# Search for the best model.
+clf.fit(x_train, y_train, epochs=2, callbacks=[tensorboard_callback_train])
+clf.fit(x_test, y_test, epochs=2, callbacks=[tensorboard_callback_test])
+# Evaluate on the testing data.
+print('Accuracy: {accuracy}'.format(accuracy=clf.evaluate(x_test, y_test)))

examples/frameworks/autokeras/requirements.txt

@@ -0,0 +1,3 @@
+autokeras
+tensorflow==2.1.0
+trains

examples/frameworks/keras/keras_tensorboard.py

@@ -0,0 +1,118 @@
+# TRAINS - Keras with Tensorboard example code, automatic logging model and Tensorboard outputs
+#
+# Train a simple deep NN on the MNIST dataset.
+# Gets to 98.40% test accuracy after 20 epochs
+# (there is *a lot* of margin for parameter tuning).
+# 2 seconds per epoch on a K520 GPU.
+from __future__ import print_function
+
+import argparse
+import os
+import tempfile
+
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras import utils as np_utils
+from tensorflow.keras.callbacks import ModelCheckpoint, TensorBoard
+from tensorflow.keras.datasets import mnist
+from tensorflow.keras.layers import Activation, Dense
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.optimizers import RMSprop
+
+from trains import Task
+
+
+class TensorBoardImage(TensorBoard):
+    @staticmethod
+    def make_image(tensor):
+        from PIL import Image
+        import io
+        tensor = np.stack((tensor, tensor, tensor), axis=2)
+        height, width, channels = tensor.shape
+        image = Image.fromarray(tensor)
+        output = io.BytesIO()
+        image.save(output, format='PNG')
+        image_string = output.getvalue()
+        output.close()
+        return tf.Summary.Image(height=height,
+                                width=width,
+                                colorspace=channels,
+                                encoded_image_string=image_string)
+
+    def on_epoch_end(self, epoch, logs=None):
+        if logs is None:
+            logs = {}
+        super(TensorBoardImage, self).on_epoch_end(epoch, logs)
+        images = self.validation_data[0]  # 0 - data; 1 - labels
+        img = (255 * images[0].reshape(28, 28)).astype('uint8')
+
+        image = self.make_image(img)
+        summary = tf.Summary(value=[tf.Summary.Value(tag='image', image=image)])
+        self.writer.add_summary(summary, epoch)
+
+
+parser = argparse.ArgumentParser(description='Keras MNIST Example')
+parser.add_argument('--batch-size', type=int, default=128, help='input batch size for training (default: 128)')
+parser.add_argument('--epochs', type=int, default=6, help='number of epochs to train (default: 6)')
+args = parser.parse_args()
+
+# the data, shuffled and split between train and test sets
+nb_classes = 10
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+
+X_train = X_train.reshape(60000, 784).astype('float32')/255.
+X_test = X_test.reshape(10000, 784).astype('float32')/255.
+print(X_train.shape[0], 'train samples')
+print(X_test.shape[0], 'test samples')
+
+# convert class vectors to binary class matrices
+Y_train = np_utils.to_categorical(y_train, nb_classes)
+Y_test = np_utils.to_categorical(y_test, nb_classes)
+
+model = Sequential()
+model.add(Dense(512, input_shape=(784,)))
+model.add(Activation('relu'))
+# model.add(Dropout(0.2))
+model.add(Dense(512))
+model.add(Activation('relu'))
+# model.add(Dropout(0.2))
+model.add(Dense(10))
+model.add(Activation('softmax'))
+
+model2 = Sequential()
+model2.add(Dense(512, input_shape=(784,)))
+model2.add(Activation('relu'))
+
+model.summary()
+
+model.compile(loss='categorical_crossentropy',
+              optimizer=RMSprop(),
+              metrics=['accuracy'])
+
+# Connecting TRAINS
+task = Task.init(project_name='examples', task_name='Keras with TensorBoard example')
+task.connect_configuration({'test': 1337, 'nested': {'key': 'value', 'number': 1}})
+
+# Advanced: setting model class enumeration
+labels = dict(('digit_%d' % i, i) for i in range(10))
+task.set_model_label_enumeration(labels)
+
+output_folder = os.path.join(tempfile.gettempdir(), 'keras_example')
+
+board = TensorBoard(histogram_freq=1, log_dir=output_folder, write_images=False)
+model_store = ModelCheckpoint(filepath=os.path.join(output_folder, 'weight.{epoch}.hdf5'))
+
+# load previous model, if it is there
+# noinspection PyBroadException
+try:
+    model.load_weights(os.path.join(output_folder, 'weight.1.hdf5'))
+except Exception:
+    pass
+
+history = model.fit(X_train, Y_train,
+                    batch_size=args.batch_size, epochs=args.epochs,
+                    callbacks=[board, model_store],
+                    verbose=1, validation_data=(X_test, Y_test))
+score = model.evaluate(X_test, Y_test, verbose=0)
+print('Test score:', score[0])
+print('Test accuracy:', score[1])

examples/frameworks/keras/legacy/keras_tensorboard.py

@@ -0,0 +1,117 @@
+# TRAINS - Keras with Tensorboard example code, automatic logging model and Tensorboard outputs
+#
+# Train a simple deep NN on the MNIST dataset.
+# Gets to 98.40% test accuracy after 20 epochs
+# (there is *a lot* of margin for parameter tuning).
+# 2 seconds per epoch on a K520 GPU.
+from __future__ import print_function
+
+import argparse
+import tempfile
+import os
+import numpy as np
+
+from keras.callbacks import TensorBoard, ModelCheckpoint
+from keras.datasets import mnist
+from keras.models import Sequential
+from keras.layers.core import Dense, Activation
+from keras.optimizers import RMSprop
+from keras.utils import np_utils
+import tensorflow as tf
+from trains import Task
+
+
+class TensorBoardImage(TensorBoard):
+    @staticmethod
+    def make_image(tensor):
+        from PIL import Image
+        import io
+        tensor = np.stack((tensor, tensor, tensor), axis=2)
+        height, width, channels = tensor.shape
+        image = Image.fromarray(tensor)
+        output = io.BytesIO()
+        image.save(output, format='PNG')
+        image_string = output.getvalue()
+        output.close()
+        return tf.Summary.Image(height=height,
+                                width=width,
+                                colorspace=channels,
+                                encoded_image_string=image_string)
+
+    def on_epoch_end(self, epoch, logs=None):
+        if logs is None:
+            logs = {}
+        super(TensorBoardImage, self).on_epoch_end(epoch, logs)
+        images = self.validation_data[0]  # 0 - data; 1 - labels
+        img = (255 * images[0].reshape(28, 28)).astype('uint8')
+
+        image = self.make_image(img)
+        summary = tf.Summary(value=[tf.Summary.Value(tag='image', image=image)])
+        self.writer.add_summary(summary, epoch)
+
+
+parser = argparse.ArgumentParser(description='Keras MNIST Example')
+parser.add_argument('--batch-size', type=int, default=128, help='input batch size for training (default: 128)')
+parser.add_argument('--epochs', type=int, default=6, help='number of epochs to train (default: 6)')
+args = parser.parse_args()
+
+# the data, shuffled and split between train and test sets
+nb_classes = 10
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+
+X_train = X_train.reshape(60000, 784).astype('float32')/255.
+X_test = X_test.reshape(10000, 784).astype('float32')/255.
+print(X_train.shape[0], 'train samples')
+print(X_test.shape[0], 'test samples')
+
+# convert class vectors to binary class matrices
+Y_train = np_utils.to_categorical(y_train, nb_classes)
+Y_test = np_utils.to_categorical(y_test, nb_classes)
+
+model = Sequential()
+model.add(Dense(512, input_shape=(784,)))
+model.add(Activation('relu'))
+# model.add(Dropout(0.2))
+model.add(Dense(512))
+model.add(Activation('relu'))
+# model.add(Dropout(0.2))
+model.add(Dense(10))
+model.add(Activation('softmax'))
+
+model2 = Sequential()
+model2.add(Dense(512, input_shape=(784,)))
+model2.add(Activation('relu'))
+
+model.summary()
+
+model.compile(loss='categorical_crossentropy',
+              optimizer=RMSprop(),
+              metrics=['accuracy'])
+
+# Connecting TRAINS
+task = Task.init(project_name='examples', task_name='Keras with TensorBoard example')
+task.connect_configuration({'test': 1337, 'nested': {'key': 'value', 'number': 1}})
+
+# Advanced: setting model class enumeration
+labels = dict(('digit_%d' % i, i) for i in range(10))
+task.set_model_label_enumeration(labels)
+
+output_folder = os.path.join(tempfile.gettempdir(), 'keras_example')
+
+board = TensorBoard(histogram_freq=1, log_dir=output_folder, write_images=False)
+model_store = ModelCheckpoint(filepath=os.path.join(output_folder, 'weight.{epoch}.hdf5'))
+
+# load previous model, if it is there
+# noinspection PyBroadException
+try:
+    model.load_weights(os.path.join(output_folder, 'weight.1.hdf5'))
+except Exception:
+    pass
+
+history = model.fit(X_train, Y_train,
+                    batch_size=args.batch_size, epochs=args.epochs,
+                    callbacks=[board, model_store],
+                    verbose=1, validation_data=(X_test, Y_test))
+score = model.evaluate(X_test, Y_test, verbose=0)
+print('Test score:', score[0])
+print('Test accuracy:', score[1])

examples/frameworks/keras/legacy/requirements.txt

@@ -0,0 +1,2 @@
+trains
+Keras>=2.2.4

examples/frameworks/keras/manual_model_upload.py

@@ -0,0 +1,54 @@
+# TRAINS - Example of manual model configuration and uploading
+#
+import os
+from tempfile import gettempdir
+
+from keras import Input, layers, Model
+
+from trains import Task
+
+
+task = Task.init(project_name='examples', task_name='Model configuration and upload')
+
+
+def get_model():
+    # Create a simple model.
+    inputs = Input(shape=(32,))
+    outputs = layers.Dense(1)(inputs)
+    keras_model = Model(inputs, outputs)
+    keras_model.compile(optimizer='adam', loss='mean_squared_error')
+    return keras_model
+
+
+# create a model
+model = get_model()
+
+# Connect a local configuration file
+config_file = os.path.join('..', '..', 'reporting', 'data_samples', 'sample.json')
+config_file = task.connect_configuration(config_file)
+# then read configuration as usual, the backend will contain a copy of it.
+# later when executing remotely, the returned `config_file` will be a temporary file
+# containing a new copy of the configuration retrieved form the backend
+# # model_config_dict = json.load(open(config_file, 'rt'))
+
+# Or Store dictionary of definition for a specific network design
+model_config_dict = {
+    'value': 13.37,
+    'dict': {'sub_value': 'string', 'sub_integer': 11},
+    'list_of_ints': [1, 2, 3, 4],
+}
+model_config_dict = task.connect_configuration(model_config_dict)
+
+# We now update the dictionary after connecting it, and the changes will be tracked as well.
+model_config_dict['new value'] = 10
+model_config_dict['value'] *= model_config_dict['new value']
+
+# store the label enumeration of the training model
+labels = {'background': 0, 'cat': 1, 'dog': 2}
+task.connect_label_enumeration(labels)
+
+# storing the model, it will have the task network configuration and label enumeration
+print('Any model stored from this point onwards, will contain both model_config and label_enumeration')
+
+model.save(os.path.join(gettempdir(), "model"))
+print('Model saved')

examples/frameworks/keras/requirements.txt

@@ -0,0 +1,3 @@
+Keras
+tensorflow>=2.0
+trains

examples/frameworks/matplotlib/matplotlib_example.py

@@ -0,0 +1,46 @@
+# TRAINS - Example of Matplotlib and Seaborn integration and reporting
+#
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from trains import Task
+
+
+task = Task.init(project_name='examples', task_name='Matplotlib example')
+
+# create plot
+N = 50
+x = np.random.rand(N)
+y = np.random.rand(N)
+colors = np.random.rand(N)
+area = (30 * np.random.rand(N))**2  # 0 to 15 point radii
+plt.scatter(x, y, s=area, c=colors, alpha=0.5)
+plt.show()
+
+# create another plot - with a name
+x = np.linspace(0, 10, 30)
+y = np.sin(x)
+plt.plot(x, y, 'o', color='black')
+plt.show()
+
+# create image plot
+m = np.eye(256, 256, dtype=np.uint8)
+plt.imshow(m)
+plt.show()
+
+# create image plot - with a name
+m = np.eye(256, 256, dtype=np.uint8)
+plt.imshow(m)
+plt.title('Image Title')
+plt.show()
+
+sns.set(style="darkgrid")
+# Load an example dataset with long-form data
+fmri = sns.load_dataset("fmri")
+# Plot the responses for different events and regions
+sns.lineplot(x="timepoint", y="signal",
+             hue="region", style="event",
+             data=fmri)
+plt.show()
+
+print('This is a Matplotlib & Seaborn example')

examples/frameworks/matplotlib/requirements.txt

@@ -0,0 +1,4 @@
+matplotlib >= 3.1.1 ; python_version >= '3.6'
+matplotlib >= 2.2.4 ; python_version < '3.6'
+seaborn
+trains

examples/frameworks/pytorch/manual_model_upload.py

@@ -0,0 +1,43 @@
+# TRAINS - Example of manual model configuration and uploading
+#
+import os
+from tempfile import gettempdir
+
+import torch
+from trains import Task
+
+
+task = Task.init(project_name='examples', task_name='Model configuration and upload')
+
+# create a model
+model = torch.nn.Module
+
+# Connect a local configuration file
+config_file = os.path.join('..', '..', 'reporting', 'data_samples', 'sample.json')
+config_file = task.connect_configuration(config_file)
+# then read configuration as usual, the backend will contain a copy of it.
+# later when executing remotely, the returned `config_file` will be a temporary file
+# containing a new copy of the configuration retrieved form the backend
+# # model_config_dict = json.load(open(config_file, 'rt'))
+
+# Or Store dictionary of definition for a specific network design
+model_config_dict = {
+    'value': 13.37,
+    'dict': {'sub_value': 'string', 'sub_integer': 11},
+    'list_of_ints': [1, 2, 3, 4],
+}
+model_config_dict = task.connect_configuration(model_config_dict)
+
+# We now update the dictionary after connecting it, and the changes will be tracked as well.
+model_config_dict['new value'] = 10
+model_config_dict['value'] *= model_config_dict['new value']
+
+# store the label enumeration of the training model
+labels = {'background': 0, 'cat': 1, 'dog': 2}
+task.connect_label_enumeration(labels)
+
+# storing the model, it will have the task network configuration and label enumeration
+print('Any model stored from this point onwards, will contain both model_config and label_enumeration')
+
+torch.save(model, os.path.join(gettempdir(), "model"))
+print('Model saved')

examples/frameworks/pytorch/notebooks/audio/audio_classifier_UrbanSound8K.ipynb

@@ -0,0 +1,380 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "e-YsQrBjzNdX"
+   },
+   "outputs": [],
+   "source": [
+    "! pip install -U pip\n",
+    "! pip install -U torch==1.5.0\n",
+    "! pip install -U torchaudio==0.5.0\n",
+    "! pip install -U torchvision==0.6.0\n",
+    "! pip install -U matplotlib==3.2.1\n",
+    "! pip install -U trains==0.15.0\n",
+    "! pip install -U pandas==1.0.4\n",
+    "! pip install -U numpy==1.18.4\n",
+    "! pip install -U tensorboard==2.2.1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "T7T0Rf26zNdm"
+   },
+   "outputs": [],
+   "source": [
+    "import PIL\n",
+    "import io\n",
+    "\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from pathlib2 import Path\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "import torch.optim as optim\n",
+    "from torch.utils.data import Dataset\n",
+    "from torch.utils.tensorboard import SummaryWriter\n",
+    "\n",
+    "import torchaudio\n",
+    "from torchvision.transforms import ToTensor\n",
+    "\n",
+    "from trains import Task\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "task = Task.init(project_name='Audio Example', task_name='audio classifier')\n",
+    "configuration_dict = {'number_of_epochs': 10, 'batch_size': 4, 'dropout': 0.25, 'base_lr': 0.001}\n",
+    "configuration_dict = task.connect(configuration_dict)  # enabling configuration override by trains\n",
+    "print(configuration_dict)  # printing actual configuration (after override in remote mode)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "msiz7QdvzNeA",
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# Download UrbanSound8K dataset (https://urbansounddataset.weebly.com/urbansound8k.html)\n",
+    "path_to_UrbanSound8K = './data/UrbanSound8K'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "wXtmZe7yzNeS"
+   },
+   "outputs": [],
+   "source": [
+    "class UrbanSoundDataset(Dataset):\n",
+    "#rapper for the UrbanSound8K dataset\n",
+    "    def __init__(self, csv_path, file_path, folderList):\n",
+    "        self.file_path = file_path\n",
+    "        self.file_names = []\n",
+    "        self.labels = []\n",
+    "        self.folders = []\n",
+    "        \n",
+    "        #loop through the csv entries and only add entries from folders in the folder list\n",
+    "        csvData = pd.read_csv(csv_path)\n",
+    "        for i in range(0,len(csvData)):\n",
+    "            if csvData.iloc[i, 5] in folderList:\n",
+    "                self.file_names.append(csvData.iloc[i, 0])\n",
+    "                self.labels.append(csvData.iloc[i, 6])\n",
+    "                self.folders.append(csvData.iloc[i, 5])\n",
+    "        \n",
+    "    def __getitem__(self, index):\n",
+    "        #format the file path and load the file\n",
+    "        path = self.file_path / (\"fold\" + str(self.folders[index])) / self.file_names[index]\n",
+    "        sound, sample_rate = torchaudio.load(path, out = None, normalization = True)\n",
+    "\n",
+    "        # UrbanSound8K uses two channels, this will convert them to one\n",
+    "        soundData = torch.mean(sound, dim=0, keepdim=True)\n",
+    "        \n",
+    "        #Make sure all files are the same size\n",
+    "        if soundData.numel() < 160000:\n",
+    "            fixedsize_data = torch.nn.functional.pad(soundData, (0, 160000 - soundData.numel()))\n",
+    "        else:\n",
+    "            fixedsize_data = soundData[0,:160000].reshape(1,160000)\n",
+    "        \n",
+    "        #downsample the audio\n",
+    "        downsample_data = fixedsize_data[::5]\n",
+    "        \n",
+    "        melspectogram_transform = torchaudio.transforms.MelSpectrogram(sample_rate=sample_rate)\n",
+    "        melspectogram = melspectogram_transform(downsample_data)\n",
+    "        melspectogram_db = torchaudio.transforms.AmplitudeToDB()(melspectogram)\n",
+    "\n",
+    "        return fixedsize_data, sample_rate, melspectogram_db, self.labels[index]\n",
+    "    \n",
+    "    def __len__(self):\n",
+    "        return len(self.file_names)\n",
+    "\n",
+    "\n",
+    "csv_path = Path(path_to_UrbanSound8K) / 'metadata' / 'UrbanSound8K.csv'\n",
+    "file_path = Path(path_to_UrbanSound8K) / 'audio'\n",
+    "\n",
+    "train_set = UrbanSoundDataset(csv_path, file_path, range(1,10))\n",
+    "test_set = UrbanSoundDataset(csv_path, file_path, [10])\n",
+    "print(\"Train set size: \" + str(len(train_set)))\n",
+    "print(\"Test set size: \" + str(len(test_set)))\n",
+    "\n",
+    "train_loader = torch.utils.data.DataLoader(train_set, batch_size = configuration_dict.get('batch_size', 4), \n",
+    "                                           shuffle = True, pin_memory=True, num_workers=1)\n",
+    "test_loader = torch.utils.data.DataLoader(test_set, batch_size = configuration_dict.get('batch_size', 4), \n",
+    "                                          shuffle = False, pin_memory=True, num_workers=1)\n",
+    "\n",
+    "classes = ('air_conditioner', 'car_horn', 'children_playing', 'dog_bark', 'drilling', 'engine_idling', \n",
+    "           'gun_shot', 'jackhammer', 'siren', 'street_music')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "ylblw-k1zNeZ"
+   },
+   "outputs": [],
+   "source": [
+    "class Net(nn.Module):\n",
+    "    def __init__(self, num_classes, dropout_value):\n",
+    "        super(Net,self).__init__()\n",
+    "        self.num_classes = num_classes\n",
+    "        self.dropout_value = dropout_value\n",
+    "        \n",
+    "        self.C1 = nn.Conv2d(1,16,3)\n",
+    "        self.C2 = nn.Conv2d(16,32,3)\n",
+    "        self.C3 = nn.Conv2d(32,64,3)\n",
+    "        self.C4 = nn.Conv2d(64,128,3)\n",
+    "        self.maxpool1 = nn.MaxPool2d(2,2)        \n",
+    "        self.fc1 = nn.Linear(128*29*197,128)\n",
+    "        self.fc2 = nn.Linear(128,self.num_classes)\n",
+    "        self.dropout = nn.Dropout(self.dropout_value)\n",
+    "    \n",
+    "    def forward(self,x):\n",
+    "        # add sequence of convolutional and max pooling layers\n",
+    "        x = F.relu(self.C1(x))\n",
+    "        x = self.maxpool1(F.relu(self.C2(x)))\n",
+    "        x = F.relu(self.C3(x))\n",
+    "        x = self.maxpool1(F.relu(self.C4(x)))\n",
+    "        # flatten image input\n",
+    "        x = x.view(-1,128*29*197)\n",
+    "        x =  F.relu(self.fc1(self.dropout(x)))\n",
+    "        x = self.fc2(self.dropout(x))\n",
+    "        return x\n",
+    "    \n",
+    "    \n",
+    "model = Net(len(classes), configuration_dict.get('dropout', 0.25))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "3yKYru14zNef"
+   },
+   "outputs": [],
+   "source": [
+    "optimizer = optim.SGD(model.parameters(), lr = configuration_dict.get('base_lr', 0.001), momentum = 0.9)\n",
+    "scheduler = optim.lr_scheduler.StepLR(optimizer, step_size = 3, gamma = 0.1)\n",
+    "criterion = nn.CrossEntropyLoss()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = torch.cuda.current_device() if torch.cuda.is_available() else torch.device('cpu')\n",
+    "print('Device to use: {}'.format(device))\n",
+    "model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tensorboard_writer = SummaryWriter('./tensorboard_logs')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_signal(signal, title, cmap=None):\n",
+    "    fig = plt.figure()\n",
+    "    if signal.ndim == 1:\n",
+    "        plt.plot(signal)\n",
+    "    else:\n",
+    "        plt.imshow(signal, cmap=cmap)    \n",
+    "    plt.title(title)\n",
+    "    \n",
+    "    plot_buf = io.BytesIO()\n",
+    "    plt.savefig(plot_buf, format='jpeg')\n",
+    "    plot_buf.seek(0)\n",
+    "    plt.close(fig)\n",
+    "    return ToTensor()(PIL.Image.open(plot_buf))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "Vdthqz3JzNem"
+   },
+   "outputs": [],
+   "source": [
+    "def train(model, epoch):\n",
+    "    model.train()\n",
+    "    for batch_idx, (sounds, sample_rate, inputs, labels) in enumerate(train_loader):\n",
+    "        inputs = inputs.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "\n",
+    "        # zero the parameter gradients\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "        # forward + backward + optimize\n",
+    "        outputs = model(inputs)\n",
+    "        _, predicted = torch.max(outputs, 1)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        \n",
+    "        iteration = epoch * len(train_loader) + batch_idx\n",
+    "        if batch_idx % log_interval == 0: #print training stats\n",
+    "            print('Train Epoch: {} [{}/{} ({:.0f}%)]\\tLoss: {:.6f}'\n",
+    "                  .format(epoch, batch_idx * len(inputs), len(train_loader.dataset), \n",
+    "                          100. * batch_idx / len(train_loader), loss))\n",
+    "            tensorboard_writer.add_scalar('training loss/loss', loss, iteration)\n",
+    "            tensorboard_writer.add_scalar('learning rate/lr', optimizer.param_groups[0]['lr'], iteration)\n",
+    "                \n",
+    "        \n",
+    "        if batch_idx % debug_interval == 0:    # report debug image every 500 mini-batches\n",
+    "            for n, (inp, pred, label) in enumerate(zip(inputs, predicted, labels)):\n",
+    "                series = 'label_{}_pred_{}'.format(classes[label.cpu()], classes[pred.cpu()])\n",
+    "                tensorboard_writer.add_image('Train MelSpectrogram samples/{}'.format(n), \n",
+    "                                             plot_signal(inp.cpu().numpy().squeeze(), series, 'hot'), iteration)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "LBWoj7u5zNes"
+   },
+   "outputs": [],
+   "source": [
+    "def test(model, epoch):\n",
+    "    model.eval()\n",
+    "    class_correct = list(0. for i in range(10))\n",
+    "    class_total = list(0. for i in range(10))\n",
+    "    with torch.no_grad():\n",
+    "        for idx, (sounds, sample_rate, inputs, labels) in enumerate(test_loader):\n",
+    "            inputs = inputs.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "\n",
+    "            outputs = model(inputs)\n",
+    "\n",
+    "            _, predicted = torch.max(outputs, 1)\n",
+    "            c = (predicted == labels)\n",
+    "            for i in range(len(inputs)):\n",
+    "                label = labels[i].item()\n",
+    "                class_correct[label] += c[i].item()\n",
+    "                class_total[label] += 1\n",
+    "        \n",
+    "            iteration = (epoch + 1) * len(train_loader)\n",
+    "            if idx % debug_interval == 0:    # report debug image every 100 mini-batches\n",
+    "                for n, (sound, inp, pred, label) in enumerate(zip(sounds, inputs, predicted, labels)):\n",
+    "                    series = 'label_{}_pred_{}'.format(classes[label.cpu()], classes[pred.cpu()])\n",
+    "                    tensorboard_writer.add_audio('Test audio samples/{}'.format(n), \n",
+    "                                                 sound, iteration, int(sample_rate[n]))\n",
+    "                    tensorboard_writer.add_image('Test MelSpectrogram samples/{}_{}'.format(idx, n), \n",
+    "                                                 plot_signal(inp.cpu().numpy().squeeze(), series, 'hot'), iteration)\n",
+    "\n",
+    "    total_accuracy = 100 * sum(class_correct)/sum(class_total)\n",
+    "    print('[Iteration {}] Accuracy on the {} test images: {}%\\n'.format(epoch, sum(class_total), total_accuracy))\n",
+    "    tensorboard_writer.add_scalar('accuracy/total', total_accuracy, iteration)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "X5lx3g_5zNey",
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "log_interval = 100\n",
+    "debug_interval = 200\n",
+    "for epoch in range(configuration_dict.get('number_of_epochs', 10)):\n",
+    "    train(model, epoch)\n",
+    "    test(model, epoch)\n",
+    "    scheduler.step()"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "name": "audio_classifier_tutorial.ipynb",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

examples/frameworks/pytorch/notebooks/audio/audio_preprocessing_example.ipynb

@@ -0,0 +1,128 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "! pip install -U pip\n",
+    "! pip install -U torch==1.5.0\n",
+    "! pip install -U torchaudio==0.5.0\n",
+    "! pip install -U matplotlib==3.2.1\n",
+    "! pip install -U trains==0.15.0\n",
+    "! pip install -U tensorboard==2.2.1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import torch\n",
+    "import torchaudio\n",
+    "from torch.utils.tensorboard import SummaryWriter\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from trains import Task\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "task = Task.init(project_name='Audio Example', task_name='data pre-processing')\n",
+    "configuration_dict = {'number_of_smaples': 3}\n",
+    "configuration_dict = task.connect(configuration_dict)  # enabling configuration override by trains\n",
+    "print(configuration_dict)  # printing actual configuration (after override in remote mode)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tensorboard_writer = SummaryWriter('./tensorboard_logs')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "if not os.path.isdir('./data'):\n",
+    "    os.mkdir('./data')\n",
+    "yesno_data = torchaudio.datasets.YESNO('./data', download=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_signal(signal, title, cmap=None):\n",
+    "    plt.figure()\n",
+    "    if signal.ndim == 1:\n",
+    "        plt.plot(signal)\n",
+    "    else:\n",
+    "        plt.imshow(signal, cmap=cmap)    \n",
+    "    plt.title(title)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "for n in range(configuration_dict.get('number_of_smaples', 3)):\n",
+    "    waveform, sample_rate, labels = yesno_data[n]\n",
+    "    melspectogram_transform = torchaudio.transforms.MelSpectrogram(sample_rate=sample_rate)\n",
+    "    plot_signal(waveform[0,:], 'Original waveform')\n",
+    "    tensorboard_writer.add_audio('Audio samples/{}'.format(n), waveform, n, sample_rate)\n",
+    "    plot_signal(melspectogram_transform(waveform.squeeze()).numpy(), 'Mel spectogram', 'hot')\n",
+    "    plot_signal(torchaudio.transforms.AmplitudeToDB()(melspectogram_transform(waveform.squeeze())).numpy(), 'Mel spectogram DB', 'hot')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

examples/frameworks/pytorch/notebooks/image/hyperparameter_search.ipynb

@@ -0,0 +1,136 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# execute this in command line on all machines to be used as workers before initiating the hyperparamer search \n",
+    "# ! pip install -U trains-agent==0.15.0\n",
+    "# ! trains-agent daemon --queue default\n",
+    "\n",
+    "# pip install with locked versions\n",
+    "! pip install -U pandas==1.0.3\n",
+    "! pip install -U trains==0.15.0\n",
+    "! pip install -U hpbandster==0.7.4  # Needed only for Bayesian optimization Hyper-Band"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from trains.automation import UniformParameterRange, UniformIntegerParameterRange\n",
+    "from trains.automation import RandomSearch, HyperParameterOptimizer\n",
+    "from trains.automation.hpbandster import OptimizerBOHB  # Needed only for Bayesian optimization Hyper-Band\n",
+    "\n",
+    "from trains import Task"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "task = Task.init(project_name='Hyper-Parameter Search', task_name='Hyper-Parameter Optimization')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#####################################################################\n",
+    "### Don't forget to replace this default id with your own task id ###\n",
+    "#####################################################################\n",
+    "TEMPLATE_TASK_ID = 'd8e928460f98437c998f3597768597f8'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimizer = HyperParameterOptimizer(\n",
+    "    base_task_id=TEMPLATE_TASK_ID,  # This is the experiment we want to optimize\n",
+    "    # here we define the hyper-parameters to optimize\n",
+    "    hyper_parameters=[\n",
+    "        UniformIntegerParameterRange('number_of_epochs', min_value=5, max_value=15, step_size=1),\n",
+    "        UniformIntegerParameterRange('batch_size', min_value=2, max_value=12, step_size=2),\n",
+    "        UniformParameterRange('dropout', min_value=0, max_value=0.5, step_size=0.05),\n",
+    "        UniformParameterRange('base_lr', min_value=0.0005, max_value=0.01, step_size=0.0005),\n",
+    "    ],\n",
+    "    # this is the objective metric we want to maximize/minimize\n",
+    "    objective_metric_title='accuracy',\n",
+    "    objective_metric_series='total',\n",
+    "    objective_metric_sign='max',  # maximize or minimize the objective metric\n",
+    "    max_number_of_concurrent_tasks=3,  # number of concurrent experiments\n",
+    "    # setting optimizer - trains supports GridSearch, RandomSearch or OptimizerBOHB\n",
+    "    optimizer_class=OptimizerBOHB,  # can be replaced with OptimizerBOHB\n",
+    "    execution_queue='default',  # queue to schedule the experiments for execution\n",
+    "    optimization_time_limit=30.,  # time limit for each experiment (optional, ignored by OptimizerBOHB)\n",
+    "    pool_period_min=1,  # Check the experiments every x minutes\n",
+    "    # set the maximum number of experiments for the optimization.\n",
+    "    # OptimizerBOHB sets the total number of iteration as total_max_jobs * max_iteration_per_job\n",
+    "    total_max_jobs=12,\n",
+    "    # setting OptimizerBOHB configuration (ignored by other optimizers)\n",
+    "    min_iteration_per_job=15000,  # minimum number of iterations per experiment, till early stopping\n",
+    "    max_iteration_per_job=150000,  # maximum number of iterations per experiment\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimizer.set_time_limit(in_minutes=120.0)  # set the time limit for the optimization process\n",
+    "optimizer.start()  \n",
+    "optimizer.wait()  # wait until process is done\n",
+    "optimizer.stop()  # make sure background optimization stopped"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# optimization is completed, print the top performing experiments id\n",
+    "k = 3\n",
+    "top_exp = optimizer.get_top_experiments(top_k=k)\n",
+    "print('Top {} experiments are:'.format(k))\n",
+    "for n, t in enumerate(top_exp, 1):\n",
+    "    print('Rank {}: task id={} |result={}'\n",
+    "          .format(n, t.id, t.get_last_scalar_metrics()['accuracy']['total']['last']))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

examples/frameworks/pytorch/notebooks/image/image_classification_CIFAR10.ipynb

@@ -0,0 +1,243 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# execute this in command line before initiating the notebook: \n",
+    "#    pip install -U pip\n",
+    "#    pip install -U ipywidgets==7.5.1\n",
+    "#    jupyter nbextension enable --py widgetsnbextension\n",
+    "\n",
+    "# pip install with locked versions\n",
+    "! pip install -U torch==1.5.0\n",
+    "! pip install -U torchvision==0.6.0\n",
+    "! pip install -U numpy==1.18.4\n",
+    "! pip install -U trains==0.15.0\n",
+    "! pip install -U tensorboard==2.2.1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "import torch.optim as optim\n",
+    "from torch.utils.tensorboard import SummaryWriter\n",
+    "\n",
+    "import torchvision.datasets as datasets\n",
+    "import torchvision.transforms as transforms\n",
+    "\n",
+    "from trains import Task"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "task = Task.init(project_name='Hyper-Parameter Search', task_name='image_classification_CIFAR10')\n",
+    "configuration_dict = {'number_of_epochs': 3, 'batch_size': 4, 'dropout': 0.25, 'base_lr': 0.001}\n",
+    "configuration_dict = task.connect(configuration_dict)  # enabling configuration override by trains\n",
+    "print(configuration_dict)  # printing actual configuration (after override in remote mode)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "transform = transforms.Compose([transforms.ToTensor()])\n",
+    "\n",
+    "trainset = datasets.CIFAR10(root='./data', train=True,\n",
+    "                                        download=True, transform=transform)\n",
+    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=configuration_dict.get('batch_size', 4),\n",
+    "                                          shuffle=True, num_workers=2)\n",
+    "\n",
+    "testset = datasets.CIFAR10(root='./data', train=False,\n",
+    "                                       download=True, transform=transform)\n",
+    "testloader = torch.utils.data.DataLoader(testset, batch_size=configuration_dict.get('batch_size', 4),\n",
+    "                                         shuffle=False, num_workers=2)\n",
+    "\n",
+    "classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
+    "\n",
+    "device = torch.cuda.current_device() if torch.cuda.is_available() else torch.device('cpu')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Net(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(Net, self).__init__()\n",
+    "        self.conv1 = nn.Conv2d(3, 6, 5)\n",
+    "        self.conv2 = nn.Conv2d(3, 6, 5)\n",
+    "        self.pool = nn.MaxPool2d(2, 2)\n",
+    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
+    "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
+    "        self.fc2 = nn.Linear(120, 84)\n",
+    "        self.dorpout = nn.Dropout(p=configuration_dict.get('dropout', 0.25))\n",
+    "        self.fc3 = nn.Linear(84, 10)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.pool(F.relu(self.conv1(x)))\n",
+    "        x = self.pool(F.relu(self.conv2(x)))\n",
+    "        x = x.view(-1, 16 * 5 * 5)\n",
+    "        x = F.relu(self.fc1(x))\n",
+    "        x = F.relu(self.fc2(x))\n",
+    "        x = self.fc3(self.dorpout(x))\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "net = Net().to(device)\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer = optim.SGD(net.parameters(), lr=configuration_dict.get('base_lr', 0.001), momentum=0.9)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tensorboard_writer = SummaryWriter('./tensorboard_logs')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test_model(test_dataloader, iteration):\n",
+    "    class_correct = list(0. for i in range(10))\n",
+    "    class_total = list(0. for i in range(10))\n",
+    "    with torch.no_grad():\n",
+    "        for j, data in enumerate(test_dataloader, 1):\n",
+    "            images, labels = data\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "            \n",
+    "            outputs = net(images)\n",
+    "            _, predicted = torch.max(outputs, 1)\n",
+    "            c = (predicted == labels).squeeze()\n",
+    "            for i in range(len(images)):\n",
+    "                label = labels[i].item()\n",
+    "                class_correct[label] += c[i].item()\n",
+    "                class_total[label] += 1\n",
+    "            \n",
+    "            if j % 500 == 0:    # report debug image every 500 mini-batches\n",
+    "                for n, (img, pred, label) in enumerate(zip(images, predicted, labels)):\n",
+    "                    tensorboard_writer.add_image(\"testing/{}-{}_GT_{}_pred_{}\"\n",
+    "                                                 .format(j, n, classes[label], classes[pred]), img, iteration)\n",
+    "\n",
+    "    for i in range(len(classes)):\n",
+    "        class_accuracy = 100 * class_correct[i] / class_total[i]\n",
+    "        print('[Iteration {}] Accuracy of {} : {}%'.format(iteration, classes[i], class_accuracy))\n",
+    "        tensorboard_writer.add_scalar('accuracy per class/{}'.format(classes[i]), class_accuracy, iteration)\n",
+    "\n",
+    "    total_accuracy = 100 * sum(class_correct)/sum(class_total)\n",
+    "    print('[Iteration {}] Accuracy on the {} test images: {}%\\n'.format(iteration, sum(class_total), total_accuracy))\n",
+    "    tensorboard_writer.add_scalar('accuracy/total', total_accuracy, iteration)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for epoch in range(configuration_dict.get('number_of_epochs', 3)):  # loop over the dataset multiple times\n",
+    "\n",
+    "    running_loss = 0.0\n",
+    "    for i, data in enumerate(trainloader, 1):\n",
+    "        # get the inputs; data is a list of [inputs, labels]\n",
+    "        inputs, labels = data\n",
+    "        inputs = inputs.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "\n",
+    "        # zero the parameter gradients\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "        # forward + backward + optimize\n",
+    "        outputs = net(inputs)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "\n",
+    "        # print statistics\n",
+    "        running_loss += loss.item()\n",
+    "        \n",
+    "        iteration = epoch * len(trainloader) + i\n",
+    "        if i % 2000 == 0:    # report loss every 2000 mini-batches\n",
+    "            print('[Epoch %d, Iteration %5d] loss: %.3f' %(epoch + 1, i + 1, running_loss / 2000))\n",
+    "            tensorboard_writer.add_scalar('training loss', running_loss / 2000, iteration)\n",
+    "            running_loss = 0.0\n",
+    "    \n",
+    "    test_model(testloader, iteration)\n",
+    "\n",
+    "print('Finished Training')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "PATH = './cifar_net.pth'\n",
+    "torch.save(net.state_dict(), PATH)\n",
+    "tensorboard_writer.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print('Task ID number is: {}'.format(task.id))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

examples/frameworks/pytorch/pytorch_distributed_example.py

@@ -0,0 +1,180 @@
+# TRAINS - example of TRAINS torch distributed support
+# notice all nodes will be reporting to the master Task (experiment)
+
+import os
+import subprocess
+import sys
+from argparse import ArgumentParser
+from math import ceil
+from random import Random
+
+import torch as th
+import torch.nn as nn
+import torch.distributed as dist
+import torch.nn.functional as F
+from torch import optim
+from torchvision import datasets, transforms
+
+from trains import Task
+
+
+local_dataset_path = './MNIST_data'
+
+
+class Net(nn.Module):
+    def __init__(self):
+        super(Net, self).__init__()
+        self.conv1 = nn.Conv2d(1, 32, 3, 1)
+        self.conv2 = nn.Conv2d(32, 64, 3, 1)
+        self.dropout1 = nn.Dropout2d(0.25)
+        self.dropout2 = nn.Dropout2d(0.5)
+        self.fc1 = nn.Linear(9216, 128)
+        self.fc2 = nn.Linear(128, 10)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = F.relu(x)
+        x = self.conv2(x)
+        x = F.max_pool2d(x, 2)
+        x = self.dropout1(x)
+        x = th.flatten(x, 1)
+        x = self.fc1(x)
+        x = F.relu(x)
+        x = self.dropout2(x)
+        x = self.fc2(x)
+        output = F.log_softmax(x, dim=1)
+        return output
+
+
+class Partition(object):
+    """ Dataset partitioning helper """
+    def __init__(self, data, index):
+        self.data = data
+        self.index = index
+
+    def __len__(self):
+        return len(self.index)
+
+    def __getitem__(self, index):
+        data_idx = self.index[index]
+        return self.data[data_idx]
+
+
+class DataPartitioner(object):
+    def __init__(self, data, sizes=(0.7, 0.2, 0.1), seed=1234):
+        self.data = data
+        self.partitions = []
+        rng = Random()
+        rng.seed(seed)
+        data_len = len(data)
+        indexes = [x for x in range(0, data_len)]
+        rng.shuffle(indexes)
+
+        for frac in sizes:
+            part_len = int(frac * data_len)
+            self.partitions.append(indexes[0:part_len])
+            indexes = indexes[part_len:]
+
+    def use(self, partition):
+        return Partition(self.data, self.partitions[partition])
+
+
+def partition_dataset(num_workers=4):
+    """ Partitioning MNIST """
+    dataset = datasets.MNIST(root=local_dataset_path, train=True, download=True,
+                             transform=transforms.Compose([
+                                 transforms.ToTensor(),
+                                 transforms.Normalize((0.1307,), (0.3081,))
+                             ]))
+    size = dist.get_world_size()
+    bsz = int(128 / float(size))
+    partition_sizes = [1.0 / size for _ in range(size)]
+    partition = DataPartitioner(dataset, partition_sizes)
+    partition = partition.use(dist.get_rank())
+    train_set = th.utils.data.DataLoader(
+        partition, num_workers=num_workers, batch_size=bsz, shuffle=True)
+    return train_set, bsz
+
+
+def run(num_workers):
+    """ Distributed Synchronous SGD Example """
+    th.manual_seed(1234)
+    train_set, bsz = partition_dataset(num_workers)
+    model = Net()
+    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
+
+    num_batches = ceil(len(train_set.dataset) / float(bsz))
+
+    from random import randint
+    param = {'worker_{}_stuff'.format(dist.get_rank()): 'some stuff ' + str(randint(0, 100))}
+    Task.current_task().connect(param)
+    Task.current_task().upload_artifact(
+        'temp {:02d}'.format(dist.get_rank()), artifact_object={'worker_rank': dist.get_rank()})
+
+    for epoch in range(2):
+        epoch_loss = 0.0
+        for i, (data, target) in enumerate(train_set):
+            optimizer.zero_grad()
+            output = model(data)
+            loss = F.nll_loss(output, target)
+            epoch_loss += loss.item()
+            loss.backward()
+            average_gradients(model)
+            optimizer.step()
+            if i % 10 == 0:
+                print('{}] Train Epoch {} - {} \tLoss  {:.6f}'.format(dist.get_rank(), epoch, i, loss))
+                Task.current_task().get_logger().report_scalar(
+                    'loss', 'worker {:02d}'.format(dist.get_rank()), value=loss.item(), iteration=i)
+            if i > 100:
+                break
+        print('Rank ', dist.get_rank(), ', epoch ',
+              epoch, ': ', epoch_loss / num_batches)
+
+
+def average_gradients(model):
+    """ Gradient averaging. """
+    size = float(dist.get_world_size())
+    for param in model.parameters():
+        dist.all_reduce(param.grad.data, op=dist.reduce_op.SUM)
+        param.grad.data /= size
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument('--nodes', help='number of nodes', type=int, default=10)
+    parser.add_argument('--workers_in_node', help='number of workers per node', type=int, default=3)
+    # this argument we will not be logging, see below Task.init
+    parser.add_argument('--rank', help='current rank', type=int)
+
+    args = parser.parse_args()
+
+    # We have to initialize the task in the master process,
+    # it will make sure that any sub-process calling Task.init will get the master task object
+    # notice that we exclude the `rank` argument, so we can launch multiple sub-processes with trains-agent
+    # otherwise, the `rank` will always be set to the original value.
+    task = Task.init("examples", "test torch distributed", auto_connect_arg_parser={'rank': False})
+
+    if os.environ.get('MASTER_ADDR'):
+        dist.init_process_group(backend='gloo', rank=args.rank, world_size=args.nodes)
+        run(args.workers_in_node)
+    else:
+        # first let's download the dataset, if we have multiple machines,
+        # they will take care of it when they get there
+        datasets.MNIST(root=local_dataset_path, train=True, download=True)
+
+        os.environ['MASTER_ADDR'] = '127.0.0.1'
+        os.environ['MASTER_PORT'] = '29500'
+
+        print(os.getpid(), 'ARGS:', args)
+        processes = []
+        for rank in range(args.nodes):
+            cmd = [sys.executable, sys.argv[0],
+                   '--nodes', str(args.nodes),
+                   '--workers_in_node', str(args.workers_in_node),
+                   '--rank', str(rank)]
+            print(cmd)
+            p = subprocess.Popen(cmd, cwd=os.getcwd(), pass_fds=[], close_fds=True)
+            processes.append(p)
+
+        for p in processes:
+            p.wait()

examples/frameworks/pytorch/pytorch_matplotlib.py

@@ -0,0 +1,482 @@
+# TRAINS - Example of Pytorch and matplotlib integration and reporting
+#
+"""
+Neural Transfer Using PyTorch
+=============================
+**Author**: `Alexis Jacq <https://alexis-jacq.github.io>`_
+
+**Edited by**: `Winston Herring <https://github.com/winston6>`_
+Introduction
+------------
+This tutorial explains how to implement the `Neural-Style algorithm <https://arxiv.org/abs/1508.06576>`__
+developed by Leon A. Gatys, Alexander S. Ecker and Matthias Bethge.
+Neural-Style, or Neural-Transfer, allows you to take an image and
+reproduce it with a new artistic style. The algorithm takes three images,
+an input image, a content-image, and a style-image, and changes the input
+to resemble the content of the content-image and the artistic style of the style-image.
+
+.. figure:: /_static/img/neural-style/neuralstyle.png
+   :alt: content1
+"""
+
+######################################################################
+# Underlying Principle
+# --------------------
+#
+# The principle is simple: we define two distances, one for the content
+# (:math:`D_C`) and one for the style (:math:`D_S`). :math:`D_C` measures how different the content
+# is between two images while :math:`D_S` measures how different the style is
+# between two images. Then, we take a third image, the input, and
+# transform it to minimize both its content-distance with the
+# content-image and its style-distance with the style-image. Now we can
+# import the necessary packages and begin the neural transfer.
+#
+# Importing Packages and Selecting a Device
+# -----------------------------------------
+# Below is a  list of the packages needed to implement the neural transfer.
+#
+# -  ``torch``, ``torch.nn``, ``numpy`` (indispensables packages for
+#    neural networks with PyTorch)
+# -  ``torch.optim`` (efficient gradient descents)
+# -  ``PIL``, ``PIL.Image``, ``matplotlib.pyplot`` (load and display
+#    images)
+# -  ``torchvision.transforms`` (transform PIL images into tensors)
+# -  ``torchvision.models`` (train or load pre-trained models)
+# -  ``copy`` (to deep copy the models; system package)
+
+from __future__ import print_function
+
+import os
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+
+from PIL import Image
+import matplotlib.pyplot as plt
+
+import torchvision.transforms as transforms
+import torchvision.models as models
+
+import copy
+from trains import Task
+
+
+task = Task.init(project_name='examples', task_name='pytorch with matplotlib example', task_type=Task.TaskTypes.testing)
+
+
+######################################################################
+# Next, we need to choose which device to run the network on and import the
+# content and style images. Running the neural transfer algorithm on large
+# images takes longer and will go much faster when running on a GPU. We can
+# use ``torch.cuda.is_available()`` to detect if there is a GPU available.
+# Next, we set the ``torch.device`` for use throughout the tutorial. Also the ``.to(device)``
+# method is used to move tensors or modules to a desired device.
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+######################################################################
+# Loading the Images
+# ------------------
+#
+# Now we will import the style and content images. The original PIL images have values between 0 and 255, but when
+# transformed into torch tensors, their values are converted to be between
+# 0 and 1. The images also need to be resized to have the same dimensions.
+# An important detail to note is that neural networks from the
+# torch library are trained with tensor values ranging from 0 to 1. If you
+# try to feed the networks with 0 to 255 tensor images, then the activated
+# feature maps will be unable sense the intended content and style.
+# However, pre-trained networks from the Caffe library are trained with 0
+# to 255 tensor images.
+#
+#
+# .. Note::
+#     Here are links to download the images required to run the tutorial:
+#     `picasso.jpg <https://pytorch.org/tutorials/_static/img/neural-style/picasso.jpg>`__ and
+#     `dancing.jpg <https://pytorch.org/tutorials/_static/img/neural-style/dancing.jpg>`__.
+#     Download these two images and add them to a directory
+#     with name ``images`` in your current working directory.
+
+# desired size of the output image
+imsize = 512 if torch.cuda.is_available() else 128  # use small size if no gpu
+
+loader = transforms.Compose([
+    transforms.Resize(imsize),  # scale imported image
+    transforms.ToTensor()])  # transform it into a torch tensor
+
+
+def image_loader(image_name):
+    image = Image.open(image_name)
+    # fake batch dimension required to fit network's input dimensions
+    image = loader(image).unsqueeze(0)
+    return image.to(device, torch.float)
+
+
+style_img = image_loader(os.path.join("..", "..", "reporting", "data_samples", "picasso.jpg"))
+content_img = image_loader(os.path.join("..", "..", "reporting", "data_samples", "dancing.jpg"))
+
+assert style_img.size() == content_img.size(), \
+    "we need to import style and content images of the same size"
+
+######################################################################
+# Now, let's create a function that displays an image by reconverting a
+# copy of it to PIL format and displaying the copy using
+# ``plt.imshow``. We will try displaying the content and style images
+# to ensure they were imported correctly.
+
+unloader = transforms.ToPILImage()  # reconvert into PIL image
+
+plt.ion()
+
+
+def imshow(tensor, title=None):
+    image = tensor.cpu().clone()  # we clone the tensor to not do changes on it
+    image = image.squeeze(0)  # remove the fake batch dimension
+    image = unloader(image)
+    plt.imshow(image)
+    if title is not None:
+        plt.title(title)
+    plt.pause(0.001)  # pause a bit so that plots are updated
+
+
+plt.figure()
+imshow(style_img, title='Style Image')
+
+plt.figure()
+imshow(content_img, title='Content Image')
+
+
+######################################################################
+# Loss Functions
+# --------------
+# Content Loss
+# ~~~~~~~~~~~~
+#
+# The content loss is a function that represents a weighted version of the
+# content distance for an individual layer. The function takes the feature
+# maps :math:`F_{XL}` of a layer :math:`L` in a network processing input :math:`X` and returns the
+# weighted content distance :math:`w_{CL}.D_C^L(X,C)` between the image :math:`X` and the
+# content image :math:`C`. The feature maps of the content image(:math:`F_{CL}`) must be
+# known by the function in order to calculate the content distance. We
+# implement this function as a torch module with a constructor that takes
+# :math:`F_{CL}` as an input. The distance :math:`\|F_{XL} - F_{CL}\|^2` is the mean square error
+# between the two sets of feature maps, and can be computed using ``nn.MSELoss``.
+#
+# We will add this content loss module directly after the convolution
+# layer(s) that are being used to compute the content distance. This way
+# each time the network is fed an input image the content losses will be
+# computed at the desired layers and because of auto grad, all the
+# gradients will be computed. Now, in order to make the content loss layer
+# transparent we must define a ``forward`` method that computes the content
+# loss and then returns the layer's input. The computed loss is saved as a
+# parameter of the module.
+#
+
+class ContentLoss(nn.Module):
+
+    def __init__(self, target, ):
+        super(ContentLoss, self).__init__()
+        # we 'detach' the target content from the tree used
+        # to dynamically compute the gradient: this is a stated value,
+        # not a variable. Otherwise the forward method of the criterion
+        # will throw an error.
+        self.target = target.detach()
+
+    def forward(self, input):
+        self.loss = F.mse_loss(input, self.target)
+        return input
+
+
+######################################################################
+# .. Note::
+#    **Important detail**: although this module is named ``ContentLoss``, it
+#    is not a true PyTorch Loss function. If you want to define your content
+#    loss as a PyTorch Loss function, you have to create a PyTorch autograd function
+#    to recompute/implement the gradient manually in the ``backward``
+#    method.
+
+######################################################################
+# Style Loss
+# ~~~~~~~~~~
+#
+# The style loss module is implemented similarly to the content loss
+# module. It will act as a transparent layer in a
+# network that computes the style loss of that layer. In order to
+# calculate the style loss, we need to compute the gram matrix :math:`G_{XL}`. A gram
+# matrix is the result of multiplying a given matrix by its transposed
+# matrix. In this application the given matrix is a reshaped version of
+# the feature maps :math:`F_{XL}` of a layer :math:`L`. :math:`F_{XL}` is reshaped to form :math:`\hat{F}_{XL}`, a :math:`K`\ x\ :math:`N`
+# matrix, where :math:`K` is the number of feature maps at layer :math:`L` and :math:`N` is the
+# length of any vectorized feature map :math:`F_{XL}^k`. For example, the first line
+# of :math:`\hat{F}_{XL}` corresponds to the first vectorized feature map :math:`F_{XL}^1`.
+#
+# Finally, the gram matrix must be normalized by dividing each element by
+# the total number of elements in the matrix. This normalization is to
+# counteract the fact that :math:`\hat{F}_{XL}` matrices with a large :math:`N` dimension yield
+# larger values in the Gram matrix. These larger values will cause the
+# first layers (before pooling layers) to have a larger impact during the
+# gradient descent. Style features tend to be in the deeper layers of the
+# network so this normalization step is crucial.
+#
+
+def gram_matrix(input):
+    a, b, c, d = input.size()  # a=batch size(=1)
+    # b=number of feature maps
+    # (c,d)=dimensions of a f. map (N=c*d)
+
+    features = input.view(a * b, c * d)  # resise F_XL into \hat F_XL
+
+    G = torch.mm(features, features.t())  # compute the gram product
+
+    # we 'normalize' the values of the gram matrix
+    # by dividing by the number of element in each feature maps.
+    return G.div(a * b * c * d)
+
+
+######################################################################
+# Now the style loss module looks almost exactly like the content loss
+# module. The style distance is also computed using the mean square
+# error between :math:`G_{XL}` and :math:`G_{SL}`.
+#
+
+class StyleLoss(nn.Module):
+
+    def __init__(self, target_feature):
+        super(StyleLoss, self).__init__()
+        self.target = gram_matrix(target_feature).detach()
+
+    def forward(self, input):
+        G = gram_matrix(input)
+        self.loss = F.mse_loss(G, self.target)
+        return input
+
+
+######################################################################
+# Importing the Model
+# -------------------
+#
+# Now we need to import a pre-trained neural network. We will use a 19
+# layer VGG network like the one used in the paper.
+#
+# PyTorch's implementation of VGG is a module divided into two child
+# ``Sequential`` modules: ``features`` (containing convolution and pooling layers),
+# and ``classifier`` (containing fully connected layers). We will use the
+# ``features`` module because we need the output of the individual
+# convolution layers to measure content and style loss. Some layers have
+# different behavior during training than evaluation, so we must set the
+# network to evaluation mode using ``.eval()``.
+#
+
+cnn = models.vgg19(pretrained=True).features.to(device).eval()
+
+######################################################################
+# Additionally, VGG networks are trained on images with each channel
+# normalized by mean=[0.485, 0.456, 0.406] and std=[0.229, 0.224, 0.225].
+# We will use them to normalize the image before sending it into the network.
+#
+
+cnn_normalization_mean = torch.tensor([0.485, 0.456, 0.406]).to(device)
+cnn_normalization_std = torch.tensor([0.229, 0.224, 0.225]).to(device)
+
+
+# create a module to normalize input image so we can easily put it in a
+# nn.Sequential
+class Normalization(nn.Module):
+    def __init__(self, mean, std):
+        super(Normalization, self).__init__()
+        # .view the mean and std to make them [C x 1 x 1] so that they can
+        # directly work with image Tensor of shape [B x C x H x W].
+        # B is batch size. C is number of channels. H is height and W is width.
+        self.mean = torch.tensor(mean).view(-1, 1, 1)
+        self.std = torch.tensor(std).view(-1, 1, 1)
+
+    def forward(self, img):
+        # normalize img
+        return (img - self.mean) / self.std
+
+
+######################################################################
+# A ``Sequential`` module contains an ordered list of child modules. For
+# instance, ``vgg19.features`` contains a sequence (Conv2d, ReLU, MaxPool2d,
+# Conv2d, ReLU...) aligned in the right order of depth. We need to add our
+# content loss and style loss layers immediately after the convolution
+# layer they are detecting. To do this we must create a new ``Sequential``
+# module that has content loss and style loss modules correctly inserted.
+#
+
+# desired depth layers to compute style/content losses :
+content_layers_default = ['conv_4']
+style_layers_default = ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5']
+
+
+def get_style_model_and_losses(cnn, normalization_mean, normalization_std,
+                               style_img, content_img,
+                               content_layers=content_layers_default,
+                               style_layers=style_layers_default):
+    cnn = copy.deepcopy(cnn)
+
+    # normalization module
+    normalization = Normalization(normalization_mean, normalization_std).to(device)
+
+    # just in order to have an iterable access to or list of content/syle
+    # losses
+    content_losses = []
+    style_losses = []
+
+    # assuming that cnn is a nn.Sequential, so we make a new nn.Sequential
+    # to put in modules that are supposed to be activated sequentially
+    model = nn.Sequential(normalization)
+
+    i = 0  # increment every time we see a conv
+    for layer in cnn.children():
+        if isinstance(layer, nn.Conv2d):
+            i += 1
+            name = 'conv_{}'.format(i)
+        elif isinstance(layer, nn.ReLU):
+            name = 'relu_{}'.format(i)
+            # The in-place version doesn't play very nicely with the ContentLoss
+            # and StyleLoss we insert below. So we replace with out-of-place
+            # ones here.
+            layer = nn.ReLU(inplace=False)
+        elif isinstance(layer, nn.MaxPool2d):
+            name = 'pool_{}'.format(i)
+        elif isinstance(layer, nn.BatchNorm2d):
+            name = 'bn_{}'.format(i)
+        else:
+            raise RuntimeError('Unrecognized layer: {}'.format(layer.__class__.__name__))
+
+        model.add_module(name, layer)
+
+        if name in content_layers:
+            # add content loss:
+            target = model(content_img).detach()
+            content_loss = ContentLoss(target)
+            model.add_module("content_loss_{}".format(i), content_loss)
+            content_losses.append(content_loss)
+
+        if name in style_layers:
+            # add style loss:
+            target_feature = model(style_img).detach()
+            style_loss = StyleLoss(target_feature)
+            model.add_module("style_loss_{}".format(i), style_loss)
+            style_losses.append(style_loss)
+
+    # now we trim off the layers after the last content and style losses
+    for i in range(len(model) - 1, -1, -1):
+        if isinstance(model[i], ContentLoss) or isinstance(model[i], StyleLoss):
+            break
+
+    model = model[:(i + 1)]
+
+    return model, style_losses, content_losses
+
+
+######################################################################
+# Next, we select the input image. You can use a copy of the content image
+# or white noise.
+#
+
+input_img = content_img.clone()
+# if you want to use white noise instead uncomment the below line:
+# input_img = torch.randn(content_img.data.size(), device=device)
+
+# add the original input image to the figure:
+plt.figure()
+imshow(input_img, title='Input Image')
+
+
+######################################################################
+# Gradient Descent
+# ----------------
+#
+# As Leon Gatys, the author of the algorithm, suggested `here <https://discuss.pytorch.org/t/pytorch-tutorial-for-neural-transfert-of-artistic-style/336/20?u=alexis-jacq>`__, we will use
+# L-BFGS algorithm to run our gradient descent. Unlike training a network,
+# we want to train the input image in order to minimise the content/style
+# losses. We will create a PyTorch L-BFGS optimizer ``optim.LBFGS`` and pass
+# our image to it as the tensor to optimize.
+#
+
+def get_input_optimizer(input_img):
+    # this line to show that input is a parameter that requires a gradient
+    optimizer = optim.LBFGS([input_img.requires_grad_()])
+    return optimizer
+
+
+######################################################################
+# Finally, we must define a function that performs the neural transfer. For
+# each iteration of the networks, it is fed an updated input and computes
+# new losses. We will run the ``backward`` methods of each loss module to
+# dynamicaly compute their gradients. The optimizer requires a "closure"
+# function, which reevaluates the modul and returns the loss.
+#
+# We still have one final constraint to address. The network may try to
+# optimize the input with values that exceed the 0 to 1 tensor range for
+# the image. We can address this by correcting the input values to be
+# between 0 to 1 each time the network is run.
+#
+
+def run_style_transfer(cnn, normalization_mean, normalization_std,
+                       content_img, style_img, input_img, num_steps=300,
+                       style_weight=1000000, content_weight=1):
+    """Run the style transfer."""
+    print('Building the style transfer model..')
+    model, style_losses, content_losses = get_style_model_and_losses(cnn,
+                                                                     normalization_mean, normalization_std, style_img,
+                                                                     content_img)
+    optimizer = get_input_optimizer(input_img)
+
+    print('Optimizing..')
+    run = [0]
+    while run[0] <= num_steps:
+
+        def closure():
+            # correct the values of updated input image
+            input_img.data.clamp_(0, 1)
+
+            optimizer.zero_grad()
+            model(input_img)
+            style_score = 0
+            content_score = 0
+
+            for sl in style_losses:
+                style_score += sl.loss
+            for cl in content_losses:
+                content_score += cl.loss
+
+            style_score *= style_weight
+            content_score *= content_weight
+
+            loss = style_score + content_score
+            loss.backward()
+
+            run[0] += 1
+            if run[0] % 50 == 0:
+                print("run {}:".format(run))
+                print('Style Loss : {:4f} Content Loss: {:4f}'.format(
+                    style_score.item(), content_score.item()))
+                print()
+
+            return style_score + content_score
+
+        optimizer.step(closure)
+
+    # a last correction...
+    input_img.data.clamp_(0, 1)
+
+    return input_img
+
+
+######################################################################
+# Finally, we can run the algorithm.
+#
+
+output = run_style_transfer(cnn, cnn_normalization_mean, cnn_normalization_std,
+                            content_img, style_img, input_img)
+
+plt.figure()
+imshow(output, title='Output Image')
+
+# sphinx_gallery_thumbnail_number = 4
+plt.ioff()
+plt.show()

examples/frameworks/pytorch/pytorch_mnist.py

@@ -0,0 +1,134 @@
+# TRAINS - Example of Pytorch mnist training integration
+#
+from __future__ import print_function
+import argparse
+import os
+from tempfile import gettempdir
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torchvision import datasets, transforms
+
+from trains import Task, Logger
+
+
+class Net(nn.Module):
+    def __init__(self):
+        super(Net, self).__init__()
+        self.conv1 = nn.Conv2d(1, 20, 5, 1)
+        self.conv2 = nn.Conv2d(20, 50, 5, 1)
+        self.fc1 = nn.Linear(4 * 4 * 50, 500)
+        self.fc2 = nn.Linear(500, 10)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.max_pool2d(x, 2, 2)
+        x = F.relu(self.conv2(x))
+        x = F.max_pool2d(x, 2, 2)
+        x = x.view(-1, 4 * 4 * 50)
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+        return F.log_softmax(x, dim=1)
+
+
+def train(args, model, device, train_loader, optimizer, epoch):
+    model.train()
+    for batch_idx, (data, target) in enumerate(train_loader):
+        data, target = data.to(device), target.to(device)
+        optimizer.zero_grad()
+        output = model(data)
+        loss = F.nll_loss(output, target)
+        loss.backward()
+        optimizer.step()
+        if batch_idx % args.log_interval == 0:
+            Logger.current_logger().report_scalar(
+                "train", "loss", iteration=(epoch * len(train_loader) + batch_idx), value=loss.item())
+            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
+                epoch, batch_idx * len(data), len(train_loader.dataset),
+                100. * batch_idx / len(train_loader), loss.item()))
+
+
+def test(args, model, device, test_loader, epoch):
+    model.eval()
+    test_loss = 0
+    correct = 0
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = data.to(device), target.to(device)
+            output = model(data)
+            test_loss += F.nll_loss(output, target, reduction='sum').item()  # sum up batch loss
+            pred = output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability
+            correct += pred.eq(target.view_as(pred)).sum().item()
+
+    test_loss /= len(test_loader.dataset)
+
+    Logger.current_logger().report_scalar(
+        "test", "loss", iteration=epoch, value=test_loss)
+    Logger.current_logger().report_scalar(
+        "test", "accuracy", iteration=epoch, value=(correct / len(test_loader.dataset)))
+    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
+        test_loss, correct, len(test_loader.dataset),
+        100. * correct / len(test_loader.dataset)))
+
+
+def main():
+    task = Task.init(project_name='examples', task_name='pytorch mnist train')
+
+    # Training settings
+    parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
+    parser.add_argument('--batch-size', type=int, default=64, metavar='N',
+                        help='input batch size for training (default: 64)')
+    parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
+                        help='input batch size for testing (default: 1000)')
+    parser.add_argument('--epochs', type=int, default=10, metavar='N',
+                        help='number of epochs to train (default: 10)')
+    parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
+                        help='learning rate (default: 0.01)')
+    parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
+                        help='SGD momentum (default: 0.5)')
+    parser.add_argument('--no-cuda', action='store_true', default=False,
+                        help='disables CUDA training')
+    parser.add_argument('--seed', type=int, default=1, metavar='S',
+                        help='random seed (default: 1)')
+    parser.add_argument('--log-interval', type=int, default=10, metavar='N',
+                        help='how many batches to wait before logging training status')
+
+    parser.add_argument('--save-model', action='store_true', default=True,
+                        help='For Saving the current Model')
+    args = parser.parse_args()
+    use_cuda = not args.no_cuda and torch.cuda.is_available()
+
+    torch.manual_seed(args.seed)
+
+    device = torch.device("cuda" if use_cuda else "cpu")
+
+    kwargs = {'num_workers': 4, 'pin_memory': True} if use_cuda else {}
+    train_loader = torch.utils.data.DataLoader(
+        datasets.MNIST(os.path.join('..', 'data'), train=True, download=True,
+                       transform=transforms.Compose([
+                           transforms.ToTensor(),
+                           transforms.Normalize((0.1307,), (0.3081,))
+                       ])),
+        batch_size=args.batch_size, shuffle=True, **kwargs)
+    test_loader = torch.utils.data.DataLoader(
+        datasets.MNIST(os.path.join('..', 'data'), train=False, transform=transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize((0.1307,), (0.3081,))
+        ])),
+        batch_size=args.test_batch_size, shuffle=True, **kwargs)
+
+    model = Net().to(device)
+    optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)
+
+    for epoch in range(1, args.epochs + 1):
+        train(args, model, device, train_loader, optimizer, epoch)
+        test(args, model, device, test_loader, epoch)
+
+    if (args.save_model):
+        torch.save(model.state_dict(), os.path.join(gettempdir(), "mnist_cnn.pt"))
+
+
+if __name__ == '__main__':
+    main()

examples/frameworks/pytorch/pytorch_tensorboard.py

@@ -0,0 +1,136 @@
+# TRAINS - Example of pytorch with tensorboard>=v1.14
+#
+from __future__ import print_function
+
+import argparse
+import os
+from tempfile import gettempdir
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torchvision import datasets, transforms
+from torch.autograd import Variable
+from torch.utils.tensorboard import SummaryWriter
+
+from trains import Task
+
+
+class Net(nn.Module):
+
+    def __init__(self):
+        super(Net, self).__init__()
+        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
+        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
+        self.conv2_drop = nn.Dropout2d()
+        self.fc1 = nn.Linear(320, 50)
+        self.fc2 = nn.Linear(50, 10)
+
+    def forward(self, x):
+        x = F.relu(F.max_pool2d(self.conv1(x), 2))
+        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
+        x = x.view(-1, 320)
+        x = F.relu(self.fc1(x))
+        x = F.dropout(x, training=self.training)
+        x = self.fc2(x)
+        return F.log_softmax(x, dim=1)
+
+
+def train(model, epoch, train_loader, args, optimizer, writer):
+    model.train()
+    for batch_idx, (data, target) in enumerate(train_loader):
+        if args.cuda:
+            data, target = data.cuda(), target.cuda()
+        data, target = Variable(data), Variable(target)
+        optimizer.zero_grad()
+        output = model(data)
+        loss = F.nll_loss(output, target)
+        loss.backward()
+        optimizer.step()
+        if batch_idx % args.log_interval == 0:
+            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
+                epoch, batch_idx * len(data), len(train_loader.dataset),
+                100. * batch_idx / len(train_loader), loss.data.item()))
+            niter = epoch*len(train_loader)+batch_idx
+            writer.add_scalar('Train/Loss', loss.data.item(), niter)
+
+
+def test(model, test_loader, args, optimizer, writer):
+    model.eval()
+    test_loss = 0
+    correct = 0
+    for niter, (data, target) in enumerate(test_loader):
+        if args.cuda:
+            data, target = data.cuda(), target.cuda()
+        data, target = Variable(data), Variable(target)
+        output = model(data)
+        test_loss += F.nll_loss(output, target, reduction='sum').data.item()  # sum up batch loss
+        pred = output.data.max(1)[1]  # get the index of the max log-probability
+        pred = pred.eq(target.data).cpu().sum()
+        writer.add_scalar('Test/Loss', pred, niter)
+        correct += pred
+        if niter % 100 == 0:
+            writer.add_image('test', data[0, :, :, :], niter)
+
+    test_loss /= len(test_loader.dataset)
+    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
+        test_loss, correct, len(test_loader.dataset),
+        100. * correct / len(test_loader.dataset)))
+
+
+def main():
+    # Training settings
+    parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
+    parser.add_argument('--batch-size', type=int, default=64, metavar='N',
+                        help='input batch size for training (default: 64)')
+    parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
+                        help='input batch size for testing (default: 1000)')
+    parser.add_argument('--epochs', type=int, default=10, metavar='N',
+                        help='number of epochs to train (default: 10)')
+    parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
+                        help='learning rate (default: 0.01)')
+    parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
+                        help='SGD momentum (default: 0.5)')
+    parser.add_argument('--no-cuda', action='store_true', default=False,
+                        help='disables CUDA training')
+    parser.add_argument('--seed', type=int, default=1, metavar='S',
+                        help='random seed (default: 1)')
+    parser.add_argument('--log-interval', type=int, default=10, metavar='N',
+                        help='how many batches to wait before logging training status')
+    args = parser.parse_args()
+    task = Task.init(project_name='examples', task_name='pytorch with tensorboard')  # noqa: F841
+    writer = SummaryWriter('runs')
+    writer.add_text('TEXT', 'This is some text', 0)
+    args.cuda = not args.no_cuda and torch.cuda.is_available()
+
+    torch.manual_seed(args.seed)
+    if args.cuda:
+        torch.cuda.manual_seed(args.seed)
+
+    kwargs = {'num_workers': 4, 'pin_memory': True} if args.cuda else {}
+    train_loader = torch.utils.data.DataLoader(datasets.MNIST('../data', train=True, download=True,
+                                                              transform=transforms.Compose([
+                                                                  transforms.ToTensor(),
+                                                                  transforms.Normalize((0.1307,), (0.3081,))])),
+                                               batch_size=args.batch_size, shuffle=True, **kwargs)
+    test_loader = torch.utils.data.DataLoader(datasets.MNIST('../data', train=False,
+                                                             transform=transforms.Compose([
+                                                                 transforms.ToTensor(),
+                                                                 transforms.Normalize((0.1307,), (0.3081,))])),
+                                              batch_size=args.batch_size, shuffle=True, **kwargs)
+
+    model = Net()
+    if args.cuda:
+        model.cuda()
+    optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)
+
+    for epoch in range(1, args.epochs + 1):
+        train(model, epoch, train_loader, args, optimizer, writer)
+        torch.save(model, os.path.join(gettempdir(), 'model{}'.format(epoch)))
+    test(model, test_loader, args, optimizer, writer)
+
+
+if __name__ == "__main__":
+    # Hack for supporting Windows OS - https://pytorch.org/docs/stable/notes/windows.html#usage-multiprocessing
+    main()

examples/frameworks/pytorch/pytorch_tensorboardx.py

@@ -0,0 +1 @@
+../tensorboardx/pytorch_tensorboardX.py

examples/frameworks/pytorch/requirements.txt

@@ -0,0 +1,6 @@
+matplotlib
+# tensorboardX
+tensorboard>=1.14.0
+torch>=1.1.0
+torchvision>=0.3.0
+trains

examples/frameworks/pytorch/tensorboard_toy_pytorch.py

@@ -0,0 +1,29 @@
+import os
+from tempfile import gettempdir
+
+import numpy as np
+from PIL import Image
+from torch.utils.tensorboard import SummaryWriter
+
+from trains import Task
+task = Task.init(project_name='examples', task_name='pytorch tensorboard toy example')
+
+
+writer = SummaryWriter(log_dir=os.path.join(gettempdir(), 'tensorboard_logs'))
+
+# convert to 4d [batch, col, row, RGB-channels]
+image_open = Image.open(os.path.join("..", "..", "reporting", "data_samples", "picasso.jpg"))
+image = np.asarray(image_open)
+image_gray = image[:, :, 0][np.newaxis, :, :, np.newaxis]
+image_rgba = np.concatenate((image, 255*np.atleast_3d(np.ones(shape=image.shape[:2], dtype=np.uint8))), axis=2)
+image_rgba = image_rgba[np.newaxis, :, :, :]
+image = image[np.newaxis, :, :, :]
+
+writer.add_image("test/first", image[0], dataformats='HWC')
+writer.add_image("test_gray/second", image_gray[0], dataformats='HWC')
+writer.add_image("test_rgba/third", image_rgba[0], dataformats='HWC')
+# writer.add_image("image/first_series", image, max_outputs=10)
+# writer.add_image("image_gray/second_series", image_gray, max_outputs=10)
+# writer.add_image("image_rgba/third_series", image_rgba, max_outputs=10)
+
+print('Done!')

examples/frameworks/scikit-learn/joblib_example.py

@@ -0,0 +1,45 @@
+try:
+    import joblib
+except ImportError:
+    from sklearn.externals import joblib
+
+from sklearn import datasets
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import train_test_split
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+from trains import Task
+
+task = Task.init(project_name="examples", task_name="joblib test")
+
+iris = datasets.load_iris()
+X = iris.data
+y = iris.target
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+model = LogisticRegression(solver='liblinear', multi_class='auto')  # sklearn LogisticRegression class
+model.fit(X_train, y_train)
+
+joblib.dump(model, 'model.pkl', compress=True)
+
+loaded_model = joblib.load('model.pkl')
+result = loaded_model.score(X_test, y_test)
+x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
+y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
+h = .02  # step size in the mesh
+xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
+plt.figure(1, figsize=(4, 3))
+
+plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', cmap=plt.cm.Paired)
+plt.xlabel('Sepal length')
+plt.ylabel('Sepal width')
+
+plt.xlim(xx.min(), xx.max())
+plt.ylim(yy.min(), yy.max())
+plt.xticks(())
+plt.yticks(())
+
+plt.show()

examples/frameworks/scikit-learn/requirements.txt

@@ -0,0 +1,3 @@
+joblib>=0.13.2
+scikit-learn
+trains

examples/frameworks/tensorboardx/pytorch_tensorboardX.py

@@ -0,0 +1,136 @@
+# TRAINS - Example of pytorch with tensorboardX
+#
+from __future__ import print_function
+
+import argparse
+import os
+from tempfile import gettempdir
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from tensorboardX import SummaryWriter
+from torch.autograd import Variable
+from torchvision import datasets, transforms
+
+from trains import Task
+
+
+class Net(nn.Module):
+    def __init__(self):
+        super(Net, self).__init__()
+        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
+        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
+        self.conv2_drop = nn.Dropout2d()
+        self.fc1 = nn.Linear(320, 50)
+        self.fc2 = nn.Linear(50, 10)
+
+    def forward(self, x):
+        x = F.relu(F.max_pool2d(self.conv1(x), 2))
+        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
+        x = x.view(-1, 320)
+        x = F.relu(self.fc1(x))
+        x = F.dropout(x, training=self.training)
+        x = self.fc2(x)
+        return F.log_softmax(x, dim=1)
+
+
+def train(model, epoch, train_loader, args, optimizer, writer):
+    model.train()
+    for batch_idx, (data, target) in enumerate(train_loader):
+        if args.cuda:
+            data, target = data.cuda(), target.cuda()
+        data, target = Variable(data), Variable(target)
+        optimizer.zero_grad()
+        output = model(data)
+        loss = F.nll_loss(output, target)
+        loss.backward()
+        optimizer.step()
+        if batch_idx % args.log_interval == 0:
+            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
+                epoch, batch_idx * len(data), len(train_loader.dataset),
+                100. * batch_idx / len(train_loader), loss.data.item()))
+            niter = epoch*len(train_loader)+batch_idx
+            writer.add_scalar('Train/Loss', loss.data.item(), niter)
+
+
+def test(model, test_loader, args, optimizer, writer):
+    model.eval()
+    test_loss = 0
+    correct = 0
+    for niter, (data, target) in enumerate(test_loader):
+        if args.cuda:
+            data, target = data.cuda(), target.cuda()
+        data, target = Variable(data), Variable(target)
+        output = model(data)
+        test_loss += F.nll_loss(output, target, reduction='sum').data.item()  # sum up batch loss
+        pred = output.data.max(1)[1]  # get the index of the max log-probability
+        pred = pred.eq(target.data).cpu().sum()
+        writer.add_scalar('Test/Loss', pred, niter)
+        correct += pred
+        if niter % 100 == 0:
+            writer.add_image('test', data[0, :, :, :], niter)
+
+    test_loss /= len(test_loader.dataset)
+    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
+        test_loss, correct, len(test_loader.dataset),
+        100. * correct / len(test_loader.dataset)))
+
+
+def main():
+    # Training settings
+    parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
+    parser.add_argument('--batch-size', type=int, default=64, metavar='N',
+                        help='input batch size for training (default: 64)')
+    parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
+                        help='input batch size for testing (default: 1000)')
+    parser.add_argument('--epochs', type=int, default=2, metavar='N',
+                        help='number of epochs to train (default: 10)')
+    parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
+                        help='learning rate (default: 0.01)')
+    parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
+                        help='SGD momentum (default: 0.5)')
+    parser.add_argument('--no-cuda', action='store_true', default=False,
+                        help='disables CUDA training')
+    parser.add_argument('--seed', type=int, default=1, metavar='S',
+                        help='random seed (default: 1)')
+    parser.add_argument('--log-interval', type=int, default=10, metavar='N',
+                        help='how many batches to wait before logging training status')
+    args = parser.parse_args()
+    args.cuda = not args.no_cuda and torch.cuda.is_available()
+
+    task = Task.init(project_name='examples', task_name='pytorch with tensorboardX')  # noqa: F841
+    writer = SummaryWriter('runs')
+    writer.add_text('TEXT', 'This is some text', 0)
+
+    torch.manual_seed(args.seed)
+    if args.cuda:
+        torch.cuda.manual_seed(args.seed)
+
+    kwargs = {'num_workers': 4, 'pin_memory': True} if args.cuda else {}
+    train_loader = torch.utils.data.DataLoader(datasets.MNIST('../data', train=True, download=True,
+                                                              transform=transforms.Compose([
+                                                                  transforms.ToTensor(),
+                                                                  transforms.Normalize((0.1307,), (0.3081,))])),
+                                               batch_size=args.batch_size, shuffle=True, **kwargs)
+    test_loader = torch.utils.data.DataLoader(datasets.MNIST('../data', train=False,
+                                                             transform=transforms.Compose([
+                                                                 transforms.ToTensor(),
+                                                                 transforms.Normalize((0.1307,), (0.3081,))])),
+                                              batch_size=args.batch_size, shuffle=True, **kwargs)
+
+    model = Net()
+    if args.cuda:
+        model.cuda()
+    optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)
+
+    for epoch in range(1, args.epochs + 1):
+        train(model, epoch, train_loader, args, optimizer, writer)
+        torch.save(model, os.path.join(gettempdir(), 'model{}'.format(epoch)))
+    test(model, test_loader, args, optimizer, writer)
+
+
+if __name__ == "__main__":
+    # Hack for supporting Windows OS - https://pytorch.org/docs/stable/notes/windows.html#usage-multiprocessing
+    main()

examples/frameworks/tensorboardx/requirements.txt

@@ -0,0 +1,4 @@
+tensorboardX>=1.8
+torch>=1.1.0
+torchvision>=0.3.0
+trains

examples/frameworks/tensorflow/legacy/requirements.txt

@@ -0,0 +1,3 @@
+trains
+tensorboard>=1.14.0
+tensorflow>=1.14.0

examples/frameworks/tensorflow/legacy/tensorboard_pr_curve.py

@@ -0,0 +1,238 @@
+# TRAINS - Example of new tensorboard pr_curves model
+#
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Create sample PR curve summary data.
+We have 3 classes: R, G, and B. We generate colors within RGB space from 3
+normal distributions (1 at each corner of the color triangle: [255, 0, 0],
+[0, 255, 0], and [0, 0, 255]).
+The true label of each random color is associated with the normal distribution
+that generated it.
+Using 3 other normal distributions (over the distance each color is from a
+corner of the color triangle - RGB), we then compute the probability that each
+color belongs to the class. We use those probabilities to generate PR curves.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os.path
+from tempfile import gettempdir
+
+from absl import app
+from absl import flags
+from six.moves import xrange  # pylint: disable=redefined-builtin
+import tensorflow as tf
+from tensorboard.plugins.pr_curve import summary
+from trains import Task
+
+task = Task.init(project_name='examples', task_name='tensorboard pr_curve')
+
+tf.compat.v1.disable_v2_behavior()
+FLAGS = flags.FLAGS
+flags.DEFINE_string('logdir', os.path.join(gettempdir(), "pr_curve_demo"),
+                    "Directory into which to write TensorBoard data.")
+
+flags.DEFINE_integer('steps', 10,
+                     'Number of steps to generate for each PR curve.')
+
+
+def start_runs(
+        logdir,
+        steps,
+        run_name,
+        thresholds,
+        mask_every_other_prediction=False):
+    """Generate a PR curve with precision and recall evenly weighted.
+    Arguments:
+      logdir: The directory into which to store all the runs' data.
+      steps: The number of steps to run for.
+      run_name: The name of the run.
+      thresholds: The number of thresholds to use for PR curves.
+      mask_every_other_prediction: Whether to mask every other prediction by
+        alternating weights between 0 and 1.
+    """
+    tf.compat.v1.reset_default_graph()
+    tf.compat.v1.set_random_seed(42)
+
+    # Create a normal distribution layer used to generate true color labels.
+    distribution = tf.compat.v1.distributions.Normal(loc=0., scale=142.)
+
+    # Sample the distribution to generate colors. Lets generate different numbers
+    # of each color. The first dimension is the count of examples.
+
+    # The calls to sample() are given fixed random seed values that are "magic"
+    # in that they correspond to the default seeds for those ops when the PR
+    # curve test (which depends on this code) was written. We've pinned these
+    # instead of continuing to use the defaults since the defaults are based on
+    # node IDs from the sequence of nodes added to the graph, which can silently
+    # change when this code or any TF op implementations it uses are modified.
+
+    # TODO(nickfelt): redo the PR curve test to avoid reliance on random seeds.
+
+    # Generate reds.
+    number_of_reds = 100
+    true_reds = tf.clip_by_value(
+        tf.concat([
+            255 - tf.abs(distribution.sample([number_of_reds, 1], seed=11)),
+            tf.abs(distribution.sample([number_of_reds, 2], seed=34))
+        ], axis=1),
+        0, 255)
+
+    # Generate greens.
+    number_of_greens = 200
+    true_greens = tf.clip_by_value(
+        tf.concat([
+            tf.abs(distribution.sample([number_of_greens, 1], seed=61)),
+            255 - tf.abs(distribution.sample([number_of_greens, 1], seed=82)),
+            tf.abs(distribution.sample([number_of_greens, 1], seed=105))
+        ], axis=1),
+        0, 255)
+
+    # Generate blues.
+    number_of_blues = 150
+    true_blues = tf.clip_by_value(
+        tf.concat([
+            tf.abs(distribution.sample([number_of_blues, 2], seed=132)),
+            255 - tf.abs(distribution.sample([number_of_blues, 1], seed=153))
+        ], axis=1),
+        0, 255)
+
+    # Assign each color a vector of 3 booleans based on its true label.
+    labels = tf.concat([
+        tf.tile(tf.constant([[True, False, False]]), (number_of_reds, 1)),
+        tf.tile(tf.constant([[False, True, False]]), (number_of_greens, 1)),
+        tf.tile(tf.constant([[False, False, True]]), (number_of_blues, 1)),
+    ], axis=0)
+
+    # We introduce 3 normal distributions. They are used to predict whether a
+    # color falls under a certain class (based on distances from corners of the
+    # color triangle). The distributions vary per color. We have the distributions
+    # narrow over time.
+    initial_standard_deviations = [v + FLAGS.steps for v in (158, 200, 242)]
+    iteration = tf.compat.v1.placeholder(tf.int32, shape=[])
+    red_predictor = tf.compat.v1.distributions.Normal(
+        loc=0.,
+        scale=tf.cast(
+            initial_standard_deviations[0] - iteration,
+            dtype=tf.float32))
+    green_predictor = tf.compat.v1.distributions.Normal(
+        loc=0.,
+        scale=tf.cast(
+            initial_standard_deviations[1] - iteration,
+            dtype=tf.float32))
+    blue_predictor = tf.compat.v1.distributions.Normal(
+        loc=0.,
+        scale=tf.cast(
+            initial_standard_deviations[2] - iteration,
+            dtype=tf.float32))
+
+    # Make predictions (assign 3 probabilities to each color based on each color's
+    # distance to each of the 3 corners). We seek double the area in the right
+    # tail of the normal distribution.
+    examples = tf.concat([true_reds, true_greens, true_blues], axis=0)
+    probabilities_colors_are_red = (1 - red_predictor.cdf(
+        tf.norm(tensor=examples - tf.constant([255., 0, 0]), axis=1))) * 2
+    probabilities_colors_are_green = (1 - green_predictor.cdf(
+        tf.norm(tensor=examples - tf.constant([0, 255., 0]), axis=1))) * 2
+    probabilities_colors_are_blue = (1 - blue_predictor.cdf(
+        tf.norm(tensor=examples - tf.constant([0, 0, 255.]), axis=1))) * 2
+
+    predictions = (
+        probabilities_colors_are_red,
+        probabilities_colors_are_green,
+        probabilities_colors_are_blue
+    )
+
+    # This is the crucial piece. We write data required for generating PR curves.
+    # We create 1 summary per class because we create 1 PR curve per class.
+    for i, color in enumerate(('red', 'green', 'blue')):
+        description = ('The probabilities used to create this PR curve are '
+                       'generated from a normal distribution. Its standard '
+                       'deviation is initially %0.0f and decreases over time.' %
+                       initial_standard_deviations[i])
+
+        weights = None
+        if mask_every_other_prediction:
+            # Assign a weight of 0 to every even-indexed prediction. Odd-indexed
+            # predictions are assigned a default weight of 1.
+            consecutive_indices = tf.reshape(
+                tf.range(tf.size(input=predictions[i])), tf.shape(input=predictions[i]))
+            weights = tf.cast(consecutive_indices % 2, dtype=tf.float32)
+
+        summary.op(
+            name=color,
+            labels=labels[:, i],
+            predictions=predictions[i],
+            num_thresholds=thresholds,
+            weights=weights,
+            display_name='classifying %s' % color,
+            description=description)
+    merged_summary_op = tf.compat.v1.summary.merge_all()
+    events_directory = os.path.join(logdir, run_name)
+    sess = tf.compat.v1.Session()
+    writer = tf.compat.v1.summary.FileWriter(events_directory, sess.graph)
+
+    for step in xrange(steps):
+        feed_dict = {
+            iteration: step,
+        }
+        merged_summary = sess.run(merged_summary_op, feed_dict=feed_dict)
+        writer.add_summary(merged_summary, step)
+
+    writer.close()
+
+
+def run_all(logdir, steps, thresholds, verbose=False):
+    """Generate PR curve summaries.
+    Arguments:
+      logdir: The directory into which to store all the runs' data.
+      steps: The number of steps to run for.
+      verbose: Whether to print the names of runs into stdout during execution.
+      thresholds: The number of thresholds to use for PR curves.
+    """
+    # First, we generate data for a PR curve that assigns even weights for
+    # predictions of all classes.
+    run_name = 'colors'
+    if verbose:
+        print('--- Running: %s' % run_name)
+    start_runs(
+        logdir=logdir,
+        steps=steps,
+        run_name=run_name,
+        thresholds=thresholds)
+
+    # Next, we generate data for a PR curve that assigns arbitrary weights to
+    # predictions.
+    run_name = 'mask_every_other_prediction'
+    if verbose:
+        print('--- Running: %s' % run_name)
+    start_runs(
+        logdir=logdir,
+        steps=steps,
+        run_name=run_name,
+        thresholds=thresholds,
+        mask_every_other_prediction=True)
+
+
+def main(_):
+    print('Saving output to %s.' % FLAGS.logdir)
+    run_all(FLAGS.logdir, FLAGS.steps, 50, verbose=True)
+    print('Done. Output saved to %s.' % FLAGS.logdir)
+
+
+if __name__ == '__main__':
+    app.run(main)

examples/frameworks/tensorflow/legacy/tensorboard_toy.py

@@ -0,0 +1,83 @@
+# TRAINS - Example of tensorboard with tensorflow (without any actual training)
+#
+import os
+from tempfile import gettempdir
+
+import tensorflow as tf
+import numpy as np
+from PIL import Image
+
+from trains import Task
+task = Task.init(project_name='examples', task_name='tensorboard toy example')
+
+
+k = tf.placeholder(tf.float32)
+
+# Make a normal distribution, with a shifting mean
+mean_moving_normal = tf.random_normal(shape=[1000], mean=(5*k), stddev=1)
+# Record that distribution into a histogram summary
+tf.summary.histogram("normal/moving_mean", mean_moving_normal)
+tf.summary.scalar("normal/value", mean_moving_normal[-1])
+
+# Make a normal distribution with shrinking variance
+variance_shrinking_normal = tf.random_normal(shape=[1000], mean=0, stddev=1-(k))
+# Record that distribution too
+tf.summary.histogram("normal/shrinking_variance", variance_shrinking_normal)
+tf.summary.scalar("normal/variance_shrinking_normal", variance_shrinking_normal[-1])
+
+# Let's combine both of those distributions into one dataset
+normal_combined = tf.concat([mean_moving_normal, variance_shrinking_normal], 0)
+# We add another histogram summary to record the combined distribution
+tf.summary.histogram("normal/bimodal", normal_combined)
+tf.summary.scalar("normal/normal_combined", normal_combined[0])
+
+# Add a gamma distribution
+gamma = tf.random_gamma(shape=[1000], alpha=k)
+tf.summary.histogram("gamma", gamma)
+
+# And a poisson distribution
+poisson = tf.random_poisson(shape=[1000], lam=k)
+tf.summary.histogram("poisson", poisson)
+
+# And a uniform distribution
+uniform = tf.random_uniform(shape=[1000], maxval=k*10)
+tf.summary.histogram("uniform", uniform)
+
+# Finally, combine everything together!
+all_distributions = [mean_moving_normal, variance_shrinking_normal, gamma, poisson, uniform]
+all_combined = tf.concat(all_distributions, 0)
+tf.summary.histogram("all_combined", all_combined)
+
+# Log text value
+tf.summary.text("this is a test", tf.make_tensor_proto("This is the content", dtype=tf.string))
+
+# convert to 4d [batch, col, row, RGB-channels]
+image_open = Image.open(os.path.join("..", "..", "..", "reporting", "data_samples", "picasso.jpg"))
+image = np.asarray(image_open)
+image_gray = image[:, :, 0][np.newaxis, :, :, np.newaxis]
+image_rgba = np.concatenate((image, 255*np.atleast_3d(np.ones(shape=image.shape[:2], dtype=np.uint8))), axis=2)
+image_rgba = image_rgba[np.newaxis, :, :, :]
+image = image[np.newaxis, :, :, :]
+
+tf.summary.image("test", image, max_outputs=10)
+tf.summary.image("test_gray", image_gray, max_outputs=10)
+tf.summary.image("test_rgba", image_rgba, max_outputs=10)
+
+# Setup a session and summary writer
+summaries = tf.summary.merge_all()
+sess = tf.Session()
+
+logger = task.get_logger()
+
+# Use original FileWriter for comparison , run:
+# % tensorboard --logdir=/tmp/histogram_example
+writer = tf.summary.FileWriter(os.path.join(gettempdir(), "histogram_example"))
+
+# Setup a loop and write the summaries to disk
+N = 40
+for step in range(N):
+    k_val = step/float(N)
+    summ = sess.run(summaries, feed_dict={k: k_val})
+    writer.add_summary(summ, global_step=step)
+
+print('Done!')

examples/frameworks/tensorflow/legacy/tensorflow_eager.py

@@ -0,0 +1,355 @@
+# TRAINS - Example of tensorflow eager mode, model logging and tensorboard
+#
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""A deep MNIST classifier using convolutional layers.
+Sample usage:
+  python mnist.py --help
+"""
+
+from __future__ import absolute_import, division, print_function
+
+import argparse
+import os
+import sys
+import time
+from tempfile import gettempdir
+
+import tensorflow as tf
+from tensorflow.examples.tutorials.mnist import input_data
+
+from trains import Task
+
+tf.compat.v1.enable_eager_execution()
+
+task = Task.init(project_name='examples', task_name='Tensorflow eager mode')
+
+
+FLAGS = tf.app.flags.FLAGS
+tf.app.flags.DEFINE_integer('data_num', 100, """Flag of type integer""")
+tf.app.flags.DEFINE_string('img_path', './img', """Flag of type string""")
+
+
+layers = tf.keras.layers
+FLAGS = None
+
+
+class Discriminator(tf.keras.Model):
+    """
+    GAN Discriminator.
+    A network to differentiate between generated and real handwritten digits.
+    """
+
+    def __init__(self, data_format):
+        """Creates a model for discriminating between real and generated digits.
+        Args:
+          data_format: Either 'channels_first' or 'channels_last'.
+            'channels_first' is typically faster on GPUs while 'channels_last' is
+            typically faster on CPUs. See
+            https://www.tensorflow.org/performance/performance_guide#data_formats
+        """
+        super(Discriminator, self).__init__(name='')
+        if data_format == 'channels_first':
+            self._input_shape = [-1, 1, 28, 28]
+        else:
+            assert data_format == 'channels_last'
+            self._input_shape = [-1, 28, 28, 1]
+        self.conv1 = layers.Conv2D(
+            64, 5, padding='SAME', data_format=data_format, activation=tf.tanh)
+        self.pool1 = layers.AveragePooling2D(2, 2, data_format=data_format)
+        self.conv2 = layers.Conv2D(
+            128, 5, data_format=data_format, activation=tf.tanh)
+        self.pool2 = layers.AveragePooling2D(2, 2, data_format=data_format)
+        self.flatten = layers.Flatten()
+        self.fc1 = layers.Dense(1024, activation=tf.tanh)
+        self.fc2 = layers.Dense(1, activation=None)
+
+    def call(self, inputs):
+        """Return two logits per image estimating input authenticity.
+        Users should invoke __call__ to run the network, which delegates to this
+        method (and not call this method directly).
+        Args:
+          inputs: A batch of images as a Tensor with shape [batch_size, 28, 28, 1]
+            or [batch_size, 1, 28, 28]
+        Returns:
+          A Tensor with shape [batch_size] containing logits estimating
+          the probability that corresponding digit is real.
+        """
+        x = tf.reshape(inputs, self._input_shape)
+        x = self.conv1(x)
+        x = self.pool1(x)
+        x = self.conv2(x)
+        x = self.pool2(x)
+        x = self.flatten(x)
+        x = self.fc1(x)
+        x = self.fc2(x)
+        return x
+
+
+class Generator(tf.keras.Model):
+    """
+    Generator of handwritten digits similar to the ones in the MNIST dataset.
+    """
+
+    def __init__(self, data_format):
+        """Creates a model for discriminating between real and generated digits.
+        Args:
+          data_format: Either 'channels_first' or 'channels_last'.
+            'channels_first' is typically faster on GPUs while 'channels_last' is
+            typically faster on CPUs. See
+            https://www.tensorflow.org/performance/performance_guide#data_formats
+        """
+        super(Generator, self).__init__(name='')
+        self.data_format = data_format
+        # We are using 128 6x6 channels as input to the first deconvolution layer
+        if data_format == 'channels_first':
+            self._pre_conv_shape = [-1, 128, 6, 6]
+        else:
+            assert data_format == 'channels_last'
+            self._pre_conv_shape = [-1, 6, 6, 128]
+        self.fc1 = layers.Dense(6 * 6 * 128, activation=tf.tanh)
+
+        # In call(), we reshape the output of fc1 to _pre_conv_shape
+
+        # Deconvolution layer. Resulting image shape: (batch, 14, 14, 64)
+        self.conv1 = layers.Conv2DTranspose(
+            64, 4, strides=2, activation=None, data_format=data_format)
+
+        # Deconvolution layer. Resulting image shape: (batch, 28, 28, 1)
+        self.conv2 = layers.Conv2DTranspose(
+            1, 2, strides=2, activation=tf.nn.sigmoid, data_format=data_format)
+
+    def call(self, inputs):
+        """Return a batch of generated images.
+        Users should invoke __call__ to run the network, which delegates to this
+        method (and not call this method directly).
+        Args:
+          inputs: A batch of noise vectors as a Tensor with shape
+            [batch_size, length of noise vectors].
+        Returns:
+          A Tensor containing generated images. If data_format is 'channels_last',
+          the shape of returned images is [batch_size, 28, 28, 1], else
+          [batch_size, 1, 28, 28]
+        """
+
+        x = self.fc1(inputs)
+        x = tf.reshape(x, shape=self._pre_conv_shape)
+        x = self.conv1(x)
+        x = self.conv2(x)
+        return x
+
+
+def discriminator_loss(discriminator_real_outputs, discriminator_gen_outputs):
+    """
+    Original discriminator loss for GANs, with label smoothing.
+    See `Generative Adversarial Nets` (https://arxiv.org/abs/1406.2661) for more
+    details.
+    Args:
+    discriminator_real_outputs: Discriminator output on real data.
+    discriminator_gen_outputs: Discriminator output on generated data. Expected
+      to be in the range of (-inf, inf).
+    Returns:
+    A scalar loss Tensor.
+    """
+
+    loss_on_real = tf.compat.v1.losses.sigmoid_cross_entropy(
+      tf.ones_like(discriminator_real_outputs),
+      discriminator_real_outputs,
+      label_smoothing=0.25)
+    loss_on_generated = tf.compat.v1.losses.sigmoid_cross_entropy(
+      tf.zeros_like(discriminator_gen_outputs), discriminator_gen_outputs)
+    loss = loss_on_real + loss_on_generated
+    tf.contrib.summary.scalar('discriminator_loss', loss)
+    return loss
+
+
+def generator_loss(discriminator_gen_outputs):
+    """
+    Original generator loss for GANs.
+    L = -log(sigmoid(D(G(z))))
+    See `Generative Adversarial Nets` (https://arxiv.org/abs/1406.2661)
+    for more details.
+    Args:
+    discriminator_gen_outputs: Discriminator output on generated data. Expected
+      to be in the range of (-inf, inf).
+    Returns:
+    A scalar loss Tensor.
+    """
+    loss = tf.compat.v1.losses.sigmoid_cross_entropy(
+      tf.ones_like(discriminator_gen_outputs), discriminator_gen_outputs)
+    tf.contrib.summary.scalar('generator_loss', loss)
+    return loss
+
+
+def train_one_epoch(generator, discriminator, generator_optimizer,
+                    discriminator_optimizer, dataset, step_counter,
+                    log_interval, noise_dim):
+    """
+    Train `generator` and `discriminator` models on `dataset`.
+    Args:
+    generator: Generator model.
+    discriminator: Discriminator model.
+    generator_optimizer: Optimizer to use for generator.
+    discriminator_optimizer: Optimizer to use for discriminator.
+    dataset: Dataset of images to train on.
+    step_counter: An integer variable, used to write summaries regularly.
+    log_interval: How many steps to wait between logging and collecting
+      summaries.
+    noise_dim: Dimension of noise vector to use.
+    """
+
+    total_generator_loss = 0.0
+    total_discriminator_loss = 0.0
+    for (batch_index, images) in enumerate(dataset):
+        with tf.device('/cpu:0'):
+            tf.compat.v1.assign_add(step_counter, 1)
+        with tf.contrib.summary.record_summaries_every_n_global_steps(
+                log_interval, global_step=step_counter):
+            current_batch_size = images.shape[0]
+            noise = tf.random.uniform(
+                  shape=[current_batch_size, noise_dim],
+                  minval=-1.,
+                  maxval=1.,
+                  seed=batch_index)
+
+            # we can use 2 tapes or a single persistent tape.
+            # Using two tapes is memory efficient since intermediate tensors can be
+            # released between the two .gradient() calls below
+            with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
+                generated_images = generator(noise)
+                tf.contrib.summary.image(
+                    'generated_images',
+                    tf.reshape(generated_images, [-1, 28, 28, 1]),
+                    max_images=10)
+
+                discriminator_gen_outputs = discriminator(generated_images)
+                discriminator_real_outputs = discriminator(images)
+                discriminator_loss_val = discriminator_loss(discriminator_real_outputs,
+                                                            discriminator_gen_outputs)
+                total_discriminator_loss += discriminator_loss_val
+
+                generator_loss_val = generator_loss(discriminator_gen_outputs)
+                total_generator_loss += generator_loss_val
+
+            generator_grad = gen_tape.gradient(generator_loss_val,
+                                               generator.variables)
+            discriminator_grad = disc_tape.gradient(discriminator_loss_val,
+                                                    discriminator.variables)
+
+            generator_optimizer.apply_gradients(
+                zip(generator_grad, generator.variables))
+            discriminator_optimizer.apply_gradients(
+                zip(discriminator_grad, discriminator.variables))
+
+            if log_interval and batch_index > 0 and batch_index % log_interval == 0:
+                print('Batch #%d\tAverage Generator Loss: %.6f\tAverage Discriminator Loss: %.6f' %
+                      (batch_index, total_generator_loss / batch_index, total_discriminator_loss / batch_index))
+
+
+def main(_):
+    (device, data_format) = ('/gpu:0', 'channels_first')
+    if FLAGS.no_gpu or tf.contrib.eager.num_gpus() <= 0:
+        (device, data_format) = ('/cpu:0', 'channels_last')
+    print('Using device %s, and data format %s.' % (device, data_format))
+
+    # Load the datasets
+    data = input_data.read_data_sets(FLAGS.data_dir)
+    dataset = (
+          tf.data.Dataset.from_tensor_slices(data.train.images[:1280]).shuffle(60000).batch(FLAGS.batch_size))
+
+    # Create the models and optimizers.
+    model_objects = {
+        'generator': Generator(data_format),
+        'discriminator': Discriminator(data_format),
+        'generator_optimizer': tf.compat.v1.train.AdamOptimizer(FLAGS.lr),
+        'discriminator_optimizer': tf.compat.v1.train.AdamOptimizer(FLAGS.lr),
+        'step_counter': tf.compat.v1.train.get_or_create_global_step(),
+    }
+
+    # Prepare summary writer and checkpoint info
+    summary_writer = tf.contrib.summary.create_file_writer(
+          FLAGS.output_dir, flush_millis=1000)
+    checkpoint_prefix = os.path.join(FLAGS.checkpoint_dir, 'ckpt')
+    latest_cpkt = tf.train.latest_checkpoint(FLAGS.checkpoint_dir)
+    if latest_cpkt:
+        print('Using latest checkpoint at ' + latest_cpkt)
+    checkpoint = tf.train.Checkpoint(**model_objects)
+    # Restore variables on creation if a checkpoint exists.
+    checkpoint.restore(latest_cpkt)
+
+    with tf.device(device):
+        for _ in range(3):
+            start = time.time()
+            with summary_writer.as_default():
+                train_one_epoch(dataset=dataset, log_interval=FLAGS.log_interval,
+                                noise_dim=FLAGS.noise, **model_objects)
+            end = time.time()
+            checkpoint.save(checkpoint_prefix)
+            print('\nTrain time for epoch #%d (step %d): %f' %
+                  (checkpoint.save_counter.numpy(), checkpoint.step_counter.numpy(), end - start))
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+            '--data-dir',
+            type=str,
+            default=os.path.join(gettempdir(), 'tensorflow', 'mnist', 'input_data'),
+            help='Directory for storing input data (default /tmp/tensorflow/mnist/input_data)')
+    parser.add_argument(
+            '--batch-size',
+            type=int,
+            default=16,
+            metavar='N',
+            help='input batch size for training (default: 128)')
+    parser.add_argument(
+            '--log-interval',
+            type=int,
+            default=1,
+            metavar='N',
+            help='number of batches between logging and writing summaries (default: 100)')
+    parser.add_argument(
+            '--output_dir',
+            type=str,
+            default=os.path.join(gettempdir(), 'tensorflow'),
+            metavar='DIR',
+            help='Directory to write TensorBoard summaries (defaults to none)')
+    parser.add_argument(
+            '--checkpoint_dir',
+            type=str,
+            default=os.path.join(gettempdir(), 'tensorflow', 'mnist', 'checkpoints'),
+            metavar='DIR',
+            help='Directory to save checkpoints in (once per epoch) (default /tmp/tensorflow/mnist/checkpoints/)')
+    parser.add_argument(
+            '--lr',
+            type=float,
+            default=0.001,
+            metavar='LR',
+            help='learning rate (default: 0.001)')
+    parser.add_argument(
+            '--noise',
+            type=int,
+            default=100,
+            metavar='N',
+            help='Length of noise vector for generator input (default: 100)')
+    parser.add_argument(
+            '--no-gpu',
+            action='store_true',
+            default=False,
+            help='disables GPU usage even if a GPU is available')
+
+    FLAGS, unparsed = parser.parse_known_args()
+
+tf.compat.v1.app.run(main=main, argv=[sys.argv[0]] + unparsed)

examples/frameworks/tensorflow/legacy/tensorflow_mnist_with_summaries.py

@@ -0,0 +1,219 @@
+# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the 'License');
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an 'AS IS' BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""A simple MNIST classifier which displays summaries in TensorBoard.
+
+This is an unimpressive MNIST model, but it is a good example of using
+tf.name_scope to make a graph legible in the TensorBoard graph explorer, and of
+naming summary tags so that they are grouped meaningfully in TensorBoard.
+
+It demonstrates the functionality of every TensorBoard dashboard.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import argparse
+import os
+import sys
+import tempfile
+import tensorflow as tf
+
+from tensorflow.examples.tutorials.mnist import input_data
+from trains import Task
+
+FLAGS = None
+task = Task.init(project_name='examples', task_name='Tensorflow mnist with summaries example')
+
+
+def train():
+    # Import data
+    mnist = input_data.read_data_sets(FLAGS.data_dir, fake_data=FLAGS.fake_data)
+
+    sess = tf.InteractiveSession()
+    # Create a multilayer model.
+
+    # Input placeholders
+    with tf.name_scope('input'):
+        x = tf.placeholder(tf.float32, [None, 784], name='x-input')
+        y_ = tf.placeholder(tf.int64, [None], name='y-input')
+
+    with tf.name_scope('input_reshape'):
+        image_shaped_input = tf.reshape(x, [-1, 28, 28, 1])
+        tf.summary.image('input', image_shaped_input, 10)
+
+    # We can't initialize these variables to 0 - the network will get stuck.
+    def weight_variable(shape):
+        """Create a weight variable with appropriate initialization."""
+        initial = tf.truncated_normal(shape, stddev=0.1)
+        return tf.Variable(initial)
+
+    def bias_variable(shape):
+        """Create a bias variable with appropriate initialization."""
+        initial = tf.constant(0.1, shape=shape)
+        return tf.Variable(initial)
+
+    def variable_summaries(var):
+        """Attach a lot of summaries to a Tensor (for TensorBoard visualization)."""
+        with tf.name_scope('summaries'):
+            mean = tf.reduce_mean(var)
+            tf.summary.scalar('mean', mean)
+            with tf.name_scope('stddev'):
+                stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
+            tf.summary.scalar('stddev', stddev)
+            tf.summary.scalar('max', tf.reduce_max(var))
+            tf.summary.scalar('min', tf.reduce_min(var))
+            tf.summary.histogram('histogram', var)
+
+    def nn_layer(input_tensor, input_dim, output_dim, layer_name, act=tf.nn.relu):
+        """Reusable code for making a simple neural net layer.
+
+        It does a matrix multiply, bias add, and then uses ReLU to nonlinearize.
+        It also sets up name scoping so that the resultant graph is easy to read,
+        and adds a number of summary ops.
+        """
+        # Adding a name scope ensures logical grouping of the layers in the graph.
+        with tf.name_scope(layer_name):
+            # This Variable will hold the state of the weights for the layer
+            with tf.name_scope('weights'):
+                weights = weight_variable([input_dim, output_dim])
+                variable_summaries(weights)
+            with tf.name_scope('biases'):
+                biases = bias_variable([output_dim])
+                variable_summaries(biases)
+            with tf.name_scope('Wx_plus_b'):
+                preactivate = tf.matmul(input_tensor, weights) + biases
+                tf.summary.histogram('pre_activations', preactivate)
+            activations = act(preactivate, name='activation')
+            tf.summary.histogram('activations', activations)
+            return activations
+
+    hidden1 = nn_layer(x, 784, 500, 'layer1')
+
+    with tf.name_scope('dropout'):
+        keep_prob = tf.placeholder(tf.float32)
+        tf.summary.scalar('dropout_keep_probability', keep_prob)
+        dropped = tf.nn.dropout(hidden1, keep_prob)
+
+    # Do not apply softmax activation yet, see below.
+    y = nn_layer(dropped, 500, 10, 'layer2', act=tf.identity)
+
+    with tf.name_scope('cross_entropy'):
+        # The raw formulation of cross-entropy,
+        #
+        # tf.reduce_mean(-tf.reduce_sum(y_ * tf.math.log(tf.softmax(y)),
+        #                                                             reduction_indices=[1]))
+        #
+        # can be numerically unstable.
+        #
+        # So here we use tf.compat.v1.losses.sparse_softmax_cross_entropy on the
+        # raw logit outputs of the nn_layer above, and then average across
+        # the batch.
+        with tf.name_scope('total'):
+            cross_entropy = tf.losses.sparse_softmax_cross_entropy(
+                labels=y_, logits=y)
+    tf.summary.scalar('cross_entropy', cross_entropy)
+
+    with tf.name_scope('train'):
+        train_step = tf.train.AdamOptimizer(FLAGS.learning_rate).minimize(
+            cross_entropy)
+
+    with tf.name_scope('accuracy'):
+        with tf.name_scope('correct_prediction'):
+            correct_prediction = tf.equal(tf.argmax(y, 1), y_)
+        with tf.name_scope('accuracy'):
+            accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
+    tf.summary.scalar('accuracy', accuracy)
+
+    # Merge all the summaries and write them out to
+    # /tmp/tensorflow/mnist/logs/mnist_with_summaries (by default)
+    merged = tf.summary.merge_all()
+    train_writer = tf.summary.FileWriter(os.path.join(FLAGS.log_dir, 'train'), sess.graph)
+    test_writer = tf.summary.FileWriter(os.path.join(FLAGS.log_dir, 'test'))
+
+    tf.global_variables_initializer().run()
+
+    # Train the model, and also write summaries.
+    # Every 10th step, measure test-set accuracy, and write test summaries
+    # All other steps, run train_step on training data, & add training summaries
+
+    def feed_dict(train):
+        """Make a TensorFlow feed_dict: maps data onto Tensor placeholders."""
+        if train or FLAGS.fake_data:
+            xs, ys = mnist.train.next_batch(FLAGS.batch_size, fake_data=FLAGS.fake_data)
+            k = FLAGS.dropout
+        else:
+            xs, ys = mnist.test.images, mnist.test.labels
+            k = 1.0
+        return {x: xs, y_: ys, keep_prob: k}
+
+    saver = tf.train.Saver()
+    for i in range(FLAGS.max_steps):
+        if i % 10 == 0:  # Record summaries and test-set accuracy
+            summary, acc = sess.run([merged, accuracy], feed_dict=feed_dict(False))
+            test_writer.add_summary(summary, i)
+            print('Accuracy at step %s: %s' % (i, acc))
+        else:  # Record train set summaries, and train
+            if i % FLAGS.batch_size == FLAGS.batch_size - 1:  # Record execution stats
+                run_metadata = tf.RunMetadata()
+                summary, _ = sess.run([merged, train_step],
+                                      feed_dict=feed_dict(True),
+                                      run_metadata=run_metadata)
+                train_writer.add_run_metadata(run_metadata, 'step%04d' % i)
+                train_writer.add_summary(summary, i)
+                print('Adding run metadata for', i)
+            else:  # Record a summary
+                summary, _ = sess.run([merged, train_step], feed_dict=feed_dict(True))
+                # train_writer.add_summary(summary, i)
+
+    save_path = saver.save(sess, FLAGS.save_path)
+    print("Saved model: %s" % save_path)
+    print('Flushing all images, this may take a couple of minutes')
+    train_writer.close()
+    test_writer.close()
+    print('Finished storing all metrics & images')
+
+
+def main(_):
+    if tf.gfile.Exists(FLAGS.log_dir):
+        tf.gfile.DeleteRecursively(FLAGS.log_dir)
+    tf.gfile.MakeDirs(FLAGS.log_dir)
+    with tf.Graph().as_default():
+        train()
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--fake_data', nargs='?', const=True, type=bool,
+                        default=False,
+                        help='If true, uses fake data for unit testing.')
+    parser.add_argument('--max_steps', type=int, default=300,
+                        help='Number of steps to run trainer.')
+    parser.add_argument('--learning_rate', type=float, default=0.001,
+                        help='Initial learning rate')
+    parser.add_argument('--dropout', type=float, default=0.9,
+                        help='Keep probability for training dropout.')
+    parser.add_argument('--data_dir', type=str,
+                        default=os.path.join(tempfile.gettempdir(), 'tensorflow', 'mnist', 'input_data'),
+                        help='Directory for storing input data')
+    parser.add_argument('--log_dir', type=str,
+                        default=os.path.join(tempfile.gettempdir(),
+                                             'tensorflow', 'mnist', 'logs', 'mnist_with_summaries'),
+                        help='Summaries log directory')
+    parser.add_argument('--save_path', default=os.path.join(tempfile.gettempdir(), "model.ckpt"),
+                        help='Save the trained model under this path')
+    parser.add_argument('--batch_size', default=100,
+                        help='Batch size for training')
+    FLAGS, unparsed = parser.parse_known_args()
+    tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

examples/frameworks/tensorflow/manual_model_upload.py

@@ -0,0 +1,42 @@
+# TRAINS - Example of manual model configuration and uploading
+#
+import os
+import tempfile
+
+import tensorflow as tf
+from trains import Task
+
+task = Task.init(project_name='examples', task_name='Model configuration and upload')
+
+model = tf.Module()
+
+# Connect a local configuration file
+config_file = os.path.join('..', '..', 'reporting', 'data_samples', 'sample.json')
+config_file = task.connect_configuration(config_file)
+# then read configuration as usual, the backend will contain a copy of it.
+# later when executing remotely, the returned `config_file` will be a temporary file
+# containing a new copy of the configuration retrieved form the backend
+# # model_config_dict = json.load(open(config_file, 'rt'))
+
+# Or Store dictionary of definition for a specific network design
+model_config_dict = {
+    'value': 13.37,
+    'dict': {'sub_value': 'string', 'sub_integer': 11},
+    'list_of_ints': [1, 2, 3, 4],
+}
+model_config_dict = task.connect_configuration(model_config_dict)
+
+# We now update the dictionary after connecting it, and the changes will be tracked as well.
+model_config_dict['new value'] = 10
+model_config_dict['value'] *= model_config_dict['new value']
+
+# store the label enumeration of the training model
+labels = {'background': 0, 'cat': 1, 'dog': 2}
+task.connect_label_enumeration(labels)
+
+# storing the model, it will have the task network configuration and label enumeration
+print('Any model stored from this point onwards, will contain both model_config and label_enumeration')
+
+tempdir = tempfile.mkdtemp()
+tf.saved_model.save(model, os.path.join(tempdir, "model"))
+print('Model saved')

examples/frameworks/tensorflow/requirements.txt

@@ -0,0 +1,3 @@
+tensorboard>=2.0
+tensorflow>=2.0
+trains

examples/frameworks/tensorflow/tensorboard_pr_curve.py

@@ -0,0 +1,279 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Create sample PR curve summary data.
+We have 3 classes: R, G, and B. We generate colors within RGB space from 3
+normal distributions (1 at each corner of the color triangle: [255, 0, 0],
+[0, 255, 0], and [0, 0, 255]).
+The true label of each random color is associated with the normal distribution
+that generated it.
+Using 3 other normal distributions (over the distance each color is from a
+corner of the color triangle - RGB), we then compute the probability that each
+color belongs to the class. We use those probabilities to generate PR curves.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os.path
+
+from tempfile import gettempdir
+from absl import app
+from absl import flags
+from six.moves import xrange  # pylint: disable=redefined-builtin
+import tensorflow as tf
+
+from tensorboard.plugins.pr_curve import summary
+from trains import Task
+
+
+task = Task.init(project_name='examples', task_name='tensorboard pr_curve')
+
+tf.compat.v1.disable_v2_behavior()
+FLAGS = flags.FLAGS
+
+flags.DEFINE_string(
+    "logdir",
+    os.path.join(gettempdir(), "pr_curve_demo"),
+    "Directory into which to write TensorBoard data.",
+)
+
+flags.DEFINE_integer(
+    "steps", 10, "Number of steps to generate for each PR curve."
+)
+
+
+def start_runs(
+    logdir, steps, run_name, thresholds, mask_every_other_prediction=False
+):
+    """Generate a PR curve with precision and recall evenly weighted.
+    Arguments:
+      logdir: The directory into which to store all the runs' data.
+      steps: The number of steps to run for.
+      run_name: The name of the run.
+      thresholds: The number of thresholds to use for PR curves.
+      mask_every_other_prediction: Whether to mask every other prediction by
+        alternating weights between 0 and 1.
+    """
+    tf.compat.v1.reset_default_graph()
+    tf.compat.v1.set_random_seed(42)
+
+    # Create a normal distribution layer used to generate true color labels.
+    distribution = tf.compat.v1.distributions.Normal(loc=0.0, scale=142.0)
+
+    # Sample the distribution to generate colors. Lets generate different numbers
+    # of each color. The first dimension is the count of examples.
+
+    # The calls to sample() are given fixed random seed values that are "magic"
+    # in that they correspond to the default seeds for those ops when the PR
+    # curve test (which depends on this code) was written. We've pinned these
+    # instead of continuing to use the defaults since the defaults are based on
+    # node IDs from the sequence of nodes added to the graph, which can silently
+    # change when this code or any TF op implementations it uses are modified.
+
+    # TODO(nickfelt): redo the PR curve test to avoid reliance on random seeds.
+
+    # Generate reds.
+    number_of_reds = 100
+    true_reds = tf.clip_by_value(
+        tf.concat(
+            [
+                255 - tf.abs(distribution.sample([number_of_reds, 1], seed=11)),
+                tf.abs(distribution.sample([number_of_reds, 2], seed=34)),
+            ],
+            axis=1,
+        ),
+        0,
+        255,
+    )
+
+    # Generate greens.
+    number_of_greens = 200
+    true_greens = tf.clip_by_value(
+        tf.concat(
+            [
+                tf.abs(distribution.sample([number_of_greens, 1], seed=61)),
+                255
+                - tf.abs(distribution.sample([number_of_greens, 1], seed=82)),
+                tf.abs(distribution.sample([number_of_greens, 1], seed=105)),
+            ],
+            axis=1,
+        ),
+        0,
+        255,
+    )
+
+    # Generate blues.
+    number_of_blues = 150
+    true_blues = tf.clip_by_value(
+        tf.concat(
+            [
+                tf.abs(distribution.sample([number_of_blues, 2], seed=132)),
+                255
+                - tf.abs(distribution.sample([number_of_blues, 1], seed=153)),
+            ],
+            axis=1,
+        ),
+        0,
+        255,
+    )
+
+    # Assign each color a vector of 3 booleans based on its true label.
+    labels = tf.concat(
+        [
+            tf.tile(tf.constant([[True, False, False]]), (number_of_reds, 1)),
+            tf.tile(tf.constant([[False, True, False]]), (number_of_greens, 1)),
+            tf.tile(tf.constant([[False, False, True]]), (number_of_blues, 1)),
+        ],
+        axis=0,
+    )
+
+    # We introduce 3 normal distributions. They are used to predict whether a
+    # color falls under a certain class (based on distances from corners of the
+    # color triangle). The distributions vary per color. We have the distributions
+    # narrow over time.
+    initial_standard_deviations = [v + FLAGS.steps for v in (158, 200, 242)]
+    iteration = tf.compat.v1.placeholder(tf.int32, shape=[])
+    red_predictor = tf.compat.v1.distributions.Normal(
+        loc=0.0,
+        scale=tf.cast(
+            initial_standard_deviations[0] - iteration, dtype=tf.float32
+        ),
+    )
+    green_predictor = tf.compat.v1.distributions.Normal(
+        loc=0.0,
+        scale=tf.cast(
+            initial_standard_deviations[1] - iteration, dtype=tf.float32
+        ),
+    )
+    blue_predictor = tf.compat.v1.distributions.Normal(
+        loc=0.0,
+        scale=tf.cast(
+            initial_standard_deviations[2] - iteration, dtype=tf.float32
+        ),
+    )
+
+    # Make predictions (assign 3 probabilities to each color based on each color's
+    # distance to each of the 3 corners). We seek double the area in the right
+    # tail of the normal distribution.
+    examples = tf.concat([true_reds, true_greens, true_blues], axis=0)
+    probabilities_colors_are_red = (
+        1
+        - red_predictor.cdf(
+            tf.norm(tensor=examples - tf.constant([255.0, 0, 0]), axis=1)
+        )
+    ) * 2
+    probabilities_colors_are_green = (
+        1
+        - green_predictor.cdf(
+            tf.norm(tensor=examples - tf.constant([0, 255.0, 0]), axis=1)
+        )
+    ) * 2
+    probabilities_colors_are_blue = (
+        1
+        - blue_predictor.cdf(
+            tf.norm(tensor=examples - tf.constant([0, 0, 255.0]), axis=1)
+        )
+    ) * 2
+
+    predictions = (
+        probabilities_colors_are_red,
+        probabilities_colors_are_green,
+        probabilities_colors_are_blue,
+    )
+
+    # This is the crucial piece. We write data required for generating PR curves.
+    # We create 1 summary per class because we create 1 PR curve per class.
+    for i, color in enumerate(("red", "green", "blue")):
+        description = (
+            "The probabilities used to create this PR curve are "
+            "generated from a normal distribution. Its standard "
+            "deviation is initially %0.0f and decreases over time."
+            % initial_standard_deviations[i]
+        )
+
+        weights = None
+        if mask_every_other_prediction:
+            # Assign a weight of 0 to every even-indexed prediction. Odd-indexed
+            # predictions are assigned a default weight of 1.
+            consecutive_indices = tf.reshape(
+                tf.range(tf.size(input=predictions[i])),
+                tf.shape(input=predictions[i]),
+            )
+            weights = tf.cast(consecutive_indices % 2, dtype=tf.float32)
+
+        summary.op(
+            name=color,
+            labels=labels[:, i],
+            predictions=predictions[i],
+            num_thresholds=thresholds,
+            weights=weights,
+            display_name="classifying %s" % color,
+            description=description,
+        )
+    merged_summary_op = tf.compat.v1.summary.merge_all()
+    events_directory = os.path.join(logdir, run_name)
+    sess = tf.compat.v1.Session()
+    writer = tf.compat.v1.summary.FileWriter(events_directory, sess.graph)
+
+    for step in xrange(steps):
+        feed_dict = {
+            iteration: step,
+        }
+        merged_summary = sess.run(merged_summary_op, feed_dict=feed_dict)
+        writer.add_summary(merged_summary, step)
+
+    writer.close()
+
+
+def run_all(logdir, steps, thresholds, verbose=False):
+    """Generate PR curve summaries.
+    Arguments:
+      logdir: The directory into which to store all the runs' data.
+      steps: The number of steps to run for.
+      verbose: Whether to print the names of runs into stdout during execution.
+      thresholds: The number of thresholds to use for PR curves.
+    """
+    # First, we generate data for a PR curve that assigns even weights for
+    # predictions of all classes.
+    run_name = "colors"
+    if verbose:
+        print("--- Running: %s" % run_name)
+    start_runs(
+        logdir=logdir, steps=steps, run_name=run_name, thresholds=thresholds
+    )
+
+    # Next, we generate data for a PR curve that assigns arbitrary weights to
+    # predictions.
+    run_name = "mask_every_other_prediction"
+    if verbose:
+        print("--- Running: %s" % run_name)
+    start_runs(
+        logdir=logdir,
+        steps=steps,
+        run_name=run_name,
+        thresholds=thresholds,
+        mask_every_other_prediction=True,
+    )
+
+
+def main(unused_argv):
+    print("Saving output to %s." % FLAGS.logdir)
+    run_all(FLAGS.logdir, FLAGS.steps, 50, verbose=True)
+    print("Done. Output saved to %s." % FLAGS.logdir)
+
+
+if __name__ == "__main__":
+    app.run(main)

examples/frameworks/tensorflow/tensorboard_toy.py

@@ -0,0 +1,76 @@
+# TRAINS - Example of tensorboard with tensorflow (without any actual training)
+#
+import os
+import tensorflow as tf
+import numpy as np
+from tempfile import gettempdir
+from PIL import Image
+
+from trains import Task
+
+
+def generate_summary(k, step):
+    # Make a normal distribution, with a shifting mean
+    mean_moving_normal = tf.random.normal(shape=[1000], mean=(5 * k), stddev=1)
+    # Record that distribution into a histogram summary
+    tf.summary.histogram("normal/moving_mean", mean_moving_normal, step=step)
+    tf.summary.scalar("normal/value", mean_moving_normal[-1], step=step)
+
+    # Make a normal distribution with shrinking variance
+    variance_shrinking_normal = tf.random.normal(shape=[1000], mean=0, stddev=1-k)
+    # Record that distribution too
+    tf.summary.histogram("normal/shrinking_variance", variance_shrinking_normal, step=step)
+    tf.summary.scalar("normal/variance_shrinking_normal", variance_shrinking_normal[-1], step=step)
+
+    # Let's combine both of those distributions into one dataset
+    normal_combined = tf.concat([mean_moving_normal, variance_shrinking_normal], 0)
+    # We add another histogram summary to record the combined distribution
+    tf.summary.histogram("normal/bimodal", normal_combined, step=step)
+    tf.summary.scalar("normal/normal_combined", normal_combined[0], step=step)
+
+    # Add a gamma distribution
+    gamma = tf.random.gamma(shape=[1000], alpha=k)
+    tf.summary.histogram("gamma", gamma, step=step)
+
+    # And a poisson distribution
+    poisson = tf.random.poisson(shape=[1000], lam=k)
+    tf.summary.histogram("poisson", poisson, step=step)
+
+    # And a uniform distribution
+    uniform = tf.random.uniform(shape=[1000], maxval=k*10)
+    tf.summary.histogram("uniform", uniform, step=step)
+
+    # Finally, combine everything together!
+    all_distributions = [mean_moving_normal, variance_shrinking_normal, gamma, poisson, uniform]
+    all_combined = tf.concat(all_distributions, 0)
+    tf.summary.histogram("all_combined", all_combined, step=step)
+
+    # Log text value
+    tf.summary.text("this is a test", "This is the content", step=step)
+
+    # convert to 4d [batch, col, row, RGB-channels]
+    image_open = Image.open(os.path.join('..', '..', 'reporting', 'data_samples', 'picasso.jpg'))
+    image = np.asarray(image_open)
+    image_gray = image[:, :, 0][np.newaxis, :, :, np.newaxis]
+    image_rgba = np.concatenate((image, 255*np.atleast_3d(np.ones(shape=image.shape[:2], dtype=np.uint8))), axis=2)
+    image_rgba = image_rgba[np.newaxis, :, :, :]
+    image = image[np.newaxis, :, :, :]
+
+    tf.summary.image("test", image, max_outputs=10, step=step)
+    tf.summary.image("test_gray", image_gray, max_outputs=10, step=step)
+    tf.summary.image("test_rgba", image_rgba, max_outputs=10, step=step)
+
+
+task = Task.init(project_name='examples', task_name='tensorboard toy example')
+
+# create the tensorboard file writer in a temp folder
+writer = tf.summary.create_file_writer(os.path.join(gettempdir(), "toy_tb_example"))
+
+# Setup a loop and write the summaries to disk
+N = 40
+for step in range(N):
+    k_val = step/float(N)
+    with writer.as_default():
+        generate_summary(k_val, tf.cast(step, tf.int64))
+
+print('Tensorboard toy example done')

examples/frameworks/tensorflow/tensorflow_mnist.py

@@ -0,0 +1,134 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import os
+from tempfile import gettempdir
+
+import tensorflow as tf
+
+from tensorflow.keras.layers import Dense, Flatten, Conv2D
+from tensorflow.keras import Model
+
+from trains import Task
+
+
+task = Task.init(project_name='examples',
+                 task_name='Tensorflow v2 mnist with summaries')
+
+
+# Load and prepare the MNIST dataset.
+mnist = tf.keras.datasets.mnist
+
+(x_train, y_train), (x_test, y_test) = mnist.load_data()
+x_train, x_test = x_train / 255.0, x_test / 255.0
+
+# Add a channels dimension
+x_train = x_train[..., tf.newaxis].astype('float32')
+x_test = x_test[..., tf.newaxis].astype('float32')
+
+# Use tf.data to batch and shuffle the dataset
+train_ds = tf.data.Dataset.from_tensor_slices((x_train, y_train)).shuffle(10000).batch(32)
+test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)
+
+
+# Build the tf.keras model using the Keras model subclassing API
+class MyModel(Model):
+    def __init__(self):
+        super(MyModel, self).__init__()
+        self.conv1 = Conv2D(32, 3, activation='relu', dtype=tf.float32)
+        self.flatten = Flatten()
+        self.d1 = Dense(128, activation='relu', dtype=tf.float32)
+        self.d2 = Dense(10, activation='softmax', dtype=tf.float32)
+
+    def call(self, x):
+        x = self.conv1(x)
+        x = self.flatten(x)
+        x = self.d1(x)
+        return self.d2(x)
+
+
+# Create an instance of the model
+model = MyModel()
+
+# Choose an optimizer and loss function for training
+loss_object = tf.keras.losses.SparseCategoricalCrossentropy()
+optimizer = tf.keras.optimizers.Adam()
+
+# Select metrics to measure the loss and the accuracy of the model.
+# These metrics accumulate the values over epochs and then print the overall result.
+train_loss = tf.keras.metrics.Mean(name='train_loss', dtype=tf.float32)
+train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')
+
+test_loss = tf.keras.metrics.Mean(name='test_loss', dtype=tf.float32)
+test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')
+
+
+# Use tf.GradientTape to train the model
+@tf.function
+def train_step(images, labels):
+    with tf.GradientTape() as tape:
+        predictions = model(images)
+        loss = loss_object(labels, predictions)
+    gradients = tape.gradient(loss, model.trainable_variables)
+    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
+
+    train_loss(loss)
+    train_accuracy(labels, predictions)
+
+
+# Test the model
+@tf.function
+def test_step(images, labels):
+    predictions = model(images)
+    t_loss = loss_object(labels, predictions)
+
+    test_loss(t_loss)
+    test_accuracy(labels, predictions)
+
+
+# Set up summary writers to write the summaries to disk in a different logs directory
+train_log_dir = os.path.join(gettempdir(), 'logs', 'gradient_tape', 'train')
+test_log_dir = os.path.join(gettempdir(), 'logs', 'gradient_tape', 'test')
+train_summary_writer = tf.summary.create_file_writer(train_log_dir)
+test_summary_writer = tf.summary.create_file_writer(test_log_dir)
+
+# Set up checkpoints manager
+ckpt = tf.train.Checkpoint(step=tf.Variable(1), optimizer=optimizer, net=model)
+manager = tf.train.CheckpointManager(ckpt, os.path.join(gettempdir(), 'tf_ckpts'), max_to_keep=3)
+ckpt.restore(manager.latest_checkpoint)
+if manager.latest_checkpoint:
+    print("Restored from {}".format(manager.latest_checkpoint))
+else:
+    print("Initializing from scratch.")
+
+# Start training
+EPOCHS = 5
+for epoch in range(EPOCHS):
+    for images, labels in train_ds:
+        train_step(images, labels)
+        with train_summary_writer.as_default():
+            tf.summary.scalar('loss', train_loss.result(), step=epoch)
+            tf.summary.scalar('accuracy', train_accuracy.result(), step=epoch)
+
+    ckpt.step.assign_add(1)
+    if int(ckpt.step) % 1 == 0:
+        save_path = manager.save()
+        print("Saved checkpoint for step {}: {}".format(int(ckpt.step), save_path))
+
+    for test_images, test_labels in test_ds:
+        test_step(test_images, test_labels)
+        with test_summary_writer.as_default():
+            tf.summary.scalar('loss', test_loss.result(), step=epoch)
+            tf.summary.scalar('accuracy', test_accuracy.result(), step=epoch)
+
+    template = 'Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, Test Accuracy: {}'
+    print(template.format(epoch+1,
+                          train_loss.result(),
+                          train_accuracy.result()*100,
+                          test_loss.result(),
+                          test_accuracy.result()*100))
+
+    # Reset the metrics for the next epoch
+    train_loss.reset_states()
+    train_accuracy.reset_states()
+    test_loss.reset_states()
+    test_accuracy.reset_states()

examples/frameworks/xgboost/requirements.txt

@@ -0,0 +1,6 @@
+sklearn
+trains
+xgboost>=0.90 ; python_version >= '3'
+xgboost>=0.82 ; python_version < '3'
+# sudo apt-get install graphviz
+graphviz>=0.8

examples/frameworks/xgboost/xgboost_sample.py

@@ -0,0 +1,60 @@
+import matplotlib.pyplot as plt
+import xgboost as xgb
+from sklearn import datasets
+from sklearn.metrics import accuracy_score
+from sklearn.model_selection import train_test_split
+from xgboost import plot_tree
+
+from trains import Task
+
+task = Task.init(project_name='examples', task_name='XGBoost simple example')
+iris = datasets.load_iris()
+X = iris.data
+y = iris.target
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+dtrain = xgb.DMatrix(X_train, label=y_train)
+dtest = xgb.DMatrix(X_test, label=y_test)
+param = {
+    'max_depth': 3,  # the maximum depth of each tree
+    'eta': 0.3,  # the training step for each iteration
+    'silent': 1,  # logging mode - quiet
+    'objective': 'multi:softprob',  # error evaluation for multiclass training
+    'num_class': 3}  # the number of classes that exist in this datset
+num_round = 20  # the number of training iterations
+
+# noinspection PyBroadException
+try:
+    # try to load a model
+    bst = xgb.Booster(params=param, model_file='xgb.01.model')
+    bst.load_model('xgb.01.model')
+except Exception:
+    bst = None
+
+# if we dont have one train a model
+if bst is None:
+    bst = xgb.train(param, dtrain, num_round)
+
+# store trained model model v1
+bst.save_model('xgb.01.model')
+bst.dump_model('xgb.01.raw.txt')
+
+# build classifier
+model = xgb.XGBClassifier()
+model.fit(X_train, y_train)
+
+# store trained classifier model
+model.save_model('xgb.02.model')
+
+# make predictions for test data
+y_pred = model.predict(X_test)
+predictions = [round(value) for value in y_pred]
+
+# evaluate predictions
+accuracy = accuracy_score(y_test, predictions)
+print("Accuracy: %.2f%%" % (accuracy * 100.0))
+labels = dtest.get_label()
+
+# plot results
+xgb.plot_importance(model)
+plot_tree(model)
+plt.show()