04_render_performance.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Basis Mixer!\n",
    "\n",
    "The previous notebooks explored the individual components of the Basis Function Models. In this notebook we will put everything together to render an expressive performance of a piece given its score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from partitura import save_performance_midi, load_musicxml\n",
    "from partitura.score import expand_grace_notes\n",
    "\n",
    "from basismixer.performance_codec import get_performance_codec\n",
    "from helper import load_model, compute_basis_from_xml\n",
    "from helper.rendering import (post_process_predictions, \n",
    "                              path_to_trained_models)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0. Select a piece and trained models\n",
    "We start by defining the piece we want to render (here is an example MusicXML file, but you can set your own!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xml_fn = './sample_data/musicxml/Mozart_K265_1.musicxml'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we set the path to the directory of the trained models from our previous notebook (or any other trained models). Following the directory structure from the previous notebook, each"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# models_dir = path_to_trained_models() # your trained model\n",
    "models_dir = './sample_data/models' # pretrained model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Load the Predictive Model\n",
    "\n",
    "The function `load_model` looks for the configuration files and the saved model parameters in `models_dir`. This function will return an instance of `FullPredictiveModel`, which is a conveniece *meta-model* which contains a list of the individual models (in `model.models`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "model, predicted_parameter_names = load_model(models_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If you want to modify any of these default values just do\n",
    "# model.default_values['parameter_name'] = value\n",
    "# For example, for making the performance slower\n",
    "beats_per_minute = 100\n",
    "model.default_values['beat_period_mean'] = 60.0 / beats_per_minute\n",
    "model.default_values['beat_period_std'] = 0.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Computing the Score Representation.\n",
    "\n",
    "We load the input MusicXML file specified above and compute the input score representation using the Basis Functions specified by the model (in `model.input_names`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load MusicXML file\n",
    "basis, part = compute_basis_from_xml(xml_fn, model.input_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Make Predict Performance\n",
    "\n",
    "We make predictions of the performance using the models. , The `predict` method of `FullPredictiveModel` combines the predictions of the individual predictive models into a single output structured array, where the field names are the output parameters (specified in `model.output_names`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = model.predict(basis, part.note_array['onset'])\n",
    "post_process_predictions(preds)\n",
    "print('Field names:', preds.dtype.names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Decode predictions\n",
    "\n",
    "Finally, we decode the predictions using a `PerformanceCodec` and export the performance as a MIDI file. The output of the `decode` method is an instance of `partitura.performance.PerformedPart`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "perf_codec = get_performance_codec(model.output_names)\n",
    "predicted_ppart = perf_codec.decode(part, preds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can export the predictions of the model as a MIDI file!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "midi_fn = 'my_midi_output.mid'\n",
    "save_performance_midi(predicted_ppart, midi_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from helper.rendering import render_midi\n",
    "\n",
    "render_midi(midi_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "from helper.plotting import plot_predictions\n",
    "plot_predictions(preds, part.note_array['onset'], \n",
    "                 predicted_parameter_names)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}