convert-jp-f-adapt2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nThis program makes learning ev-gmm.\\n'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "\n",
    "\"\"\"\n",
    "This program makes learning ev-gmm.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# __future__ module make compatible python2 and python3\n",
    "from __future__ import division, print_function\n",
    "\n",
    "# basic modules\n",
    "import os\n",
    "import os.path\n",
    "import time\n",
    "\n",
    "# for warning ignore\n",
    "import warnings\n",
    "#warning.filterwarnings('ignore')\n",
    "\n",
    "# for file system manupulation \n",
    "from shutil import rmtree \n",
    "import glob\n",
    "import argparse\n",
    "\n",
    "# for save object\n",
    "import pickle\n",
    "\n",
    "# for make glaph\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set_style(\"whitegrid\")\n",
    "plt.rcParams['figure.figsize'] = (16, 5)\n",
    "import librosa.display\n",
    "\n",
    "# for scientific computing\n",
    "import numpy as np\n",
    "from numpy.linalg import norm \n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.mixture import GMM # GMM class cannot use after sklearn 0.20.0\n",
    "import sklearn.mixture\n",
    "#from sklearn.mixture.gaussian_mixture import _compute_precision_cholesky\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "import scipy.sparse\n",
    "from scipy.signal import firwin, lfilter\n",
    "\n",
    "# for display audio controler\n",
    "from IPython.display import Audio\n",
    "\n",
    "# for manuplate audio data\n",
    "import soundfile as sf\n",
    "import pyworld as pw\n",
    "import pysptk\n",
    "from dtw import dtw\n",
    "from fastdtw import fastdtw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WORLD(object):\n",
    "    \"\"\"\n",
    "    WORLD based speech analyzer and synthezer.\n",
    "    \n",
    "    Ref : https://github.com/k2kobayashi/sprocket/\n",
    "    \"\"\"\n",
    "    def __init__(self, fs=16000, fftl=1024, shiftms=5.0, minf0=40.0, maxf0=500.0):\n",
    "        \"\"\"\n",
    "        Parameters\n",
    "        ----------\n",
    "        fs : int \n",
    "            Sampling frequency \n",
    "        fftl : int\n",
    "            FFT length\n",
    "        shiftms : float\n",
    "            Shift length [ms]\n",
    "        minf0 : float\n",
    "            Floor in F0 estimation\n",
    "        maxf0 : float\n",
    "            Seli in F0 estimation\n",
    "        \"\"\"\n",
    "        \n",
    "        self.fs = fs\n",
    "        self.fftl = fftl\n",
    "        self.shiftms = shiftms\n",
    "        self.minf0 = minf0\n",
    "        self.maxf0 = maxf0\n",
    "        \n",
    "    def analyze(self, x):\n",
    "        \"\"\"\n",
    "        Analyze acoustic featueres.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        x : array, shape(`T`)\n",
    "            monoral speech signal in time domain\n",
    "        \n",
    "        Returns\n",
    "        ----------\n",
    "        f0 : array, shape(`T`)\n",
    "            F0 sequence\n",
    "        sp : array, shape(`T`, `fftl / 2 + 1`)\n",
    "            Spectral envelope sequence\n",
    "        ap : array, shape(`T`, `fftl / 2 + 1`)\n",
    "            aperiodicity sequence\n",
    "        \"\"\"\n",
    "        \n",
    "        f0, time_axis = pw.harvest(x, self.fs, f0_floor=self.minf0,\n",
    "                                   f0_ceil=self.maxf0, frame_period=self.shiftms)\n",
    "        sp = pw.cheaptrick(x, f0, time_axis, self.fs, fft_size=self.fftl)\n",
    "        ap = pw.d4c(x, f0, time_axis, self.fs, fft_size=self.fftl)\n",
    "        \n",
    "        assert sp.shape == ap.shape\n",
    "        \n",
    "        return f0, sp, ap\n",
    "    \n",
    "    def analyze_f0(self, x):\n",
    "        \"\"\"\n",
    "        Analyze f0.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        x : array, shape(`T`)\n",
    "            monoral speech signal in time domain\n",
    "        \n",
    "        Returns\n",
    "        ----------\n",
    "        f0 : array, shape(`T`)\n",
    "            F0 sequence\n",
    "        \"\"\"\n",
    "\n",
    "        f0, time_axis = pw.harvest(x, self.fs, f0_floor=self.minf0,\n",
    "                                   f0_ceil=self.maxf0, frame_period=self.shiftms)\n",
    "        \n",
    "        assert f0.shape == x.shape()\n",
    "        \n",
    "        return f0\n",
    "    \n",
    "    def synthesis(self, f0, sp, ap):\n",
    "        \"\"\"\n",
    "        Re-synthesizes a speech waveform from acoustic featueres.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        f0 : array, shape(`T`)\n",
    "            F0 sequence\n",
    "        sp : array, shape(`T`, `fftl / 2 + 1`)\n",
    "            Spectral envelope sequence\n",
    "        ap : array, shape(`T`, `fftl / 2 + 1`)\n",
    "            aperiodicity sequence\n",
    "        \"\"\"\n",
    "\n",
    "        return pw.synthesize(f0, sp, ap, self.fs, frame_period=self.shiftms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FeatureExtractor(object):\n",
    "    \"\"\"\n",
    "    Analyze acoustic features from a waveform.\n",
    "    \n",
    "    This class may have several types of estimeter like WORLD or STRAIGHT.\n",
    "    Default type is WORLD.\n",
    "    \n",
    "    Ref : https://github.com/k2kobayashi/sprocket/\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, analyzer='world', fs=16000, fftl=1024, \n",
    "                 shiftms=5.0, minf0=50.0, maxf0=500.0):\n",
    "        \"\"\"\n",
    "        Parameters\n",
    "        ----------\n",
    "        analyzer : str\n",
    "            Analyzer\n",
    "        fs : int \n",
    "            Sampling frequency \n",
    "        fftl : int\n",
    "            FFT length\n",
    "        shiftms : float\n",
    "            Shift length [ms]\n",
    "        minf0 : float\n",
    "            Floor in F0 estimation\n",
    "        maxf0 : float\n",
    "            Seli in F0 estimation\n",
    "        \"\"\"\n",
    "        \n",
    "        self.analyzer = analyzer\n",
    "        self.fs = fs\n",
    "        self.fftl = fftl\n",
    "        self.shiftms = shiftms\n",
    "        self.minf0 = minf0\n",
    "        self.maxf0 = maxf0\n",
    "    \n",
    "        if self.analyzer == 'world':\n",
    "            self.analyzer = WORLD(fs=self.fs, fftl=self.fftl, \n",
    "                                  minf0=self.minf0, maxf0=self.maxf0, shiftms=self.shiftms)\n",
    "        else:\n",
    "            raise('Analyzer Error : not support type, see FeatureExtractor class.')\n",
    "        \n",
    "        self._f0 = None\n",
    "        self._sp = None\n",
    "        self._ap = None\n",
    "        \n",
    "    def analyze(self, x):\n",
    "        \"\"\"\n",
    "        Analyze acoustic featueres.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        x : array, shape(`T`)\n",
    "            monoral speech signal in time domain\n",
    "        \n",
    "        Returns\n",
    "        ----------\n",
    "        f0 : array, shape(`T`)\n",
    "            F0 sequence\n",
    "        sp : array, shape(`T`, `fftl / 2 + 1`)\n",
    "            Spectral envelope sequence\n",
    "        ap : array, shape(`T`, `fftl / 2 + 1`)\n",
    "            aperiodicity sequence\n",
    "        \"\"\"\n",
    "        \n",
    "        self.x = np.array(x, dtype=np.float)\n",
    "        self._f0, self._sp, self._ap = self.analyzer.analyze(self.x)\n",
    "        \n",
    "        # check f0 < 0\n",
    "        self._f0[self._f0 < 0] = 0\n",
    "        \n",
    "        if np.sum(self._f0) == 0.0:\n",
    "            print(\"Warning : F0 values are all zero.\")\n",
    "        \n",
    "        return self._f0, self._sp, self._ap\n",
    "    \n",
    "    def analyze_f0(self, x):\n",
    "        \"\"\"\n",
    "        Analyze f0.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        x : array, shape(`T`)\n",
    "            monoral speech signal in time domain\n",
    "        \n",
    "        Returns\n",
    "        ----------\n",
    "        f0 : array, shape(`T`)\n",
    "            F0 sequence\n",
    "        \"\"\"\n",
    "\n",
    "        self.x = np.array(x, dtype=np.float)\n",
    "        self._f0 = self.analyzer.analyze_f0(self.x)\n",
    "\n",
    "        # check f0 < 0\n",
    "        self._f0[self._f0 < 0] = 0\n",
    "        \n",
    "        if np.sum(self._f0) == 0.0:\n",
    "            print(\"Warning : F0 values are all zero.\")\n",
    "        \n",
    "        return self._f0\n",
    "    \n",
    "    def mcep(self, dim=24, alpha=0.42):\n",
    "        \"\"\"\n",
    "        Convert mel-cepstrum sequence from spectral envelope.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        dim : int\n",
    "            mel-cepstrum dimension\n",
    "        alpha : float\n",
    "            parameter of all-path filter\n",
    "        \n",
    "        Returns\n",
    "        ----------\n",
    "        mcep : array, shape(`T`, `dim + 1`)\n",
    "            mel-cepstrum sequence\n",
    "        \"\"\"        \n",
    "        \n",
    "        self._analyzed_check()\n",
    "        \n",
    "        return pysptk.sp2mc(self._sp, dim, alpha)\n",
    "    \n",
    "    def codeap(self):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        self._analyzed_check()\n",
    "        \n",
    "        return pw.code_aperiodicity(self._ap, self.fs)\n",
    "    \n",
    "    def npow(self):\n",
    "        \"\"\"\n",
    "        Normalized power sequence from spectral envelope.\n",
    "        \n",
    "        Returns\n",
    "        ----------\n",
    "        npow : vector, shape(`T`, `1`)\n",
    "            Normalized power sequence of the given waveform\n",
    "        \"\"\"\n",
    "        \n",
    "        self._analyzed_check()\n",
    "        \n",
    "        npow = np.apply_along_axis(self._spvec2pow, 1, self._sp)\n",
    "        \n",
    "        meanpow = np.mean(npow)\n",
    "        npow = 10.0 * np.log10(npow / meanpow)\n",
    "        \n",
    "        return npow\n",
    "    \n",
    "    def _spvec2pow(self, specvec):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        fftl2 = len(specvec) - 1\n",
    "        fftl = fftl2 * 2\n",
    "        \n",
    "        power = specvec[0] + specvec[fftl2]\n",
    "        for k in range(1, fftl2):\n",
    "            power += 2.0 * specvec[k]\n",
    "        power /= fftl\n",
    "        \n",
    "        return power\n",
    "        \n",
    "    def _analyzed_check(self):\n",
    "        if self._f0 is None and self._sp is None and self._ap is None:\n",
    "            raise('Call FeatureExtractor.analyze() before this method.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Synthesizer(object):\n",
    "    \"\"\"\n",
    "    Synthesize a waveform from acoustic features.\n",
    "    \n",
    "    Ref : https://github.com/k2kobayashi/sprocket/\n",
    "    \"\"\"\n",
    "    def __init__(self, fs=16000, fftl=1024, shiftms=5.0):\n",
    "        \"\"\"\n",
    "        Parameters\n",
    "        ----------\n",
    "        fs : int \n",
    "            Sampling frequency \n",
    "        fftl : int\n",
    "            FFT length\n",
    "        shiftms : float\n",
    "            Shift length [ms]\n",
    "        \"\"\"\n",
    "        \n",
    "        self.fs = fs\n",
    "        self.fftl = fftl\n",
    "        self.shiftms = shiftms\n",
    "    \n",
    "    def synthesis(self, f0, mcep, ap, rmcep=None, alpha=0.42):\n",
    "        \"\"\"\n",
    "        Re-synthesizes a speech waveform from acoustic featueres.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        f0 : array, shape(`T`)\n",
    "            F0 sequence\n",
    "        mcep : array, shape(`T`, `dim`)\n",
    "            mel-cepstrum sequence\n",
    "        ap : array, shape(`T`, `fftl / 2 + 1`)\n",
    "            aperiodicity sequence\n",
    "        rmcep : array, shape(`T`, `dim`)\n",
    "            array of reference mel-cepstrum sequence\n",
    "        alpha : float\n",
    "            parameter of all-path filter\n",
    "            \n",
    "        Returns\n",
    "        ----------\n",
    "        wav : array,\n",
    "            syntesized waveform\n",
    "        \"\"\"\n",
    "        \n",
    "        if rmcep is not None:\n",
    "            # power modification\n",
    "            mcep = mod_power(mcep, rmcep, alpha=alpha)\n",
    "        \n",
    "        sp = pysptk.mc2sp(mcep, alpha, self.fftl)\n",
    "        wav = pw.synthesize(f0, sp, ap, self.fs, frame_period=self.shiftms)\n",
    "        \n",
    "        return wav\n",
    "        \n",
    "    def synthesis_diff(self, x, diffmcep, rmcep=None, alpha=0.42):\n",
    "        \"\"\"\n",
    "        Re-synthesizes a speech waveform from acoustic featueres.\n",
    "        filtering with a differential mel-cepstrum.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        x : array, shape(`samples`)\n",
    "            array of waveform sequence\n",
    "        diffmcep : array, shape(`T`, `dim`)\n",
    "            array of differential mel-cepstrum sequence\n",
    "        rmcep : array, shape(`T`, `dim`)\n",
    "            array of reference mel-cepstrum sequence\n",
    "        alpha : float\n",
    "            parameter of all-path filter\n",
    "            \n",
    "        Returns\n",
    "        ----------\n",
    "        wav : array,\n",
    "            syntesized waveform\n",
    "        \"\"\"      \n",
    "        \n",
    "        x = x.astype(np.float64)\n",
    "        dim = diffmcep.shape[1] - 1 \n",
    "        shiftl = int(self.fs / 1000 * self.shiftms)\n",
    "        \n",
    "        if rmcep is not None:\n",
    "            # power modification\n",
    "            diffmcep = mod_power(rmcep + diffmcep, rmcep, alpha=alpha) - rmcep        \n",
    "        \n",
    "        # mc2b = transform mel-cepstrum to MLSA digital filter coefficients.\n",
    "        b = np.apply_along_axis(pysptk.mc2b, 1, diffmcep, alpha)\n",
    "        \n",
    "        mlsa_fil = pysptk.synthesis.Synthesizer(pysptk.synthesis.MLSADF(dim, alpha=alpha),\n",
    "                                                shiftl)\n",
    "        wav = mlsa_fil.synthesis(x, b)\n",
    "        \n",
    "        return wav\n",
    "    \n",
    "    def synthesis_sp(self, f0, sp, ap):\n",
    "        \"\"\"\n",
    "        Re-synthesizes a speech waveform from acoustic featueres.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        f0 : array, shape(`T`)\n",
    "            F0 sequence\n",
    "        spc : array, shape(`T`, `dim`)\n",
    "            mel-cepstrum sequence\n",
    "        ap : array, shape(`T`, `fftl / 2 + 1`)\n",
    "            aperiodicity sequence\n",
    "            \n",
    "        Returns\n",
    "        ----------\n",
    "        wav : array,\n",
    "            syntesized waveform\n",
    "        \"\"\"      \n",
    "        \n",
    "        wav = pw.synthesize(f0, sp, ap, self.fs, frame_period=self.shiftms)\n",
    "        \n",
    "        return wav\n",
    "    \n",
    "def mod_power(cvmcep, rmcep, alpha=0.42, irlen=256):\n",
    "    \"\"\"\n",
    "    power modification based on inpuulse responce\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    cvmcep : array, shape(`T`, `dim`)\n",
    "        array of converted mel-cepstrum\n",
    "    rmcep : arraym shape(`T`, `dim`)\n",
    "        array of reference mel-cepstrum\n",
    "    alpha : float\n",
    "        parameter of all-path filter\n",
    "    irlen : int\n",
    "        Length for IIR filter\n",
    "\n",
    "    Returns\n",
    "    ----------\n",
    "    modified_cvmcep : array, shape(`T`, `dim`)\n",
    "        array of power modified converted mel-cepstrum\n",
    "    \"\"\"\n",
    "\n",
    "    if rmcep.shape != cvmcep.shape:\n",
    "        raise ValueError(\n",
    "            \"The shape of the converted and reference mel-cepstrum are different : {} / {}.format(cvmcep.shape, rmcep.shape)\"\n",
    "        )\n",
    "\n",
    "    # mc2e = Compute energy from mel-cepstrum. e-option\n",
    "    cv_e = pysptk.mc2e(cvmcep, alpha=alpha, irlen=irlen)\n",
    "    r_e = pysptk.mc2e(rmcep, alpha=alpha, irlen=irlen)\n",
    "\n",
    "    dpow = np.log(r_e / cv_e) / 2\n",
    "\n",
    "    modified_cvmcep = np.copy(cvmcep)\n",
    "    modified_cvmcep[:, 0] += dpow\n",
    "\n",
    "    return modified_cvmcep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def util methods\n",
    "def melcd(array1, array2):\n",
    "    \"\"\"\n",
    "    calculate mel-cepstrum distortion\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    array1, array2 : array, shape(`T`, `dim`) or shape(`dim`)\n",
    "        Array of original and target.\n",
    "    \n",
    "    Returns\n",
    "    ----------\n",
    "    mcd : scala, number > 0\n",
    "        Scala of mel-cepstrum distoriton\n",
    "    \"\"\"\n",
    "    if array1.shape != array2.shape:\n",
    "        raise ValueError(\n",
    "            \"The shape of both array are different : {} / {}.format(array1.shape,array2.shape)\"\n",
    "        )    \n",
    "   \n",
    "    if array1.ndim == 2:\n",
    "        diff = array1 - array2\n",
    "        mcd = 10.0 / np.log(10) * np.mean(np.sqrt(2.0 * np.sum(diff ** 2, axis=1)))\n",
    "    elif array1.ndim == 1:\n",
    "        diff = array1 - array2\n",
    "        mcd = 10.0 / np.log(10) * np.sqrt(2.0 * np.sum(diff ** 2))\n",
    "    else:\n",
    "        raise ValueError(\"Dimension mismatch.\")\n",
    "        \n",
    "    return mcd\n",
    "\n",
    "def delta(data, win=[-1.0, 1.0, 0]):\n",
    "    \"\"\"\n",
    "    calculate delta component\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    data : array, shape(`T`, `dim`)\n",
    "        Array of static matrix sequence.\n",
    "    win : array, shape(`3`)\n",
    "        The shape of window matrix.\n",
    "    \n",
    "    Returns\n",
    "    ----------\n",
    "    delta : array, shape(`T`, `dim`)\n",
    "        Array of delta matrix sequence.\n",
    "    \"\"\"\n",
    "    \n",
    "    if data.ndim == 1:\n",
    "        # change vector into 1d-array\n",
    "        T = len(data)\n",
    "        dim = data.ndim\n",
    "        data = data.reshape(T, dim)\n",
    "    else:\n",
    "        T, dim = data.shape\n",
    "    \n",
    "    win = np.array(win, dtype=np.float64)\n",
    "    delta = np.zeros((T, dim))\n",
    "    \n",
    "    delta[0] = win[0] * data[0] + win[1] * data[1]\n",
    "    delta[-1] = win[0] * data[-2] + win[1] * data[-1]\n",
    "    \n",
    "    for i in range(len(win)):\n",
    "        delta[1:T - 1] += win[i] * delta[i:T - 2 + i]\n",
    "    \n",
    "    return delta\n",
    "\n",
    "def static_delta(data, win=[-1.0, 1.0, 0]):\n",
    "    \"\"\"\n",
    "    calculate static and delta component\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    data : array, shape(`T`, `dim`)\n",
    "        Array of static matrix sequence.\n",
    "    win : array, shape(`3`)\n",
    "        The shape of window matrix.\n",
    "    \n",
    "    Returns\n",
    "    ----------\n",
    "    sddata : array, shape(`T`, `dim * 2`)\n",
    "        Array of static and delta matrix sequence.\n",
    "    \"\"\"\n",
    "    \n",
    "    sddata = np.c_[data, delta(data, win)]\n",
    "    \n",
    "    assert sddata.shape[1] == data.shape[1] * 2\n",
    "    \n",
    "    return sddata\n",
    "\n",
    "def construct_static_and_delta_matrix(T, D, win=[-1.0, 1.0, 0]):\n",
    "    \"\"\"\n",
    "    calculate static and delta transformation matrix\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    T : scala, `T`\n",
    "        Scala of time length\n",
    "    D : scala, `D`\n",
    "        Scala of the number of dimension.\n",
    "    win : array, shape(`3`)\n",
    "        The shape of window matrix.\n",
    "    \n",
    "    Returns\n",
    "    ----------\n",
    "    W : array, shape(`2 * D * T`, `D * T`)\n",
    "        Array of static and delta transformation matrix.\n",
    "    \"\"\"\n",
    "    \n",
    "    static = [0, 1, 0]\n",
    "    delta = win\n",
    "    assert len(static) == len(delta)\n",
    "    \n",
    "    # generate full W\n",
    "    DT = D * T\n",
    "    ones = np.ones(DT)\n",
    "    row = np.arange(2 * DT).reshape(2 * T, D) # generate serial numbers\n",
    "    static_row = row[::2] # [1,2,3,4,5] => [1,3,5]\n",
    "    delta_row = row[1::2] # [1,2,3,4,5] => [2,4]\n",
    "    col = np.arange(DT)\n",
    "    \n",
    "    data = np.array([ones * static[0], ones * static[1],\n",
    "                      ones * static[2], ones * delta[0],\n",
    "                      ones * delta[1], ones * delta[2]]).flatten()\n",
    "    row = np.array([[static_row] * 3, [delta_row] * 3]).flatten()\n",
    "    col = np.array([[col - D, col, col + D] * 2]).flatten()\n",
    "\n",
    "    # remove component at first and end frame\n",
    "    valid_idx = np.logical_not(np.logical_or(col < 0, col >= DT))\n",
    "    \n",
    "    W = scipy.sparse.csr_matrix(\n",
    "        (data[valid_idx], (row[valid_idx], col[valid_idx])), shape=(2 * DT, DT))\n",
    "    W.eliminate_zeros()\n",
    "    \n",
    "    return W\n",
    "    \n",
    "def extfrm(data, npow, power_threshold=-20):\n",
    "    \"\"\"\n",
    "    Extract frame over the power threshold\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    data : array, shape(`T`, `dim`)\n",
    "        array of input data\n",
    "    npow : array, shape(`T`)\n",
    "        vector of normalized power sequence\n",
    "    threshold : scala\n",
    "        scala of power threshold [dB]\n",
    "        \n",
    "    Returns\n",
    "    ----------\n",
    "    data : array, shape(`T_ext`, `dim`)\n",
    "        remaining data after extracting frame\n",
    "        `T_ext` <= `T`\n",
    "    \"\"\"\n",
    "    T = data.shape[0]\n",
    "    if T != len(npow):\n",
    "        raise(\"Length of two vectors is different.\")\n",
    "        \n",
    "    valid_index = np.where(npow > power_threshold)\n",
    "    extdata = data[valid_index]\n",
    "    assert extdata.shape[0] <= T\n",
    "    \n",
    "    return extdata\n",
    "\n",
    "def estimate_twf(orgdata, tardata, distance='melcd', fast=True, otflag=None):\n",
    "    \"\"\"\n",
    "    time warping function estimator\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    orgdata : array, shape(`T_org`, `dim`)\n",
    "        array of source feature\n",
    "    tardata : array, shape(`T_tar`, `dim`)\n",
    "        array of target feature\n",
    "    distance : str \n",
    "        distance function\n",
    "    fast : bool\n",
    "        use fastdtw instead of dtw\n",
    "    otflag : str\n",
    "        Alignment into the length of specification\n",
    "        'org' : alignment into original length\n",
    "        'tar' : alignment into target length   \n",
    "    \n",
    "    Returns\n",
    "    ----------\n",
    "    twf : array, shape(`2`, `T`)\n",
    "        time warping function between original and target\n",
    "    \"\"\"\n",
    "    \n",
    "    if distance == 'melcd':\n",
    "        def distance_func(x, y): return melcd(x, y)\n",
    "    else:\n",
    "        raise ValueError('this distance method is not support.')\n",
    "    \n",
    "    if fast:\n",
    "        _, path = fastdtw(orgdata, tardata, dist=distance_func)\n",
    "        twf = np.array(path).T\n",
    "    else:\n",
    "        _, _, _, twf = dtw(orgdata, tardata, distance_func) \n",
    "        \n",
    "    if otflag is not None:\n",
    "        twf = modify_twf(twf, otflag=otflag)\n",
    "    \n",
    "    return twf\n",
    "\n",
    "def align_data(org_data, tar_data, twf):\n",
    "    \"\"\"\n",
    "    get aligned joint feature vector\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    org_data : array, shape(`T_org`, `dim_org`)\n",
    "        Acoustic feature vector of original speaker\n",
    "    tar_data : array, shape(`T_tar`, `dim_tar`)\n",
    "        Acoustic feature vector of target speaker\n",
    "    twf : array, shape(`2`, `T`)\n",
    "        time warping function between original and target\n",
    "        \n",
    "    Returns\n",
    "    ----------\n",
    "    jdata : array, shape(`T_new`, `dim_org + dim_tar`)\n",
    "        Joint feature vector between source and target\n",
    "    \"\"\"\n",
    "    \n",
    "    jdata = np.c_[org_data[twf[0]], tar_data[twf[1]]]\n",
    "    return jdata\n",
    "\n",
    "def modify_twf(twf, otflag=None):\n",
    "    \"\"\"\n",
    "    align specified length\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    twf : array, shape(`2`, `T`)\n",
    "        time warping function between original and target\n",
    "    otflag : str\n",
    "        Alignment into the length of specification\n",
    "        'org' : alignment into original length\n",
    "        'tar' : alignment into target length   \n",
    "    \n",
    "    Returns\n",
    "    ----------\n",
    "    mod_twf : array, shape(`2`, `T_new`)\n",
    "        time warping function of modified alignment\n",
    "    \"\"\"\n",
    "    \n",
    "    if otflag == 'org':\n",
    "        of, indice = np.unique(twf[0], return_index=True)\n",
    "        mod_twf = np.c_[of, twf[1][indice]].T\n",
    "    elif otflag == 'tar':\n",
    "        tf, indice = np.unique(twf[1], return_index=True)\n",
    "        mod_twf = np.c_[twf[0][indice], tf].T \n",
    "    \n",
    "    return mod_twf\n",
    "\n",
    "def low_cut_filter(x, fs, cutoff=70):\n",
    "    \"\"\"\n",
    "    low cut filter\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    x : array, shape('samples')\n",
    "        waveform sequence\n",
    "    fs : array, int\n",
    "        Sampling frequency\n",
    "    cutoff : float\n",
    "        cutoff frequency of low cut filter\n",
    "    \n",
    "    Returns\n",
    "    ----------\n",
    "    lct_x : array, shape('samples')\n",
    "        Low cut filtered waveform sequence\n",
    "    \"\"\"\n",
    "    \n",
    "    nyquist = fs // 2\n",
    "    norm_cutoff = cutoff / nyquist\n",
    "    \n",
    "    # low cut filter\n",
    "    fil = firwin(255, norm_cutoff, pass_zero=False)\n",
    "    lct_x = lfilter(fil, 1, x)\n",
    "    \n",
    "    return lct_x\n",
    "\n",
    "def extsddata(data, npow, power_threshold=-20):\n",
    "    \"\"\"\n",
    "    get power extract static and delta feature vector\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    data : array, shape(`T`, `dim`)\n",
    "        acoustic feature vector\n",
    "    npow : array, shape(`T`)\n",
    "        normalized power vector\n",
    "    power_threshold : float\n",
    "        power threshold\n",
    "    \n",
    "    Returns\n",
    "    ----------\n",
    "    extsddata : array, shape(`T_new`, `dim * 2`)\n",
    "        silence remove static and delta feature vector\n",
    "    \"\"\"\n",
    "    \n",
    "    extsddata = extfrm(static_delta(data), npow, power_threshold=power_threshold)\n",
    "    return extsddata\n",
    "\n",
    "def transform_jnt(array_list):\n",
    "    num_files = len(array_list)\n",
    "    for i in range(num_files):\n",
    "        if i == 0:\n",
    "            jnt = array_list[i]\n",
    "        else:\n",
    "            jnt = np.r_[jnt, array_list[i]]\n",
    "    return jnt\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class F0statistics(object):\n",
    "    \"\"\"\n",
    "    Estimate F0 statistics and convert F0\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "    def estimate(self, f0list):\n",
    "        \"\"\"\n",
    "        estimate F0 statistics from list of f0\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        f0list : list, shape(`f0num`)\n",
    "            List of several F0 sequence\n",
    "        \n",
    "        Returns\n",
    "        ----------\n",
    "        f0stats : array, shape(`[mean, std]`)\n",
    "            values of mean and standard deviation for log f0\n",
    "        \"\"\"\n",
    "        \n",
    "        n_files = len(f0list)\n",
    "        assert n_files != 0\n",
    "\n",
    "        for i in range(n_files):\n",
    "            f0 = f0list[i]\n",
    "            nonzero_indices = np.nonzero(f0)\n",
    "            if i == 0:\n",
    "                f0s = np.log(f0[nonzero_indices])\n",
    "            else:\n",
    "                f0s = np.r_[f0s, np.log(f0[nonzero_indices])]\n",
    "        \n",
    "        f0stats = np.array([np.mean(f0s), np.std(f0s)])\n",
    "        \n",
    "        return f0stats\n",
    "\n",
    "    def convert(self, f0, orgf0stats, tarf0stats):\n",
    "        \"\"\"\n",
    "        convert F0 based on F0 statistics\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        f0 : array, shape(`T`, `1`)\n",
    "            array of F0 sequence\n",
    "        orgf0stats : array, shape(`[mean, std]`)\n",
    "            vectors of mean and standard deviation of log f0 for original speaker\n",
    "        tarf0stats : array, shape(`[mean, std]`)\n",
    "            vectors of mean and standard deviation of log f0 for target speaker\n",
    "        \n",
    "        Returns\n",
    "        ----------\n",
    "        cvf0 : array, shape(`T`, `1`)\n",
    "            array of converted F0 sequence\n",
    "        \"\"\"\n",
    "        \n",
    "        # get length and dimension\n",
    "        T = len(f0)\n",
    "        \n",
    "        # perform f0 conversion\n",
    "        cvf0 = np.zeros(T)\n",
    "        \n",
    "        nonzero_indices  = f0 > 0\n",
    "        cvf0[nonzero_indices] = np.exp((tarf0stats[1] / orgf0stats[1]) * (np.log(f0[nonzero_indices]) - orgf0stats[0]) + tarf0stats[0])\n",
    "        \n",
    "        return cvf0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GV(object):\n",
    "    \"\"\"\n",
    "    Estimate statistics and perform postfilter based on the GV statistics.\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "    def estimate(self, datalist):\n",
    "        \"\"\"\n",
    "        estimate GV statistics from list of data\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        datalist : list, shape(`num_data`)\n",
    "            List of several data ([T, dim]) sequence\n",
    "        \n",
    "        Returns\n",
    "        ----------\n",
    "        gvstats : array, shape(`2`, `dim`)\n",
    "            array of mean and standard deviation for GV\n",
    "        \"\"\"\n",
    "        \n",
    "        n_files = len(datalist)\n",
    "        assert n_files != 0\n",
    "        \n",
    "        var = []\n",
    "        for i in range(n_files):\n",
    "            data = datalist[i]\n",
    "            var.append(np.var(data, axis=0))\n",
    "            \n",
    "        # calculate vm and vv\n",
    "        vm = np.mean(np.array(var), axis=0)\n",
    "        vv = np.var(np.array(var), axis=0)\n",
    "        gvstats = np.r_[vm, vv]\n",
    "        gvstats = gvstats.reshape(2, len(vm))\n",
    "        \n",
    "        return gvstats\n",
    "\n",
    "    def postfilter(self, data, gvstats, cvgvstats=None, alpha=1.0, startdim=1):\n",
    "        \"\"\"\n",
    "        perform postfilter based on GV statistics into data\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        data : array, shape(`T`, `dim`)\n",
    "            array of data sequence\n",
    "        gvstats : array, shape(`2`, `dim`)\n",
    "            array of mean and variance for target GV\n",
    "        cvgvstats : array, shape(`2`, `dim`)\n",
    "            array of mean and variance for converted GV\n",
    "        alpha : float\n",
    "            morphing coefficient between GV transformed data and data.\n",
    "            alpha * gvpf(data) + (1 - alpha) * data\n",
    "        startdim : int\n",
    "            start dimension to perform GV postfilter\n",
    "        \n",
    "        Returns\n",
    "        ----------\n",
    "        filtered_data : array, shape(`T`, `data`)\n",
    "            array of GV postfiltered data sequnece\n",
    "        \"\"\"\n",
    "        \n",
    "        # get length and dimension\n",
    "        T, dim = data.shape\n",
    "        assert gvstats is not None\n",
    "        assert dim == gvstats.shape[1]\n",
    "        \n",
    "        # calculate statics of input data\n",
    "        datamean = np.mean(data, axis=0)\n",
    "        \n",
    "        if cvgvstats is None:\n",
    "            # use variance of the given data\n",
    "            datavar = np.var(data, axis=0)\n",
    "        else:\n",
    "            # use variance of trained gv stats\n",
    "            datavar = cvgvstats[0]\n",
    "        \n",
    "        # perform GV postfilter\n",
    "        filterd = np.sqrt(gvstats[0, startdim:] / datavar[startdim:]) * (data[:, startdim:] - datamean[startdim:]) + datamean[startdim:]\n",
    "        \n",
    "        filterd_data = np.c_[data[:, :startdim], filterd]\n",
    "        \n",
    "        return alpha * filterd_data + (1 - alpha) * data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 0. config path\n",
    "__versions = \"pre-stored-jp\"\n",
    "__same_path = \"./utterance/\" + __versions + \"/\"\n",
    "prepare_path = __same_path + \"output/\"\n",
    "pre_stored_source_list = __same_path + 'pre-source/**/V01/T01/**/*.wav'\n",
    "pre_stored_list = __same_path + \"pre/**/V01/T01/**/*.wav\"\n",
    "output_path = \"./utterance/orl/jp-f/1/adapt2/\"\n",
    "\n",
    "# 1. estimate features\n",
    "feat = FeatureExtractor()\n",
    "synthesizer = Synthesizer()\n",
    "\n",
    "org_f0list = None\n",
    "org_splist = None\n",
    "org_mceplist = None\n",
    "org_aplist = None\n",
    "org_npowlist = None\n",
    "org_codeaplist = None\n",
    "\n",
    "if os.path.exists(prepare_path + \"_org_f0.pickle\") \\\n",
    "    and os.path.exists(prepare_path + \"_org_sp.pickle\") \\\n",
    "    and os.path.exists(prepare_path + \"_org_ap.pickle\") \\\n",
    "    and os.path.exists(prepare_path + \"_org_mcep.pickle\") \\\n",
    "    and os.path.exists(prepare_path + \"_org_npow.pickle\") \\\n",
    "    and os.path.exists(prepare_path + \"_org_codeap.pickle\"):\n",
    "        \n",
    "    with open(prepare_path + \"_org_f0.pickle\", 'rb') as f:    \n",
    "        org_f0list = pickle.load(f)\n",
    "    with open(prepare_path + \"_org_sp.pickle\", 'rb') as f:   \n",
    "        org_splist = pickle.load(f)\n",
    "    with open(prepare_path + \"_org_ap.pickle\", 'rb') as f:  \n",
    "        org_aplist = pickle.load(f)\n",
    "    with open(prepare_path + \"_org_mcep.pickle\", 'rb') as f:  \n",
    "        org_mceplist = pickle.load(f)\n",
    "    with open(prepare_path + \"_org_npow.pickle\", 'rb') as f:  \n",
    "        org_npowlist = pickle.load(f)\n",
    "    with open(prepare_path + \"_org_codeap.pickle\", 'rb') as f:  \n",
    "        org_codeaplist = pickle.load(f) \n",
    "else:\n",
    "    org_f0list = []\n",
    "    org_splist = []\n",
    "    org_mceplist = []\n",
    "    org_aplist = []\n",
    "    org_npowlist = []\n",
    "    org_codeaplist = []\n",
    "    ite = 0\n",
    "    for files in sorted(glob.iglob(pre_stored_source_list, recursive=True)):\n",
    "        wavf = files\n",
    "        x, fs = sf.read(wavf)\n",
    "        x = np.array(x, dtype=np.float)\n",
    "        x = low_cut_filter(x, fs, cutoff=70)\n",
    "        assert fs == 16000\n",
    "\n",
    "        print(\"extract acoustic featuers: \" + wavf)\n",
    "\n",
    "        f0, sp, ap = feat.analyze(x)\n",
    "        mcep = feat.mcep()\n",
    "        npow = feat.npow()\n",
    "        codeap = feat.codeap()\n",
    "        wav = synthesizer.synthesis_sp(f0, sp, ap)\n",
    "        wav = np.clip(wav, -32768, 32767)\n",
    "        sf.write(output_path + \"src_ansys_{}_.wav\".format(ite), wav, fs)\n",
    "        \n",
    "        org_f0list.append(f0)\n",
    "        org_splist.append(sp)\n",
    "        org_mceplist.append(mcep)\n",
    "        org_aplist.append(ap)\n",
    "        org_npowlist.append(npow)\n",
    "        org_codeaplist.append(codeap)\n",
    "\n",
    "        wav = synthesizer.synthesis(f0, mcep, ap)\n",
    "        wav = np.clip(wav, -32768, 32767)\n",
    "        sf.write(output_path + \"src_mcep_{}_.wav\".format(ite), wav, fs)\n",
    "        ite = ite + 1\n",
    "\n",
    "    with open(prepare_path + \"_org_f0.pickle\", 'wb') as f:    \n",
    "        pickle.dump(org_f0list, f)\n",
    "    with open(prepare_path + \"_org_sp.pickle\", 'wb') as f:   \n",
    "        pickle.dump(org_splist, f)\n",
    "    with open(prepare_path + \"_org_npow.pickle\", 'wb') as f:   \n",
    "        pickle.dump(org_npowlist, f)\n",
    "    with open(prepare_path + \"_org_ap.pickle\", 'wb') as f:  \n",
    "        pickle.dump(org_aplist, f)\n",
    "    with open(prepare_path + \"_org_mcep.pickle\", 'wb') as f:  \n",
    "        pickle.dump(org_mceplist, f)\n",
    "    with open(prepare_path + \"_org_codeap.pickle\", 'wb') as f:  \n",
    "        pickle.dump(org_codeaplist, f) \n",
    "\n",
    "mid_f0list = None\n",
    "mid_mceplist = None\n",
    "mid_aplist = None\n",
    "mid_npowlist = None\n",
    "mid_splist = None\n",
    "mid_codeaplist = None        \n",
    "\n",
    "if os.path.exists(prepare_path + \"_mid_f0.pickle\") \\\n",
    "    and os.path.exists(prepare_path + \"_mid_sp_0_.pickle\") \\\n",
    "    and os.path.exists(prepare_path + \"_mid_ap_0_.pickle\") \\\n",
    "    and os.path.exists(prepare_path + \"_mid_mcep.pickle\") \\\n",
    "    and os.path.exists(prepare_path + \"_mid_npow.pickle\") \\\n",
    "    and os.path.exists(prepare_path + \"_mid_codeap.pickle\"):\n",
    "        \n",
    "    with open(prepare_path + \"_mid_f0.pickle\", 'rb') as f:    \n",
    "        mid_f0list = pickle.load(f)\n",
    "    for i in range(0, len(org_splist)*21, len(org_splist)):  \n",
    "        with open(prepare_path + \"_mid_sp_{}_.pickle\".format(i), 'rb') as f:\n",
    "            temp_splist = pickle.load(f)\n",
    "            if mid_splist is None:\n",
    "                mid_splist = temp_splist\n",
    "            else:\n",
    "                mid_splist = mid_splist + temp_splist\n",
    "    for i in range(0, len(org_aplist)*21, len(org_aplist)):  \n",
    "        with open(prepare_path + \"_mid_ap_{}_.pickle\".format(i), 'rb') as f:\n",
    "            temp_aplist = pickle.load(f)\n",
    "            if mid_aplist is None:\n",
    "                mid_aplist = temp_aplist\n",
    "            else:\n",
    "                mid_aplist = mid_aplist + temp_aplist    \n",
    "    with open(prepare_path + \"_mid_mcep.pickle\", 'rb') as f:  \n",
    "        mid_mceplist = pickle.load(f)\n",
    "    with open(prepare_path + \"_mid_npow.pickle\", 'rb') as f:  \n",
    "        mid_npowlist = pickle.load(f)\n",
    "    with open(prepare_path + \"_mid_codeap.pickle\", 'rb') as f:  \n",
    "        mid_codeaplist = pickle.load(f) \n",
    "else:        \n",
    "    mid_f0list = []\n",
    "    mid_mceplist = []\n",
    "    mid_aplist = []\n",
    "    mid_npowlist = []\n",
    "    mid_splist = []\n",
    "    mid_codeaplist = []\n",
    "    ite = 0\n",
    "    for files in sorted(glob.iglob(pre_stored_list, recursive=True)):\n",
    "        wavf = files\n",
    "        x, fs = sf.read(wavf)\n",
    "        x = np.array(x, dtype=np.float)\n",
    "        x = low_cut_filter(x, fs, cutoff=70)\n",
    "        assert fs == 16000\n",
    "\n",
    "        print(\"extract acoustic featuers: \" + wavf)\n",
    "\n",
    "        f0, sp, ap = feat.analyze(x)\n",
    "        mcep = feat.mcep()\n",
    "        npow = feat.npow()\n",
    "        codeap = feat.codeap()\n",
    "        name, ext = os.path.splitext(wavf)\n",
    "        wav = synthesizer.synthesis_sp(f0, sp, ap)\n",
    "        wav = np.clip(wav, -32768, 32767)\n",
    "        sf.write(output_path + \"mid_ansys_{}_.wav\".format(ite), wav, fs)\n",
    "        \n",
    "        mid_f0list.append(f0)\n",
    "        mid_splist.append(sp)\n",
    "        mid_mceplist.append(mcep)\n",
    "        mid_aplist.append(ap)\n",
    "        mid_npowlist.append(npow)\n",
    "        mid_codeaplist.append(codeap)\n",
    "\n",
    "        wav = synthesizer.synthesis(f0, mcep, ap)\n",
    "        wav = np.clip(wav, -32768, 32767)\n",
    "        sf.write(output_path + \"mid_mcep_{}_.wav\".format(ite), wav, fs)\n",
    "        ite = ite + 1\n",
    "        \n",
    "    with open(prepare_path + \"_mid_f0.pickle\", 'wb') as f:\n",
    "        print(f)\n",
    "        pickle.dump(mid_f0list, f)\n",
    "    with open(prepare_path + \"_mid_npow.pickle\", 'wb') as f:\n",
    "        print(f)\n",
    "        pickle.dump(mid_npowlist, f)\n",
    "    for i in range(0, len(mid_splist), len(org_splist)):\n",
    "        with open(prepare_path + \"_mid_sp_{}_.pickle\".format(i), 'wb') as f:   \n",
    "            print(f)\n",
    "            pickle.dump(mid_splist[i:i+len(org_splist)], f)\n",
    "    for i in range(0, len(mid_aplist), len(org_aplist)):\n",
    "        with open(prepare_path + \"_mid_ap_{}_.pickle\".format(i), 'wb') as f:\n",
    "            print(f)\n",
    "            pickle.dump(mid_aplist[i:i+len(org_aplist)], f)\n",
    "    with open(prepare_path + \"_mid_mcep.pickle\", 'wb') as f:\n",
    "        print(f)\n",
    "        pickle.dump(mid_mceplist, f)\n",
    "    with open(prepare_path + \"_mid_codeap.pickle\", 'wb') as f:\n",
    "        print(f)\n",
    "        pickle.dump(mid_codeaplist, f) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GMMTrainer(object):\n",
    "    \"\"\"\n",
    "    this class offers the training of GMM with several types of covariance matrix.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    n_mix : int \n",
    "        the number of mixture components of the GMM\n",
    "    n_iter : int\n",
    "        the number of iteration for EM algorithm\n",
    "    covtype : str\n",
    "        the type of covariance matrix of the GMM\n",
    "        'full': full-covariance matrix\n",
    "    \n",
    "    Attributes\n",
    "    ---------\n",
    "    param : \n",
    "        sklearn-based model parameters of the GMM\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, n_mix=64, n_iter=100, covtype='full', params='wmc'):\n",
    "        self.n_mix = n_mix\n",
    "        self.n_iter = n_iter\n",
    "        self.covtype = covtype\n",
    "        self.params = params\n",
    "        self.param = sklearn.mixture.GMM(n_components=self.n_mix,\n",
    "                                                     covariance_type=self.covtype,\n",
    "                                                     n_iter=self.n_iter, params=self.params)\n",
    "        \n",
    "    def train(self, jnt):\n",
    "        \"\"\"\n",
    "        fit GMM parameter from given joint feature vector\n",
    "        \n",
    "        Parametes\n",
    "        ---------\n",
    "        jnt : array, shape(`T`, `jnt.shape[0]`)\n",
    "            joint feature vector of original and target feature vector consisting of static and delta components\n",
    "        \"\"\"\n",
    "        \n",
    "        if self.covtype == 'full':\n",
    "            self.param.fit(jnt)\n",
    "            \n",
    "        return\n",
    "    \n",
    "class GMMConvertor(object):\n",
    "    \"\"\"\n",
    "    this class offers the several conversion techniques such as Maximum Likelihood Parameter Generation (MLPG)\n",
    "    and Minimum Mean Square Error (MMSE).\n",
    "    \n",
    "    Parametes\n",
    "    ---------\n",
    "    n_mix : int\n",
    "        the number of mixture components of the GMM\n",
    "    covtype : str\n",
    "        the type of covariance matrix of the GMM\n",
    "        'full': full-covariance matrix\n",
    "    gmmmode : str\n",
    "        the type of the GMM for opening\n",
    "        `None` : Normal Joint Density - GMM (JD-GMM)\n",
    "    \n",
    "    Attributes\n",
    "    ---------\n",
    "    param : \n",
    "        sklearn-based model parameters of the GMM\n",
    "    w : shape(`n_mix`)\n",
    "        vector of mixture component weight of the GMM\n",
    "    jmean : shape(`n_mix`, `jnt.shape[0]`)\n",
    "        Array of joint mean vector of the GMM\n",
    "    jcov : shape(`n_mix`, `jnt.shape[0]`, `jnt.shape[0]`)\n",
    "        array of joint covariance matrix of the GMM\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, n_mix=64, covtype='full', gmmmode=None):\n",
    "        self.n_mix = n_mix\n",
    "        self.covtype = covtype\n",
    "        self.gmmmode = gmmmode\n",
    "        \n",
    "    def open_from_param(self, param):\n",
    "        \"\"\"\n",
    "        open GMM from GMMTrainer\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        param : GMMTrainer\n",
    "            GMMTrainer class\n",
    "        \"\"\"\n",
    "        \n",
    "        self.param = param\n",
    "        self._deploy_parameters()\n",
    "        \n",
    "        return\n",
    "    \n",
    "    def convert(self, data, cvtype='mlpg'):\n",
    "        \"\"\"\n",
    "        convert data based on conditional probability density function\n",
    "        \n",
    "        Parametes\n",
    "        ---------\n",
    "        data : array, shape(`T`, `dim`)\n",
    "            original data will be converted\n",
    "        cvtype : str\n",
    "            type of conversion technique\n",
    "            `mlpg` : maximum likelihood parameter generation\n",
    "            \n",
    "        Returns\n",
    "        ----------\n",
    "        odata : array, shape(`T`, `dim`)\n",
    "            converted data\n",
    "        \"\"\"\n",
    "        \n",
    "        # estimate parameter sequence\n",
    "        cseq, wseq, mseq, covseq = self._gmmmap(data)\n",
    "        \n",
    "        if cvtype == 'mlpg':\n",
    "            odata = self._mlpg(mseq, covseq)\n",
    "        else:\n",
    "            raise ValueError('please choose conversion mode in `mlpg`.')\n",
    "        \n",
    "        return odata\n",
    "    \n",
    "    def _gmmmap(self, sddata):\n",
    "        # paramete for sequencial data\n",
    "        T, sddim = sddata.shape\n",
    "        \n",
    "        # estimate posterior sequence\n",
    "        wseq = self.pX.predict_proba(sddata)\n",
    "        \n",
    "        # estimate mixture sequence\n",
    "        cseq = np.argmax(wseq, axis=1)\n",
    "        \n",
    "        mseq = np.zeros((T, sddim))\n",
    "        covseq = np.zeros((T, sddim, sddim))\n",
    "        for t in range(T):\n",
    "            # read maximum likelihood mixture component in frame t\n",
    "            m = cseq[t]\n",
    "            \n",
    "            # conditional mean vector sequence\n",
    "            mseq[t] = self.meanY[m] + self.A[m] @ (sddata[t] - self.meanX[m])\n",
    "            \n",
    "            # conditional covariance sequence\n",
    "            covseq[t] = self.cond_cov_inv[m]\n",
    "        \n",
    "        return cseq, wseq, mseq, covseq\n",
    "    \n",
    "    def _mlpg(self, mseq, covseq):\n",
    "        # parameter for sequencial data\n",
    "        T, sddim = mseq.shape\n",
    "        \n",
    "        # prepare W\n",
    "        W = construct_static_and_delta_matrix(T, sddim // 2)\n",
    "        \n",
    "        # prepare D\n",
    "        D = get_diagonal_precision_matrix(T, sddim, covseq)\n",
    "        \n",
    "        # calculate W'D\n",
    "        WD = W.T @ D\n",
    "        \n",
    "        # W'DW\n",
    "        WDW = WD @ W\n",
    "        \n",
    "        # W'Dm\n",
    "        WDM = WD @ mseq.flatten()\n",
    "        \n",
    "        # estimate y = (W'DW)^-1 * W'Dm\n",
    "        odata = scipy.sparse.linalg.spsolve(WDW, WDM, use_umfpack=False).reshape(T, sddim // 2)\n",
    "        \n",
    "        return odata\n",
    "    \n",
    "    def _deploy_parameters(self):\n",
    "        # read JD-GMM parameters from self.param\n",
    "        self.W = self.param.weights_\n",
    "        self.jmean = self.param.means_\n",
    "        self.jcov = self.param.covars_\n",
    "        \n",
    "        # devide GMM parameters into source and target parameters\n",
    "        sddim = self.jmean.shape[1] // 2\n",
    "        self.meanX = self.jmean[:, 0:sddim]\n",
    "        self.meanY = self.jmean[:, sddim:]\n",
    "        self.covXX = self.jcov[:, :sddim, :sddim]\n",
    "        self.covXY = self.jcov[:, :sddim, sddim:]\n",
    "        self.covYX = self.jcov[:, sddim:, :sddim]\n",
    "        self.covYY = self.jcov[:, sddim:, sddim:]\n",
    "        \n",
    "        # change model parameter of GMM into that of gmmmode\n",
    "        if self.gmmmode is None:\n",
    "            pass\n",
    "        else:\n",
    "            raise ValueError('please choose GMM mode in [None]')\n",
    "            \n",
    "        # estimate parameters for conversion\n",
    "        self._set_Ab()\n",
    "        self._set_pX()\n",
    "        \n",
    "        return\n",
    "    \n",
    "    def _set_Ab(self):\n",
    "        # calculate A and b from self.jmean, self.jcov\n",
    "        sddim = self.jmean.shape[1] // 2\n",
    "        \n",
    "        # calculate inverse covariance for covariance XX in each mixture\n",
    "        self.covXXinv = np.zeros((self.n_mix, sddim, sddim))\n",
    "        for m in range(self.n_mix):\n",
    "            self.covXXinv[m] = np.linalg.inv(self.covXX[m])\n",
    "            \n",
    "        # calculate A, b, and conditional covariance given X\n",
    "        self.A = np.zeros((self.n_mix, sddim, sddim))\n",
    "        self.b = np.zeros((self.n_mix, sddim))\n",
    "        self.cond_cov_inv = np.zeros((self.n_mix, sddim, sddim))\n",
    "        for m in range(self.n_mix):\n",
    "            # calculate A (A = yxcov_m * xxcov_m^-1)\n",
    "            self.A[m] = self.covYX[m] @ self.covXXinv[m]\n",
    "            \n",
    "            # calculate b (b = mean^Y - A * mean^X)\n",
    "            self.b[m] = self.meanY[m] - self.A[m] @ self.meanX[m]\n",
    "            \n",
    "            # calculate conditional covariance (cov^(Y|X)^-1 = (yycov - A * xycov)^-1)\n",
    "            self.cond_cov_inv[m] = np.linalg.inv(self.covYY[m] - self.A[m] @ self.covXY[m])\n",
    "            \n",
    "        return\n",
    "    \n",
    "    def _set_pX(self):\n",
    "        # probability density function of X \n",
    "        self.pX = sklearn.mixture.GMM(n_components=self.n_mix, covariance_type=self.covtype)\n",
    "        self.pX.weights_ = self.W\n",
    "        self.pX.means_ = self.meanX\n",
    "        self.pX.covars_ = self.covXX\n",
    "        \n",
    "        # following function is required to estimate porsterior\n",
    "        # p(x | \\lambda^(X))\n",
    "        #self.pX.precisions_cholesky_ = _compute_precision_cholesky(self.covXX, self.covtype)\n",
    "        \n",
    "        return\n",
    "    \n",
    "def get_diagonal_precision_matrix(T, D, covseq):\n",
    "    return scipy.sparse.block_diag(covseq, format='csr')        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_alignment(odata, onpow, tdata, tnpow, opow=-20, tpow=-20, sd=0, cvdata=None, given_twf=None, otflag=None, distance='melcd'):\n",
    "    \"\"\"\n",
    "    get alignment between original and target.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    odata : array, shape(`T`, `dim`)\n",
    "        acoustic feature vector of original\n",
    "    onpow : array, shape(`T`)\n",
    "        Normalized power vector of original\n",
    "    tdata : array, shape(`T`, `dim`)\n",
    "        acoustic feature vector of target\n",
    "    tnpow : array, shape(`T`)\n",
    "        Normalized power vector of target\n",
    "    opow : float\n",
    "        power threshold of original\n",
    "    tpow : float\n",
    "        power threshold of target\n",
    "    sd : int\n",
    "        start dimension to be used for alignment\n",
    "    cvdata : array, shape(`T`, `dim`)\n",
    "        converted original data\n",
    "    given_twf : array, shape(`T_new`, `dim * 2`)\n",
    "        Alignment given twf\n",
    "    otflag : str\n",
    "        Alignment into the length of specification\n",
    "        'org' : alignment into original length\n",
    "        'tar' : alignment into target length\n",
    "    distance : str\n",
    "        Distance function to be used\n",
    "    \n",
    "    Returns\n",
    "    ----------\n",
    "    jdata : array, shape(`T_new`, `dim * 2`)\n",
    "        joint static and delta feature vector\n",
    "    twf : array, shape(`T_new`, `dim * 2`)\n",
    "        Time warping function\n",
    "    mcd : float\n",
    "        Mel-cepstrum distortion between arrays\n",
    "    \"\"\"\n",
    "    \n",
    "    oexdata = extsddata(odata[:, sd:], onpow, power_threshold=opow)\n",
    "    texdata = extsddata(tdata[:, sd:], tnpow, power_threshold=tpow)\n",
    "    \n",
    "    if cvdata is None:\n",
    "        align_odata = oexdata\n",
    "    else:\n",
    "        cvexdata = extsddata(cvdata, onpow, power_threshold=opow)\n",
    "        align_odata = cvexdata\n",
    "    \n",
    "    if given_twf is None: \n",
    "        twf = estimate_twf(align_odata, texdata, distance=distance, fast=False, otflag=otflag)\n",
    "    else:\n",
    "        twf = given_twf\n",
    "    \n",
    "    jdata = align_data(oexdata, texdata, twf)\n",
    "    mcd = melcd(align_odata[twf[0]], texdata[twf[1]])\n",
    "    \n",
    "    return jdata, twf, mcd\n",
    "\n",
    "def align_feature_vectors(odata, onpows, tdata, tnpows, opow=-100, tpow=-100, itnum=3, sd=0, given_twfs=None, otflag=None):\n",
    "    \"\"\"\n",
    "    get alignment to create joint feature vector\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    odata : list, (`num_files`)\n",
    "        List of original feature vectors\n",
    "    onpow : list, (`num_files`)\n",
    "        List of original npows\n",
    "    tdata : list, (`num_files`)\n",
    "        List of target feature vectors\n",
    "    tnpow : list, (`num_files`)\n",
    "        List of target npows\n",
    "    opow : float\n",
    "        power threshold of original\n",
    "    tpow : float\n",
    "        power threshold of target\n",
    "    itnum : int\n",
    "        the number of iteration\n",
    "    sd : int\n",
    "        start dimension of feature vector to be used for alignment\n",
    "    given_twf : array, shape(`T_new`, `dim * 2`)\n",
    "        use given alignment while 1st iteration\n",
    "    otflag : str\n",
    "        Alignment into the length of specification\n",
    "        'org' : alignment into original length\n",
    "        'tar' : alignment into target length\n",
    "    distance : str\n",
    "        Distance function to be used\n",
    "    \n",
    "    Returns\n",
    "    ----------\n",
    "    jdata : array, shape(`T_new`, `dim * 2`)\n",
    "        joint static and delta feature vector\n",
    "    twf : array, shape(`T_new`, `dim * 2`)\n",
    "        Time warping function\n",
    "    mcd : float\n",
    "        Mel-cepstrum distortion between arrays\n",
    "    \"\"\"\n",
    "    \n",
    "    it = 1\n",
    "    num_files = len(odata)\n",
    "    cvgmm, cvdata = None, None\n",
    "    for it in range(1, itnum+1):\n",
    "        print('{}-th joint feature extraction starts.'.format(it))\n",
    "        \n",
    "        # alignment\n",
    "        twfs, jfvs = [], []\n",
    "        for i in range(num_files):\n",
    "            if it == 1 and given_twfs is not None:\n",
    "                gtwf = given_twfs[i]\n",
    "            else:\n",
    "                gtwf = None\n",
    "            \n",
    "            if it > 1:\n",
    "                cvdata = cvgmm.convert(static_delta(odata[i][:, sd:]))\n",
    "            \n",
    "            jdata, twf, mcd = get_alignment(odata[i], onpows[i], tdata[i], tnpows[i], opow=opow, tpow=tpow,\n",
    "                                            sd=sd, cvdata=cvdata, given_twf=gtwf, otflag=otflag)\n",
    "            twfs.append(twf)\n",
    "            jfvs.append(jdata)\n",
    "            print('distortion [dB] for {}-th file: {}'.format(i+1, mcd))\n",
    "            \n",
    "        jnt_data = transform_jnt(jfvs)\n",
    "        \n",
    "        if it != itnum:\n",
    "            # train GMM, if not final iteration\n",
    "            datagmm = GMMTrainer()\n",
    "            datagmm.train(jnt_data)\n",
    "            cvgmm = GMMConvertor()\n",
    "            cvgmm.open_from_param(datagmm.param)\n",
    "        it += 1\n",
    "    return jfvs, twfs    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. estimate twf and jnt\n",
    "if os.path.exists(prepare_path + \"_jnt_mcep_0_.pickle\"):\n",
    "    pass\n",
    "else:\n",
    "    for i in range(0, len(mid_mceplist), len(org_mceplist)):\n",
    "        org_mceps = org_mceplist\n",
    "        org_npows = org_npowlist\n",
    "        mid_mceps = mid_mceplist[i:i+len(org_mceps)]\n",
    "        mid_npows = mid_npowlist[i:i+len(org_npows)]\n",
    "        assert len(org_mceps) == len(mid_mceps)\n",
    "        assert len(org_npows) == len(mid_npows)\n",
    "        assert len(org_mceps) == len(org_npows)\n",
    "\n",
    "        # dtw between original and target 0-th and silence\n",
    "        print(\"## alignment mcep 0-th and silence ##\")\n",
    "        jmceps, twfs = align_feature_vectors(org_mceps, org_npows, mid_mceps, mid_npows, opow=-15, tpow=-15, sd=1)\n",
    "        jnt_mcep = transform_jnt(jmceps)\n",
    "\n",
    "        # save joint feature vectors\n",
    "        with open(prepare_path + \"_jnt_mcep_{}_.pickle\".format(i), 'wb') as f:   \n",
    "            print(f)\n",
    "            pickle.dump(jnt_mcep, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<_io.BufferedReader name='./utterance/pre-stored-jp/output/initgmm.pickle'>\n"
     ]
    }
   ],
   "source": [
    "# 3. make EV-GMM\n",
    "initgmm, initgmm_codeap = None, None\n",
    "if os.path.exists(prepare_path + \"initgmm.pickle\"):\n",
    "    with open(prepare_path + \"initgmm.pickle\".format(i), 'rb') as f:   \n",
    "        print(f)\n",
    "        initgmm = pickle.load(f)\n",
    "else:\n",
    "    jnt, jnt_codeap = None, []\n",
    "    for i in range(0, len(mid_mceplist), len(org_mceplist)):\n",
    "        with open(prepare_path + \"_jnt_mcep_{}_.pickle\".format(i), 'rb') as f:  \n",
    "            temp_jnt = pickle.load(f)\n",
    "            if jnt is None:\n",
    "                jnt = temp_jnt\n",
    "            else:\n",
    "                jnt = np.r_[jnt, temp_jnt]\n",
    "\n",
    "    # train initial gmm\n",
    "    initgmm = GMMTrainer()\n",
    "    initgmm.train(jnt)\n",
    "\n",
    "    with open(prepare_path + \"initgmm.pickle\", 'wb') as f:   \n",
    "        print(f)\n",
    "        pickle.dump(initgmm, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get initial gmm params\n",
    "init_W = initgmm.param.weights_\n",
    "init_jmean = initgmm.param.means_\n",
    "init_jcov = initgmm.param.covars_\n",
    "sddim = init_jmean.shape[1] // 2\n",
    "init_meanX = init_jmean[:, :sddim]\n",
    "init_meanY = init_jmean[:, sddim:]\n",
    "init_covXX = init_jcov[:, :sddim, :sddim]\n",
    "init_covXY = init_jcov[:, :sddim, sddim:]\n",
    "init_covYX = init_jcov[:, sddim:, :sddim]\n",
    "init_covYY = init_jcov[:, sddim:, sddim:]\n",
    "fitted_source = init_meanX\n",
    "fitted_target = init_meanY\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sv = None\n",
    "if os.path.exists(prepare_path + \"_sv.npy\"):\n",
    "    sv = np.array(sv)\n",
    "    sv = np.load(prepare_path + '_sv.npy')\n",
    "else:\n",
    "    depengmm, depenjnt = None, None\n",
    "    sv = []\n",
    "    for i in range(0, len(mid_mceplist), len(org_mceplist)):\n",
    "        with open(prepare_path + \"_jnt_mcep_{}_.pickle\".format(i), 'rb') as f:  \n",
    "            depenjnt = pickle.load(f)\n",
    "            depengmm = GMMTrainer(params='m')\n",
    "            depengmm.param.weights_ = init_W\n",
    "            depengmm.param.means_ = init_jmean\n",
    "            depengmm.param.covars_ = init_jcov\n",
    "            depengmm.train(depenjnt)\n",
    "            sv.append(depengmm.param.means_)\n",
    "    sv = np.array(sv)\n",
    "    np.save(output_path + \"_sv\", sv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_mix = 64\n",
    "S = int(len(mid_mceplist) / len(org_mceplist))\n",
    "assert S == 22\n",
    "\n",
    "source_pca = sklearn.decomposition.PCA()\n",
    "source_pca.fit(sv[:,:,:sddim].reshape((S, n_mix*sddim)))\n",
    "\n",
    "target_pca = sklearn.decomposition.PCA()\n",
    "target_pca.fit(sv[:,:,sddim:].reshape((S, n_mix*sddim)))\n",
    "\n",
    "eigenvectors = source_pca.components_.reshape((n_mix, sddim, S)), target_pca.components_.reshape((n_mix, sddim, S)) \n",
    "biasvectors = source_pca.mean_.reshape((n_mix, sddim)), target_pca.mean_.reshape((n_mix, sddim))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A11.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A14.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A17.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A18.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A19.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A20.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A21.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A22.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A23.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A24.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A25.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A26.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A27.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A28.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A29.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A30.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A31.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A32.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A33.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A34.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A35.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A36.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A37.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A38.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A39.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A40.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A41.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A42.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A43.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A44.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A45.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A46.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A47.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A48.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A49.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A50.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A51.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A52.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A53.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A54.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A55.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A56.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A57.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A58.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/input/EJM10/V01/T01/TIMIT/000/A59.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/ATR503/A/A01.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/ATR503/A/A02.wav\n"
     ]
    }
   ],
   "source": [
    "# estimate statistic features\n",
    "for_convert_source = __same_path + 'input/EJM10/V01/T01/TIMIT/000/*.wav'\n",
    "for_convert_target = __same_path + 'adaptation/EJF01/V01/T01/ATR503/A/*.wav'\n",
    "\n",
    "src_f0list = []\n",
    "src_splist = []\n",
    "src_mceplist = []\n",
    "src_aplist = []\n",
    "src_npowlist = []\n",
    "src_codeaplist = []\n",
    "if os.path.exists(__same_path + 'input/EJM10/V01/T01/TIMIT/000/A11.wav'):\n",
    "    ite = 0\n",
    "    for files in sorted(glob.iglob(for_convert_source, recursive=True)):\n",
    "        wavf = files\n",
    "        x, fs = sf.read(wavf)\n",
    "        x = np.array(x, dtype=np.float)\n",
    "        x = low_cut_filter(x, fs, cutoff=70)\n",
    "        assert fs == 16000\n",
    "\n",
    "        print(\"extract acoustic featuers: \" + wavf)\n",
    "\n",
    "        f0, sp, ap = feat.analyze(x)\n",
    "        mcep = feat.mcep()\n",
    "        npow = feat.npow()\n",
    "        codeap = feat.codeap()\n",
    "        wav = synthesizer.synthesis_sp(f0, sp, ap)\n",
    "        wav = np.clip(wav, -32768, 32767)\n",
    "        sf.write(output_path + \"input_ansys_{}_.wav\".format(ite), wav, fs)\n",
    "        \n",
    "        src_f0list.append(f0)\n",
    "        src_splist.append(sp)\n",
    "        src_mceplist.append(mcep)\n",
    "        src_aplist.append(ap)\n",
    "        src_npowlist.append(npow)\n",
    "        src_codeaplist.append(codeap)\n",
    "\n",
    "        wav = synthesizer.synthesis(f0, mcep, ap)\n",
    "        wav = np.clip(wav, -32768, 32767)\n",
    "        sf.write(output_path + \"input_mcep_{}_.wav\".format(ite), wav, fs)\n",
    "        ite = ite + 1\n",
    "\n",
    "else:\n",
    "    raise ValueError(\"No such files.\")\n",
    "tar_f0list = []\n",
    "tar_mceplist = []\n",
    "tar_aplist = []\n",
    "tar_npowlist = []\n",
    "tar_splist = []\n",
    "tar_codeaplist = []\n",
    "\n",
    "if os.path.exists(__same_path + 'adaptation/EJF01/V01/T01/ATR503/A/A01.wav'):\n",
    "    ite = 0\n",
    "    for files in sorted(glob.iglob(for_convert_target, recursive=True)):\n",
    "        wavf = files\n",
    "        x, fs = sf.read(wavf)\n",
    "        x = np.array(x, dtype=np.float)\n",
    "        x = low_cut_filter(x, fs, cutoff=70)\n",
    "        assert fs == 16000\n",
    "\n",
    "        print(\"extract acoustic featuers: \" + wavf)\n",
    "\n",
    "        f0, sp, ap = feat.analyze(x)\n",
    "        mcep = feat.mcep()\n",
    "        npow = feat.npow()\n",
    "        codeap = feat.codeap()\n",
    "        name, ext = os.path.splitext(wavf)\n",
    "        wav = synthesizer.synthesis_sp(f0, sp, ap)\n",
    "        wav = np.clip(wav, -32768, 32767)\n",
    "        sf.write(output_path + \"target_ansys_{}_.wav\".format(ite), wav, fs)\n",
    "        \n",
    "        tar_f0list.append(f0)\n",
    "        tar_splist.append(sp)\n",
    "        tar_mceplist.append(mcep)\n",
    "        tar_aplist.append(ap)\n",
    "        tar_npowlist.append(npow)\n",
    "        tar_codeaplist.append(codeap)\n",
    "\n",
    "        wav = synthesizer.synthesis(f0, mcep, ap)\n",
    "        wav = np.clip(wav, -32768, 32767)\n",
    "        sf.write(output_path + \"target_mcep_{}_.wav\".format(ite), wav, fs)\n",
    "        ite = ite + 1\n",
    "else:\n",
    "    raise ValueError(\"No such files.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "f0statis = F0statistics()\n",
    "tarf0stats = f0statis.estimate(tar_f0list)\n",
    "srcf0stats = f0statis.estimate(org_f0list)\n",
    "\n",
    "gv = GV()\n",
    "srcgvstats = gv.estimate(org_mceplist)\n",
    "targvstats = gv.estimate(tar_mceplist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adapt:  1 / 2\n",
      "epoch =  0\n",
      "epoch =  1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  11\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  12\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  13\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  15\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  16\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  17\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  18\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  19\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  20\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  21\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  22\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  23\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  25\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  26\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  27\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  28\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  29\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  30\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  31\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  32\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  33\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  34\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  35\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  36\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  37\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  38\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  39\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  40\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  41\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  42\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  43\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  44\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  45\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  46\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  47\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  48\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  49\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  51\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  52\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  53\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  54\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  55\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  56\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  57\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  58\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  59\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  60\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  61\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  62\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  63\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  64\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  65\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  66\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  67\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  68\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  69\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  70\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  71\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  72\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  73\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  74\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  75\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  76\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  77\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  78\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  79\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  80\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  81\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  82\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  83\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  84\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  85\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  86\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  87\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  88\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  89\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  90\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  91\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  92\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  93\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  94\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  95\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  96\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  97\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  98\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  99\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adapt:  2 / 2\n",
      "epoch =  0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  11\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  12\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  13\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  15\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  16\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  17\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  18\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  19\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  20\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  21\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  22\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  23\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  25\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  26\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  27\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  28\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  29\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  30\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  31\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  32\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  33\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  34\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  35\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  36\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  37\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  38\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  39\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  40\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  41\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  42\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  43\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  44\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  45\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  46\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  47\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  48\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  49\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  51\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  52\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  53\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  54\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  55\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  56\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  57\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  58\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  59\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  60\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  61\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  62\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  63\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  64\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  65\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  66\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  67\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  68\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  69\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  70\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  71\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  72\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  73\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  74\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  75\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  76\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  77\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  78\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  79\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  80\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  81\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  82\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  83\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  84\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  85\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  86\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  87\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  88\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  89\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  90\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  91\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  92\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  93\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  94\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  95\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  96\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  97\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  98\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch =  99\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "# 5. fitting target\n",
    "epoch = 100\n",
    "\n",
    "fitgmm = sklearn.mixture.GMM(n_components=n_mix,\n",
    "                             covariance_type='full',\n",
    "                             n_iter=100)\n",
    "fitgmm.weights_ = init_W\n",
    "fitgmm.means_ = init_meanY\n",
    "fitgmm.covars_ = init_covYY\n",
    "\n",
    "for i in range(len(tar_mceplist)):\n",
    "    print(\"adapt: \", i+1, \"/\", len(tar_mceplist))\n",
    "    target = tar_mceplist[i]\n",
    "    target_pow = target[:, 0]\n",
    "    target = target[:, 1:]\n",
    "    for x in range(epoch):\n",
    "        print(\"epoch = \", x)\n",
    "        predict = fitgmm.predict_proba(np.atleast_2d(static_delta(target)))\n",
    "        \n",
    "        y = np.sum([predict[:, k:k+1] * (static_delta(target) - biasvectors[1][k]) for k in range(n_mix)], axis=1)\n",
    "        gamma = np.sum(predict, axis=0)\n",
    "        \n",
    "        left = np.sum([gamma[k] * np.dot(eigenvectors[1][k].T,\n",
    "                                         np.linalg.solve(fitgmm.covars_, eigenvectors[1])[k])\n",
    "                                                        for k in range(n_mix)], axis=0)\n",
    "        right = np.sum([np.dot(eigenvectors[1][k].T,\n",
    "                               np.linalg.solve(fitgmm.covars_, y)[k])\n",
    "                        for k in range(n_mix)], axis=0)\n",
    "        weight = np.linalg.solve(left, right)\n",
    "        \n",
    "        fitted_target = np.dot(eigenvectors[1], weight) + biasvectors[1]\n",
    "        fitgmm.means_ = fitted_target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mcepconvert(source, weights, jmean, meanX, covarXX, covarXY, covarYX, covarYY,\n",
    "                fitted_source, fitted_target):\n",
    "    \n",
    "    M = 64\n",
    "    # set pX\n",
    "    px = sklearn.mixture.GMM(n_components=M, covariance_type='full', n_iter=100)\n",
    "    px.weights_ = weights\n",
    "    px.means_ = meanX\n",
    "    px.covars_ = covarXX\n",
    "    \n",
    "    # set Ab\n",
    "    sddim = jmean.shape[1] // 2\n",
    "    covXXinv = np.zeros((M, sddim, sddim))\n",
    "    for m in range(M):\n",
    "        covXXinv[m] = np.linalg.inv(covarXX[m])\n",
    "    A = np.zeros((M, sddim, sddim))\n",
    "    b = np.zeros((M, sddim))\n",
    "    cond_cov_inv = np.zeros((M, sddim, sddim))\n",
    "    for m in range(M):\n",
    "        A[m] = covarYX[m] @ covXXinv[m]\n",
    "        b[m] = fitted_target[m] - A[m] @ meanX[m]\n",
    "        cond_cov_inv[m] = np.linalg.inv(covarYY[m] - A[m] @ covarXY[m])\n",
    "        \n",
    "    # _gmmmap\n",
    "    T, sddim = source.shape\n",
    "    wseq = px.predict_proba(source)\n",
    "    cseq = np.argmax(wseq, axis=1)\n",
    "    mseq = np.zeros((T, sddim))\n",
    "    covseq = np.zeros((T, sddim, sddim))\n",
    "    for t in range(T):\n",
    "        m = cseq[t]\n",
    "        mseq[t] = fitted_target[m] + A[m] @ (source[t] - meanX[m])\n",
    "        covseq[t] = cond_cov_inv[m]\n",
    "        \n",
    "    # _mlpg\n",
    "    T, sddim = mseq.shape\n",
    "    W = construct_static_and_delta_matrix(T, sddim // 2)\n",
    "    D = get_diagonal_precision_matrix(T, sddim, covseq)\n",
    "    WD = W.T @ D\n",
    "    WDW = WD @ W\n",
    "    WDM = WD @ mseq.flatten()\n",
    "    \n",
    "    output = scipy.sparse.linalg.spsolve(WDW, WDM, use_umfpack=False).reshape(T, sddim // 2)\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:58: DeprecationWarning: Class GMM is deprecated; The class GMM is deprecated in 0.18 and will be  removed in 0.20. Use class GaussianMixture instead.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n",
      "/anaconda3/lib/python3.5/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function log_multivariate_normal_density is deprecated; The function log_multivariate_normal_density is deprecated in 0.18 and will be removed in 0.20.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "# learn cvgvstats \n",
    "cv_mceps = []\n",
    "for i in range(len(src_mceplist)):\n",
    "    temp_mcep = src_mceplist[i]\n",
    "    temp_mcep_0th = temp_mcep[:, 0]\n",
    "    temp_mcep = temp_mcep[:, 1:]\n",
    "    sta_mcep = static_delta(temp_mcep)\n",
    "    cvmcep_wopow = np.array(mcepconvert(sta_mcep, init_W, init_jmean, init_meanX,\n",
    "                                        init_covXX, init_covXY, init_covYX, init_covYY,\n",
    "                                        fitted_source, fitted_target))\n",
    "    cvmcep = np.c_[temp_mcep_0th, cvmcep_wopow]\n",
    "    cv_mceps.append(cvmcep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "cvgvstats = gv.estimate(cv_mceps)\n",
    "\n",
    "for i in range(len(src_mceplist)):\n",
    "    cvmcep_wGV = gv.postfilter(cv_mceps[i], targvstats, cvgvstats=cvgvstats)\n",
    "    cvf0 = f0statis.convert(src_f0list[i], srcf0stats, tarf0stats)\n",
    "    wav = synthesizer.synthesis(cvf0, cvmcep_wGV, src_aplist[i], rmcep=src_mceplist[i])\n",
    "    sf.write(output_path + \"cv_{}_.wav\".format(i), wav, 16000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(src_mceplist)):\n",
    "    wav = synthesizer.synthesis(src_f0list[i], src_mceplist[i], src_aplist[i])\n",
    "    sf.write(output_path + \"mcep_{}_.wav\".format(i), wav, 16000)\n",
    "    wav = synthesizer.synthesis_sp(src_f0list[i], src_splist[i], src_aplist[i])\n",
    "    sf.write(output_path + \"ansys_{}_.wav\".format(i), wav, 16000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x221e022828>]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x221dfff438>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cvf0 = f0statis.convert(src_f0list[0], srcf0stats, tarf0stats)\n",
    "plt.plot(cvf0)\n",
    "plt.plot(src_f0list[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "cvmcep_wGV = gv.postfilter(cv_mceps[0], srcgvstats, cvgvstats=cvgvstats)\n",
    "cvf0 = f0statis.convert(src_f0list[0], srcf0stats, tarf0stats)\n",
    "wav = synthesizer.synthesis(cvf0, cvmcep_wGV, src_aplist[0], rmcep=src_mceplist[0])\n",
    "sf.write(output_path + \"te.wav\", wav, 16000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A11.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A14.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A17.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A18.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A19.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A20.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A21.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A22.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A23.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A24.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A25.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A26.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A27.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A28.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A29.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A30.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A31.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A32.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A33.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A34.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A35.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A36.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A37.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A38.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A39.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A40.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A41.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A42.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A43.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A44.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A45.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A46.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A47.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A48.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A49.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A50.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A51.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A52.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A53.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A54.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A55.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A56.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A57.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A58.wav\n",
      "extract acoustic featuers: ./utterance/pre-stored-jp/adaptation/EJF01/V01/T01/TIMIT/000/A59.wav\n"
     ]
    }
   ],
   "source": [
    "# org-cv distance\n",
    "with open(output_path + \"melcd_org-cv.txt\", \"w\") as outfile:\n",
    "    outfile.write(\"adapt2 org-cv mcd.\\n\")\n",
    "    for i in range(len(src_mceplist)):\n",
    "        temp_mcep = src_mceplist[i]\n",
    "        temp_mcep_0th = temp_mcep[:, 0]\n",
    "        temp_mcep = temp_mcep[:, 1:]\n",
    "        \n",
    "        temp_cv = cv_mceps[i]\n",
    "        temp_cv_0th = temp_cv[:, 0]\n",
    "        temp_cv = temp_cv[:, 1:]\n",
    "        \n",
    "        _, _, mcd = get_alignment(temp_mcep, temp_mcep_0th, temp_cv, temp_cv_0th, opow=-15, tpow=-15, sd=1)\n",
    "        outfile.write(\"{0},{1}\\n\".format(i, mcd))\n",
    "\n",
    "# cv-target distance\n",
    "# read target files and analyze mceps\n",
    "targets_mceplist = []\n",
    "targets_list = __same_path + 'adaptation/EJF01/V01/T01/TIMIT/000/*.wav'\n",
    "for files in sorted(glob.iglob(targets_list, recursive=True)):\n",
    "    wavf = files\n",
    "    x, fs = sf.read(wavf)\n",
    "    x = np.array(x, dtype=np.float)\n",
    "    x = low_cut_filter(x, fs, cutoff=70)\n",
    "    assert fs == 16000\n",
    "    print(\"extract acoustic featuers: \" + wavf)\n",
    "\n",
    "    f0, sp, ap = feat.analyze(x)\n",
    "    mcep = feat.mcep()\n",
    "    targets_mceplist.append(mcep)\n",
    "\n",
    "with open(output_path + \"melcd_cv-target.txt\", \"w\") as outfile:\n",
    "    outfile.write(\"adapt2 cv-target mcd.\\n\")\n",
    "    \n",
    "    for i in range(len(src_mceplist)):\n",
    "        temp_mcep = targets_mceplist[i]\n",
    "        temp_mcep_0th = temp_mcep[:, 0]\n",
    "        temp_mcep = temp_mcep[:, 1:]\n",
    "        \n",
    "        temp_cv = cv_mceps[i]\n",
    "        temp_cv_0th = temp_cv[:, 0]\n",
    "        temp_cv = temp_cv[:, 1:]\n",
    "        \n",
    "        _, _, mcd = get_alignment(temp_cv, temp_cv_0th, temp_mcep, temp_mcep_0th, opow=-15, tpow=-15, sd=1)\n",
    "        outfile.write(\"{0},{1}\\n\".format(i, mcd))\n",
    "\n",
    "# org-target distance\n",
    "with open(output_path + \"melcd_org-target.txt\", \"w\") as outfile:\n",
    "    outfile.write(\"adapt2 org-target mcd.\\n\")\n",
    "    \n",
    "    for i in range(len(src_mceplist)):\n",
    "\n",
    "        temp_mcep = src_mceplist[i]\n",
    "        temp_mcep_0th = temp_mcep[:, 0]\n",
    "        temp_mcep = temp_mcep[:, 1:]\n",
    "        \n",
    "        temp_mcep2 = targets_mceplist[i]\n",
    "        temp_mcep2_0th = temp_mcep2[:, 0]\n",
    "        temp_mcep2 = temp_mcep2[:, 1:]\n",
    "        \n",
    "        \n",
    "        _, _, mcd = get_alignment(temp_mcep, temp_mcep_0th, temp_mcep2, temp_mcep2_0th, opow=-15, tpow=-15, sd=1)\n",
    "        outfile.write(\"{0},{1}\\n\".format(i, mcd))"
   ]
  }
 ],
 "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}