Parabolic Plotting.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hd\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "import importlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = tf.constant(0.2, dtype=tf.float64)\n",
    "n_points = 1024"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "sess = tf.Session(config=config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ratios: \t [ 8.          8.0006876   8.00081633 ... 15.98011364 15.99862491\n",
      " 16.        ]\n",
      "Log-2 Ratios: \t [3.         3.00012399 3.00014721 ... 3.99820576 3.99987601 4.        ]\n"
     ]
    }
   ],
   "source": [
    "# We're just calculating the unison, fourth, fifth, octave\n",
    "vectors = hd.vectors.space_graph(5, 5, bounds=(3.0, 4.0))\n",
    "vecs = sess.run(vectors)\n",
    "ratios = np.sort(np.prod(hd.PRIMES[:vectors.shape[-1]] ** vecs, axis=1))\n",
    "# Print out the logs of the vectors\n",
    "print(\"Ratios: \\t\", ratios)\n",
    "print(\"Log-2 Ratios: \\t\", np.log2(ratios))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3543, 5)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vecs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[-5., -5., -5.,  4.,  5.],\n",
       "        [-5., -5., -5.,  4.,  5.]],\n",
       "\n",
       "       [[-5., -5., -5.,  4.,  5.],\n",
       "        [-5., -5., -5.,  5.,  4.]],\n",
       "\n",
       "       [[-5., -5., -5.,  4.,  5.],\n",
       "        [-5., -5., -4.,  3.,  5.]],\n",
       "\n",
       "       ...,\n",
       "\n",
       "       [[ 5.,  5.,  5., -5., -2.],\n",
       "        [ 5.,  5.,  3., -1., -4.]],\n",
       "\n",
       "       [[ 5.,  5.,  5., -5., -2.],\n",
       "        [ 5.,  5.,  4., -3., -3.]],\n",
       "\n",
       "       [[ 5.,  5.,  5., -5., -2.],\n",
       "        [ 5.,  5.,  5., -5., -2.]]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tensor for the permutations of unison, fourth, fifth, octave\n",
    "perms = hd.cartesian.permutations(np.vstack(vecs), times=2)\n",
    "sess.run(perms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "pds = hd.tenney.pd_aggregate_graph(perms)\n",
    "hds = hd.tenney.hd_aggregate_graph(perms) + 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.variable_scope(\"default\", reuse=tf.AUTO_REUSE):\n",
    "    log_pitches = tf.get_variable(\"log_pitches\", [n_points, 2], dtype=tf.float64)\n",
    "    init_op = tf.global_variables_initializer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "xs = np.linspace(0.0, 1.0, n_points)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def z_calc(pds, hds, log_pitches, a=1.0, b=1.0):\n",
    "    \"\"\"\n",
    "    pds: Pitch distance coordinate values of each vector in the space\n",
    "    hds: Aggregate harmonic distance values of each vector in the space\n",
    "    log_pitches: The set of pitches to evaluate\n",
    "    \"\"\"\n",
    "    distances = tf.map_fn(lambda x: hd.utilities.reduce_parabola(pds - x, a=a, b=b), log_pitches)\n",
    "    return tf.reduce_min(distances * hds + hds, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def assign_coords_and_return(slice_level, a=1.0, b=1.0):\n",
    "    \"\"\"\n",
    "    Given a y-level (in a 2-dimensional space), take a slice of it with a xs.\n",
    "    \"\"\"\n",
    "    xy_coords = np.hstack([xs[:, None], np.full_like(xs, slice_level)[:, None]])\n",
    "    z_op = z_calc(pds, hds, tf.constant(xy_coords, dtype=tf.float64), a=a, b=b)\n",
    "    zs = sess.run(z_op)\n",
    "    plt.ylim(0.0, 30.0)\n",
    "    for x in sess.run(pds):\n",
    "        plt.axvline(x=x[0])\n",
    "    plt.plot(xs, zs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "assign_coords_and_return(np.log2(3.0), a=C, b=C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2-dimensional optimization\n",
    "\n",
    "Setting out the batch sizes, etc.\n",
    "\n",
    "We're reusing the vectors etc. from above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "C = 0.02\n",
    "LEARNING_RATE = 1.0e-3\n",
    "CONVERGENCE_THRESHOLD = 1.0e-8\n",
    "MAX_ITERS = 1000000\n",
    "DIMENSIONS = 2\n",
    "BATCH_SIZE = 512\n",
    "POINTS_PER_DIMENSION = 64\n",
    "xs = np.linspace(0.00, 1.0, POINTS_PER_DIMENSION)\n",
    "ys = np.linspace(0.00, 1.0, POINTS_PER_DIMENSION)\n",
    "xv, yv = np.meshgrid(xs, ys, sparse=False)\n",
    "zv = np.array([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.variable_scope(\"2d_optimization\", reuse=tf.AUTO_REUSE):\n",
    "    log_pitches = tf.get_variable(\"log_pitches_64x512\", [BATCH_SIZE, DIMENSIONS], dtype=tf.float64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "sess.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = z_calc(pds, hds, log_pitches, a=C, b=C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "stopping_op = hd.optimize.stopping_op(loss, [log_pitches], lr=LEARNING_RATE, ct=CONVERGENCE_THRESHOLD)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creates a vector of pairs of shape [n_points**dimensions, dimensions]\n",
    "starting_coordinates = np.array([xv, yv]).reshape(DIMENSIONS, POINTS_PER_DIMENSION**DIMENSIONS).T\n",
    "starting_dataset = tf.data.Dataset.from_tensor_slices({\n",
    "    \"coords\": tf.constant(starting_coordinates)\n",
    "})\n",
    "starting_iterator = starting_dataset.batch(BATCH_SIZE).make_one_shot_iterator()\n",
    "next_element = starting_iterator.get_next()\n",
    "assign_op = log_pitches.assign(next_element['coords'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_possible_pitches_log = np.empty([0, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converged at iteration:  184\n",
      "Converged at iteration:  209\n",
      "Converged at iteration:  216\n",
      "Converged at iteration:  211\n",
      "Converged at iteration:  199\n",
      "Converged at iteration:  207\n",
      "Converged at iteration:  201\n",
      "Converged at iteration:  187\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    try:\n",
    "        sess.run([assign_op])\n",
    "        for idx in range(MAX_ITERS):\n",
    "            if (sess.run(stopping_op)):\n",
    "                print(\"Converged at iteration: \", idx)\n",
    "                out_pitches = np.array(sess.run(log_pitches))\n",
    "                all_possible_pitches_log = np.concatenate([all_possible_pitches_log, out_pitches])\n",
    "                break\n",
    "    except tf.errors.OutOfRangeError:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.00000000e+00, 0.00000000e+00],\n",
       "       [1.87200106e-20, 0.00000000e+00],\n",
       "       [3.74400212e-20, 0.00000000e+00],\n",
       "       ...,\n",
       "       [1.00000000e+00, 1.00000000e+00],\n",
       "       [1.00000000e+00, 1.00000000e+00],\n",
       "       [1.00000000e+00, 1.00000000e+00]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_possible_pitches_log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4096, 2)\n",
      "[[0.00000000e+00 0.00000000e+00]\n",
      " [1.87200106e-20 0.00000000e+00]\n",
      " [3.74400212e-20 0.00000000e+00]\n",
      " ...\n",
      " [1.00000000e+00 1.00000000e+00]\n",
      " [1.00000000e+00 1.00000000e+00]\n",
      " [1.00000000e+00 1.00000000e+00]]\n",
      "[[[0. 0. 0.]\n",
      "  [0. 0. 0.]]\n",
      "\n",
      " [[0. 0. 0.]\n",
      "  [0. 0. 0.]]\n",
      "\n",
      " [[0. 0. 0.]\n",
      "  [0. 0. 0.]]\n",
      "\n",
      " ...\n",
      "\n",
      " [[1. 0. 0.]\n",
      "  [1. 0. 0.]]\n",
      "\n",
      " [[1. 0. 0.]\n",
      "  [1. 0. 0.]]\n",
      "\n",
      " [[1. 0. 0.]\n",
      "  [1. 0. 0.]]]\n",
      "20\n",
      "[((1.0, 1.0), (1.0, 1.0)), ((1.0, 1.0), (5.0, 4.0)), ((1.0, 1.0), (4.0, 3.0)), ((1.0, 1.0), (3.0, 2.0)), ((1.0, 1.0), (5.0, 3.0)), ((1.0, 1.0), (2.0, 1.0)), ((5.0, 4.0), (1.0, 1.0)), ((5.0, 4.0), (5.0, 4.0)), ((4.0, 3.0), (1.0, 1.0)), ((4.0, 3.0), (4.0, 3.0)), ((4.0, 3.0), (2.0, 1.0)), ((3.0, 2.0), (1.0, 1.0)), ((3.0, 2.0), (3.0, 2.0)), ((3.0, 2.0), (2.0, 1.0)), ((5.0, 3.0), (1.0, 1.0)), ((5.0, 3.0), (5.0, 3.0)), ((2.0, 1.0), (1.0, 1.0)), ((2.0, 1.0), (4.0, 3.0)), ((2.0, 1.0), (3.0, 2.0)), ((2.0, 1.0), (2.0, 1.0))]\n"
     ]
    }
   ],
   "source": [
    "print(all_possible_pitches_log.shape)\n",
    "log_vectors = hd.vectors.pd_graph(vectors)\n",
    "\n",
    "print(all_possible_pitches_log)\n",
    "diffs_to_poles = tf.abs(tf.tile(log_vectors[:, None, None], [1, 1, 2]) - all_possible_pitches_log)\n",
    "mins = tf.argmin(diffs_to_poles, axis=0)\n",
    "winner = tf.map_fn(lambda m: tf.map_fn(lambda v: vectors[v], m, dtype=tf.float64), mins, dtype=tf.float64)\n",
    "winners = sess.run(winner)\n",
    "print(winners)\n",
    "\n",
    "def vector_to_ratio(vector):\n",
    "    primes = hd.PRIMES[:vector.shape[0]]\n",
    "    num = np.where(vector > 0, vector, np.zeros_like(primes))\n",
    "    den = np.where(vector < 0, vector, np.zeros_like(primes))\n",
    "    return (\n",
    "        np.product(np.power(primes, num)), \n",
    "        np.product(primes ** np.abs(den))\n",
    "    )\n",
    "\n",
    "all_possible_pitches = set()\n",
    "\n",
    "for row in winners:\n",
    "    all_possible_pitches.add(tuple([vector_to_ratio(r) for r in row]))\n",
    "\n",
    "print(len(all_possible_pitches))\n",
    "print(sorted(all_possible_pitches, key=lambda r: (r[0][0] / r[0][1], r[1][0] / r[1][1])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}