notebooks/music_generation_training_nottingham.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pretty_midi\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.autograd import Variable\n",
    "import torch.utils.data as data\n",
    "import os\n",
    "import random\n",
    "\n",
    "import sys\n",
    "\n",
    "# Download midi library from here: http://deeplearning.net/tutorial/rnnrbm.html\n",
    "# and do sysn.path.append with it, like below.\n",
    "# Direct link: http://www.iro.umontreal.ca/~lisa/deep/midi.zip\n",
    "sys.path.append(\"/home/daniil/projects/rnns/midi/\")\n",
    "\n",
    "from utils import midiread, midiwrite\n",
    "\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = '0'\n",
    "\n",
    "\n",
    "def midi_filename_to_piano_roll(midi_filename):\n",
    "    \n",
    "    midi_data = midiread(midi_filename, dt=0.3)\n",
    "    \n",
    "    piano_roll = midi_data.piano_roll.transpose()\n",
    "    \n",
    "    # Binarize the pressed notes\n",
    "    piano_roll[piano_roll > 0] = 1\n",
    "    \n",
    "    return piano_roll\n",
    "\n",
    "\n",
    "def pad_piano_roll(piano_roll, max_length=132333, pad_value=0):\n",
    "    \n",
    "    # We hardcode 128 -- because we will always use only\n",
    "    # 128 pitches\n",
    "    \n",
    "    original_piano_roll_length = piano_roll.shape[1]\n",
    "    \n",
    "    padded_piano_roll = np.zeros((88, max_length))\n",
    "    padded_piano_roll[:] = pad_value\n",
    "    \n",
    "    padded_piano_roll[:, :original_piano_roll_length] = piano_roll\n",
    "\n",
    "    return padded_piano_roll\n",
    "\n",
    "\n",
    "class NotesGenerationDataset(data.Dataset):\n",
    "    \n",
    "    def __init__(self, midi_folder_path, longest_sequence_length=1491):\n",
    "        \n",
    "        self.midi_folder_path = midi_folder_path\n",
    "        \n",
    "        midi_filenames = os.listdir(midi_folder_path)\n",
    "        \n",
    "        self.longest_sequence_length = longest_sequence_length\n",
    "        \n",
    "        midi_full_filenames = map(lambda filename: os.path.join(midi_folder_path, filename),\n",
    "                                  midi_filenames)\n",
    "        \n",
    "        self.midi_full_filenames = midi_full_filenames\n",
    "        \n",
    "        if longest_sequence_length is None:\n",
    "            \n",
    "            self.update_the_max_length()\n",
    "    \n",
    "    \n",
    "    def update_the_max_length(self):\n",
    "        \"\"\"Recomputes the longest sequence constant of the dataset.\n",
    "\n",
    "        Reads all the midi files from the midi folder and finds the max\n",
    "        length.\n",
    "        \"\"\"\n",
    "        \n",
    "        sequences_lengths = map(lambda filename: midi_filename_to_piano_roll(filename).shape[1],\n",
    "                                self.midi_full_filenames)\n",
    "        \n",
    "        max_length = max(sequences_lengths)\n",
    "        \n",
    "        self.longest_sequence_length = max_length\n",
    "                \n",
    "    \n",
    "    def __len__(self):\n",
    "        \n",
    "        return len(self.midi_full_filenames)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        \n",
    "        midi_full_filename = self.midi_full_filenames[index]\n",
    "        \n",
    "        piano_roll = midi_filename_to_piano_roll(midi_full_filename)\n",
    "        \n",
    "        # -1 because we will shift it\n",
    "        sequence_length = piano_roll.shape[1] - 1\n",
    "        \n",
    "        # Shifted by one time step\n",
    "        input_sequence = piano_roll[:, :-1]\n",
    "        ground_truth_sequence = piano_roll[:, 1:]\n",
    "                \n",
    "        # pad sequence so that all of them have the same lenght\n",
    "        # Otherwise the batching won't work\n",
    "        input_sequence_padded = pad_piano_roll(input_sequence, max_length=self.longest_sequence_length)\n",
    "        \n",
    "        ground_truth_sequence_padded = pad_piano_roll(ground_truth_sequence,\n",
    "                                                      max_length=self.longest_sequence_length,\n",
    "                                                      pad_value=-100)\n",
    "                \n",
    "        input_sequence_padded = input_sequence_padded.transpose()\n",
    "        ground_truth_sequence_padded = ground_truth_sequence_padded.transpose()\n",
    "        \n",
    "        return (torch.FloatTensor(input_sequence_padded),\n",
    "                torch.LongTensor(ground_truth_sequence_padded),\n",
    "                torch.LongTensor([sequence_length]) )\n",
    "\n",
    "    \n",
    "def post_process_sequence_batch(batch_tuple):\n",
    "    \n",
    "    input_sequences, output_sequences, lengths = batch_tuple\n",
    "    \n",
    "    splitted_input_sequence_batch = input_sequences.split(split_size=1)\n",
    "    splitted_output_sequence_batch = output_sequences.split(split_size=1)\n",
    "    splitted_lengths_batch = lengths.split(split_size=1)\n",
    "\n",
    "    training_data_tuples = zip(splitted_input_sequence_batch,\n",
    "                               splitted_output_sequence_batch,\n",
    "                               splitted_lengths_batch)\n",
    "\n",
    "    training_data_tuples_sorted = sorted(training_data_tuples,\n",
    "                                         key=lambda p: int(p[2]),\n",
    "                                         reverse=True)\n",
    "\n",
    "    splitted_input_sequence_batch, splitted_output_sequence_batch, splitted_lengths_batch = zip(*training_data_tuples_sorted)\n",
    "\n",
    "    input_sequence_batch_sorted = torch.cat(splitted_input_sequence_batch)\n",
    "    output_sequence_batch_sorted = torch.cat(splitted_output_sequence_batch)\n",
    "    lengths_batch_sorted = torch.cat(splitted_lengths_batch)\n",
    "    \n",
    "    # Here we trim overall data matrix using the size of the longest sequence\n",
    "    input_sequence_batch_sorted = input_sequence_batch_sorted[:, :lengths_batch_sorted[0, 0], :]\n",
    "    output_sequence_batch_sorted = output_sequence_batch_sorted[:, :lengths_batch_sorted[0, 0], :]\n",
    "    \n",
    "    input_sequence_batch_transposed = input_sequence_batch_sorted.transpose(0, 1)\n",
    "    \n",
    "    # pytorch's api for rnns wants lenghts to be list of ints\n",
    "    lengths_batch_sorted_list = list(lengths_batch_sorted)\n",
    "    lengths_batch_sorted_list = map(lambda x: int(x), lengths_batch_sorted_list)\n",
    "    \n",
    "    return input_sequence_batch_transposed, output_sequence_batch_sorted, lengths_batch_sorted_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "trainset = NotesGenerationDataset('Nottingham/train/')\n",
    "\n",
    "trainset_loader = torch.utils.data.DataLoader(trainset, batch_size=120,\n",
    "                                              shuffle=True, num_workers=4, drop_last=True)\n",
    "\n",
    "valset = NotesGenerationDataset('Nottingham/valid/', longest_sequence_length=None)\n",
    "\n",
    "valset_loader = torch.utils.data.DataLoader(valset, batch_size=30, shuffle=False, num_workers=4, drop_last=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class RNN(nn.Module):\n",
    "    \n",
    "    def __init__(self, input_size, hidden_size, num_classes, n_layers=2):\n",
    "        \n",
    "        super(RNN, self).__init__()\n",
    "        \n",
    "        self.input_size = input_size\n",
    "        self.hidden_size = hidden_size\n",
    "        self.num_classes = num_classes\n",
    "        self.n_layers = n_layers\n",
    "        \n",
    "        self.notes_encoder = nn.Linear(in_features=input_size, out_features=hidden_size)\n",
    "        \n",
    "        self.lstm = nn.LSTM(hidden_size, hidden_size, n_layers)\n",
    "        \n",
    "        self.logits_fc = nn.Linear(hidden_size, num_classes)\n",
    "    \n",
    "    \n",
    "    def forward(self, input_sequences, input_sequences_lengths, hidden=None):\n",
    "        \n",
    "        batch_size = input_sequences.shape[1]\n",
    "\n",
    "        notes_encoded = self.notes_encoder(input_sequences)\n",
    "        \n",
    "        # Here we run rnns only on non-padded regions of the batch\n",
    "        packed = torch.nn.utils.rnn.pack_padded_sequence(notes_encoded, input_sequences_lengths)\n",
    "        outputs, hidden = self.lstm(packed, hidden)\n",
    "        outputs, output_lengths = torch.nn.utils.rnn.pad_packed_sequence(outputs) # unpack (back to padded)\n",
    "        \n",
    "        logits = self.logits_fc(outputs)\n",
    "                \n",
    "        logits = logits.transpose(0, 1).contiguous()\n",
    "        \n",
    "        neg_logits = (1 - logits)\n",
    "        \n",
    "        # Since the BCE loss doesn't support masking, we use the crossentropy\n",
    "        binary_logits = torch.stack((logits, neg_logits), dim=3).contiguous()\n",
    "        \n",
    "        logits_flatten = binary_logits.view(-1, 2)\n",
    "        \n",
    "        return logits_flatten, hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "rnn = RNN(input_size=88, hidden_size=512, num_classes=88)\n",
    "rnn = rnn.cuda()\n",
    "\n",
    "criterion = nn.CrossEntropyLoss().cuda()\n",
    "\n",
    "criterion_val = nn.CrossEntropyLoss(size_average=False).cuda()\n",
    "\n",
    "learning_rate = 0.001\n",
    "optimizer = torch.optim.Adam(rnn.parameters(), lr=learning_rate)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overriden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "\n",
    "import sys, os\n",
    "sys.path.append(\"/home/daniil/repos/pytorch-segmentation-detection/\")\n",
    "sys.path.insert(0, '/home/daniil/repos/pytorch-segmentation-detection/vision/')\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "# importing a list that can be binded with a figure and update\n",
    "# the figure when being appended\n",
    "from pytorch_segmentation_detection.utils.visualization import VizList\n",
    "\n",
    "# Creating figure, axes and binding to lists \n",
    "f, (loss_axis, validation_axis) = plt.subplots(2, 1)\n",
    "\n",
    "loss_axis.plot([], [])\n",
    "validation_axis.plot([], [])\n",
    "\n",
    "loss_list = VizList()\n",
    "val_list = VizList()\n",
    "\n",
    "loss_list.bind_to_axis(loss_axis)\n",
    "val_list.bind_to_axis(validation_axis)\n",
    "\n",
    "loss_axis.set_title('Training Loss')\n",
    "validation_axis.set_title('Validation Loss')\n",
    "\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def validate():\n",
    "\n",
    "    full_val_loss = 0.0\n",
    "    overall_sequence_length = 0.0\n",
    "\n",
    "    for batch in valset_loader:\n",
    "\n",
    "        post_processed_batch_tuple = post_process_sequence_batch(batch)\n",
    "\n",
    "        input_sequences_batch, output_sequences_batch, sequences_lengths = post_processed_batch_tuple\n",
    "\n",
    "        output_sequences_batch_var =  Variable( output_sequences_batch.contiguous().view(-1).cuda() )\n",
    "\n",
    "        input_sequences_batch_var = Variable( input_sequences_batch.cuda() )\n",
    "\n",
    "        logits, _ = rnn(input_sequences_batch_var, sequences_lengths)\n",
    "\n",
    "        loss = criterion_val(logits, output_sequences_batch_var)\n",
    "\n",
    "        full_val_loss += loss.data[0]\n",
    "        overall_sequence_length += sum(sequences_lengths)\n",
    "\n",
    "    return full_val_loss / (overall_sequence_length * 88)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Process Process-33619:\n",
      "Process Process-33620:\n",
      "Process Process-33617:\n",
      "Process Process-33618:\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/multiprocessing/process.py\", line 267, in _bootstrap\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/multiprocessing/process.py\", line 267, in _bootstrap\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/multiprocessing/process.py\", line 267, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/multiprocessing/process.py\", line 267, in _bootstrap\n",
      "    self.run()\n",
      "    self.run()\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/multiprocessing/process.py\", line 114, in run\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/multiprocessing/process.py\", line 114, in run\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/multiprocessing/process.py\", line 114, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "    self.run()\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/site-packages/torch/utils/data/dataloader.py\", line 36, in _worker_loop\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/site-packages/torch/utils/data/dataloader.py\", line 36, in _worker_loop\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/site-packages/torch/utils/data/dataloader.py\", line 36, in _worker_loop\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/multiprocessing/process.py\", line 114, in run\n",
      "    r = index_queue.get()\n",
      "    r = index_queue.get()\n",
      "    r = index_queue.get()\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/multiprocessing/queues.py\", line 376, in get\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/multiprocessing/queues.py\", line 374, in get\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/multiprocessing/queues.py\", line 374, in get\n",
      "    return recv()\n",
      "    racquire()\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/site-packages/torch/utils/data/dataloader.py\", line 36, in _worker_loop\n",
      "    racquire()\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/site-packages/torch/multiprocessing/queue.py\", line 21, in recv\n",
      "KeyboardInterrupt\n",
      "KeyboardInterrupt\n",
      "    buf = self.recv_bytes()\n",
      "    r = index_queue.get()\n",
      "KeyboardInterrupt\n",
      "  File \"/home/daniil/repos/anaconda2/lib/python2.7/multiprocessing/queues.py\", line 374, in get\n",
      "    racquire()\n",
      "KeyboardInterrupt\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-71609b6b08f8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     22\u001b[0m         \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlogits\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_sequences_batch_var\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m         \u001b[0mloss_list\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 24\u001b[0;31m         \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     25\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     26\u001b[0m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclip_grad_norm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparameters\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclip\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/home/daniil/repos/anaconda2/lib/python2.7/site-packages/torch/autograd/variable.pyc\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph, retain_variables)\u001b[0m\n\u001b[1;32m    165\u001b[0m                 \u001b[0mVariable\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    166\u001b[0m         \"\"\"\n\u001b[0;32m--> 167\u001b[0;31m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_variables\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    168\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    169\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/home/daniil/repos/anaconda2/lib/python2.7/site-packages/torch/autograd/__init__.pyc\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(variables, grad_variables, retain_graph, create_graph, retain_variables)\u001b[0m\n\u001b[1;32m     97\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     98\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[0;32m---> 99\u001b[0;31m         variables, grad_variables, retain_graph)\n\u001b[0m\u001b[1;32m    100\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    101\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "clip = 1.0\n",
    "epochs_number = 12000000\n",
    "sample_history = []\n",
    "best_val_loss = float(\"inf\")\n",
    "\n",
    "for epoch_number in xrange(epochs_number):\n",
    "\n",
    "    for batch in trainset_loader:\n",
    "\n",
    "        post_processed_batch_tuple = post_process_sequence_batch(batch)\n",
    "\n",
    "        input_sequences_batch, output_sequences_batch, sequences_lengths = post_processed_batch_tuple\n",
    "\n",
    "        output_sequences_batch_var =  Variable( output_sequences_batch.contiguous().view(-1).cuda() )\n",
    "        \n",
    "        input_sequences_batch_var = Variable( input_sequences_batch.cuda() )\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        logits, _ = rnn(input_sequences_batch_var, sequences_lengths)\n",
    "        \n",
    "        loss = criterion(logits, output_sequences_batch_var)\n",
    "        loss_list.append( loss.data[0] )\n",
    "        loss.backward()\n",
    "        \n",
    "        torch.nn.utils.clip_grad_norm(rnn.parameters(), clip)\n",
    "\n",
    "        optimizer.step()\n",
    "    \n",
    "    \n",
    "    current_val_loss = validate()\n",
    "    val_list.append(current_val_loss)\n",
    "    \n",
    "    if current_val_loss < best_val_loss:\n",
    "        \n",
    "        torch.save(rnn.state_dict(), 'music_rnn.pth')\n",
    "        best_val_loss = current_val_loss"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}