module_test_c.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input Data: .wav -> Pitch contour (f0s), Harmonic spectral envelope (sps), Aperiodic spectral envelope (aps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils import *\n",
    "from ops import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import librosa.display\n",
    "from IPython.display import Audio\n",
    "# import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "# matplotlib.rcParams['figure.figsize'] = (16, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_seed = 0\n",
    "np.random.seed(random_seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Autoencoder: Style_Encoder, Content_Encoder, MLP, Decoder, Discriminator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Style_Encoder(inputs, style_dim=16, reuse=False, scope='style_encoder'):                                                            # [1, 24, 128] = [batch_size, feature_channel, time]\n",
    "\n",
    "    inputs = tf.transpose(inputs, perm=[0, 2, 1], name='input_transpose')                                                               # [1, 128, 24] = [batch_size, time, feature_channel]\n",
    "\n",
    "    with tf.variable_scope(scope, reuse=reuse):\n",
    "\n",
    "        h1 = conv1d_layer(inputs=inputs, filters=128, kernel_size=15, strides=1, name='h1_conv')                                        # [1, 128, 128]\n",
    "        h1_gates = conv1d_layer(inputs=inputs, filters=128, kernel_size=15, strides=1, name='h1_conv_gates')\n",
    "        h1_glu = gated_linear_layer(inputs=h1, gates=h1_gates, name='h1_glu')\n",
    "\n",
    "        # Downsample\n",
    "        d1 = downsample1d_block_withoutIN(inputs=h1_glu, filters=256, kernel_size=5, strides=2, name_prefix='downsample1d_block1')      # [1, 64, 256]\n",
    "        d2 = downsample1d_block_withoutIN(inputs=d1, filters=512, kernel_size=5, strides=2, name_prefix='downsample1d_block2')          # [1, 32, 512]\n",
    "\n",
    "        d3 = downsample1d_block_withoutIN(inputs=d2, filters=512, kernel_size=3, strides=2, name_prefix='downsample1d_block3')          # [1, 16, 512]\n",
    "        d4 = downsample1d_block_withoutIN(inputs=d3, filters=512, kernel_size=3, strides=2, name_prefix='downsample1d_block4')          # [1, 8, 512]\n",
    "\n",
    "        # Global Average Pooling\n",
    "        p1 = adaptive_avg_pooling(d4)                                                                                                   # [1, 1, 512]\n",
    "        style = conv1d_layer(inputs=p1, filters=style_dim, kernel_size=1, strides=1, name='SE_logit')                                   # [1, 1, 16]\n",
    "\n",
    "        return style                                                                                                                    # [1, 1, 16]\n",
    "\n",
    "\n",
    "def Content_Encoder(inputs, reuse=False, scope='content_encoder'):\n",
    "    # IN removes the original feature mean and variance that represent important style information\n",
    "    inputs = tf.transpose(inputs, perm=[0, 2, 1], name='input_transpose')                                                               # [1, 24, 128] = [batch_size, time, feature_channel]\n",
    "\n",
    "    with tf.variable_scope(scope, reuse=reuse):\n",
    "\n",
    "        h1 = conv1d_layer(inputs=inputs, filters=128, kernel_size=15, strides=1, name='h1_conv')                                        # [1, 128, 128]\n",
    "        h1_norm = instance_norm_layer(inputs=h1, name='h1_norm')\n",
    "        h1_gates = conv1d_layer(inputs=inputs, filters=128, kernel_size=15, strides=1, name='h1_gates')\n",
    "        h1_norm_gates = instance_norm_layer(inputs=h1_gates, name='h1_norm_gates')\n",
    "        h1_glu = gated_linear_layer(inputs=h1_norm, gates=h1_norm_gates, name='h1_glu')\n",
    "\n",
    "        # downsample\n",
    "        d1 = downsample1d_block(inputs=h1_glu, filters=256, kernel_size=5, strides=2, name_prefix='downsample1d_block1')                # [1, 64, 256]\n",
    "        d2 = downsample1d_block(inputs=d1, filters=512, kernel_size=5, strides=2, name_prefix='downsample1d_block2')                    # [1, 32, 512]\n",
    "               \n",
    "        # Residual blocks\n",
    "        r1 = residual1d_block(inputs=d2, filters = 512, kernel_size=3, strides=1, name_prefix='residual1d_block1')                      # [1, 32, 512]\n",
    "        r2 = residual1d_block(inputs=r1, filters = 512, kernel_size=3, strides=1, name_prefix='residual1d_block2')\n",
    "        r3 = residual1d_block(inputs=r2, filters = 512, kernel_size=3, strides=1, name_prefix='residual1d_block3')\n",
    "        content = residual1d_block(inputs=r3, filters=512, kernel_size=3, strides=1, name_prefix='residual1d_block4')\n",
    "\n",
    "        return content                                                                                                                  # [1, 32, 512]\n",
    "\n",
    "\n",
    "def MLP(style, reuse=False, scope='MLP'):                                                                                               # [1, 1, 16]\n",
    "\n",
    "    with tf.variable_scope(scope, reuse=reuse):\n",
    "\n",
    "        x1 = linear(style, 512, scope='linear_1')                                                                                       # [1, 1, 512]\n",
    "        x1_gates = linear(x1, 512, scope='linear_1_gates')\n",
    "        x1_glu = gated_linear_layer(inputs=x1, gates=x1_gates, name='x1_glu')\n",
    "\n",
    "        x2 = linear(x1_glu, 512, scope='linear_2')\n",
    "        x2_gates = linear(x2, 512, scope='linear_2_gates')\n",
    "        x2_glu = gated_linear_layer(inputs=x2, gates=x2_gates, name='x2_glu')\n",
    "\n",
    "        mu = linear(x2_glu, 512, scope='mu')\n",
    "        sigma = linear(x2_glu, 512, scope='sigma')\n",
    "\n",
    "        mu = tf.reshape(mu, shape=[-1, 1, 512])                                                                                         # [1, 1, 512]\n",
    "        sigma = tf.reshape(sigma, shape=[-1, 1, 512])                                                                                   # [1, 1, 512]\n",
    "\n",
    "        return mu, sigma                                                                                                                # [1, 1, 512]\n",
    "\n",
    "\n",
    "def Decoder(content, style, reuse=False, scope=\"decoder\"):\n",
    "\n",
    "    with tf.variable_scope(scope, reuse=reuse):\n",
    "\n",
    "        mu, sigma = MLP(style, reuse)                                                                                                   # [1, 1, 512]\n",
    "        x = content                                                                                                                     # [1, 32, 512]\n",
    "\n",
    "        # Adaptive Residual blocks\n",
    "        r1 = residual1d_block_adaptive(inputs=x, filters=512, mu=mu, sigma=sigma, kernel_size=3, strides=1, name_prefix='residual1d_block1')        # [1, 32, 512]\n",
    "        r2 = residual1d_block_adaptive(inputs=r1, filters=512, mu=mu, sigma=sigma, kernel_size=3, strides=1, name_prefix='residual1d_block2')\n",
    "        r3 = residual1d_block_adaptive(inputs=r2, filters=512, mu=mu, sigma=sigma, kernel_size=3, strides=1, name_prefix='residual1d_block3')\n",
    "\n",
    "        # Upsample\n",
    "        u1 = upsample1d_block(inputs=r3, filters=512, kernel_size=5, strides=1, shuffle_size=2, name_prefix='upsample1d_block1')        # [1, 64, 512]\n",
    "        u2 = upsample1d_block(inputs=u1, filters=256, kernel_size=5, strides=1, shuffle_size=2, name_prefix='upsample1d_block2')        # [1, 128, 256]\n",
    "\n",
    "        # Output\n",
    "        o1 = conv1d_layer(inputs=u2, filters=24, kernel_size=15, strides=1, name='o1_conv')                                             # [1, 128, 24]\n",
    "        o2 = tf.transpose(o1, perm=[0, 2, 1], name='output_transpose')                                                                  # [1, 24, 128]\n",
    "\n",
    "        return o2                                                                                                                       # [1, 24, 128] = [batch_size, feature_channel, time]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Discriminator(inputs, reuse=False, scope='discriminator'):\n",
    "\n",
    "    # inputs = [batch_size, num_features, time]\n",
    "    # add channel for 2D convolution [batch_size, num_features, time, 1]\n",
    "    inputs = tf.expand_dims(inputs, -1)                                                                                                 # [1, 24, 128, 1]\n",
    "\n",
    "    with tf.variable_scope(scope, reuse=reuse):\n",
    "\n",
    "        h1 = conv2d_layer(inputs=inputs, filters=128, kernel_size=[3, 3], strides=[1, 2], name='h1_conv')                               # [1, 24, 64, 128]\n",
    "        h1_gates = conv2d_layer(inputs=inputs, filters=128, kernel_size=[3, 3], strides=[1, 2], name='h1_conv_gates')\n",
    "        h1_glu = gated_linear_layer(inputs=h1, gates=h1_gates, name='h1_glu')\n",
    "\n",
    "        # Downsample\n",
    "        d1 = downsample2d_block(inputs=h1_glu, filters=256, kernel_size=[3, 3], strides=[2, 2], name_prefix='downsample2d_block1')      # [1, 12, 32, 256]\n",
    "        d2 = downsample2d_block(inputs=d1, filters=512, kernel_size=[3, 3], strides=[2, 2], name_prefix='downsample2d_block2')          # [1, 6, 16, 512]\n",
    "        d3 = downsample2d_block(inputs=d2, filters=1024, kernel_size=[6, 3], strides=[1, 2], name_prefix='downsample2d_block3')         # [1, 6, 8, 1024]\n",
    "\n",
    "        # Output\n",
    "        o1 = tf.layers.dense(inputs=d3, units=1, activation=tf.nn.sigmoid)\n",
    "\n",
    "        return [o1]                                                                                                                       # [1, 6, 8, 1]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Autoencoder Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "##################################################################################\n",
    "# Model\n",
    "##################################################################################\n",
    "\n",
    "def Encoder_A(x_A, reuse=False):\n",
    "    style_A = Style_Encoder(x_A, reuse=reuse, scope='style_encoder_A')\n",
    "    content_A = Content_Encoder(x_A, reuse=reuse, scope='content_encoder_A')\n",
    "\n",
    "    return content_A, style_A\n",
    "\n",
    "def Encoder_B(x_B, reuse=False):\n",
    "    style_B = Style_Encoder(x_B, reuse=reuse, scope='style_encoder_B')\n",
    "    content_B = Content_Encoder(x_B, reuse=reuse, scope='content_encoder_B')\n",
    "\n",
    "    return content_B, style_B\n",
    "\n",
    "def Decoder_A(content_B, style_A, reuse=False):\n",
    "    x_ba = Decoder(content=content_B, style=style_A, reuse=reuse, scope='decoder_A')\n",
    "\n",
    "    return x_ba\n",
    "\n",
    "def Decoder_B(content_A, style_B, reuse=False):\n",
    "    x_ab = Decoder(content=content_A, style=style_B, reuse=reuse, scope='decoder_B')\n",
    "\n",
    "    return x_ab\n",
    "\n",
    "def discriminate_real(x_A, x_B):\n",
    "    real_A_logit = Discriminator(x_A, scope=\"discriminator_A\")\n",
    "    real_B_logit = Discriminator(x_B, scope=\"discriminator_B\")\n",
    "\n",
    "    return real_A_logit, real_B_logit\n",
    "\n",
    "def discriminate_fake(x_ba, x_ab):\n",
    "    fake_A_logit = Discriminator(x_ba, reuse=True, scope=\"discriminator_A\")\n",
    "    fake_B_logit = Discriminator(x_ab, reuse=True, scope=\"discriminator_B\")\n",
    "\n",
    "    return fake_A_logit, fake_B_logit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Module: EmoMUNIT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import readData\n",
    "tf.reset_default_graph()\n",
    "class EmoMUNIT(object):\n",
    "    def __init__(self, sess):\n",
    "        \n",
    "        # self.train_A_dir = './../../../Database/Emotion/ang_neu/ang'\n",
    "        # self.train_B_dir = './../../../Database/Emotion/ang_neu/neu'\n",
    "        # self.validation_A_dir = './../../../Database/Emotion/ang_neu/val_ang'\n",
    "        # self.validation_B_dir = './../../../Database/Emotion/ang_neu/val_neu'\n",
    "#         self.max_samples = 1000\n",
    "\n",
    "        dir = \"C:/Users/Gayane/Desktop/EmotionTask/Data/IEMOCAP_full_release/\"\n",
    "        dirAudio = \"Session1/sentences/wav/\"\n",
    "        dirText = \"Session1/dialog/EmoEvaluation/\"\n",
    "        obj = readData.preProcessing(dir, dirAudio, dirText)\n",
    "        wavFoldersPaths =  obj.wavFilePath()\n",
    "        self.train_A_dir = wavFoldersPaths[0][:10]\n",
    "        self.train_B_dir = wavFoldersPaths[0][10:20]\n",
    "        self.validation_A_dir = wavFoldersPaths[0][20:23]\n",
    "        self.validation_B_dir = wavFoldersPaths[0][23:25]\n",
    "        \n",
    "        self.batch_size = 1\n",
    "        self.style_dim = 16\n",
    "        \n",
    "        self.Encoder_A = Encoder_A\n",
    "        self.Encoder_B = Encoder_B\n",
    "        self.Decoder_A = Decoder_A\n",
    "        self.Decoder_B = Decoder_B\n",
    "        self.discriminate_real = discriminate_real\n",
    "        self.discriminate_fake = discriminate_fake\n",
    "        \n",
    "        self.recon_x_cyc_w = 0.0\n",
    "        self.gan_type = 'lsgan'\n",
    "        \n",
    "        self.gan_w = 1.0\n",
    "        self.recon_x_w = 1.0\n",
    "        self.recon_s_w = 1.0\n",
    "        self.recon_c_w = 1.0\n",
    "        self.recon_x_cyc_w = 0.0\n",
    "               \n",
    "        self.audio_len = 128    # = n_frames, time_length\n",
    "        self.audio_ch = 24      # = num_mcep, num_features\n",
    "        \n",
    "        self.direction = 'A2B'\n",
    "        \n",
    "        self.model_name = 'EmoMUNIT'\n",
    "        self.gan_type = 'lsgan'\n",
    "        self.dataset_name = 'ang2neu'\n",
    "        self.log_dir = 'logs'\n",
    "        self.sample_dir = 'samples'\n",
    "        self.checkpoint_dir = 'checkpoint'\n",
    "        self.result_dir = 'results'\n",
    "        \n",
    "        self.sess = sess\n",
    "        self.epoch = 3 # 300\n",
    "        self.iteration = 2 #1000\n",
    "        self.init_lr_D = 0.0001\n",
    "        self.init_lr_G = 0.0002\n",
    "        \n",
    "        self.sample_freq = 1000\n",
    "        self.save_freq = 1000\n",
    "        \n",
    "        self.sampling_rate = 16000\n",
    "        self.frame_period = 5.0\n",
    "        self.num_mcep = 24\n",
    "        \n",
    "    \n",
    "    def build_model(self):\n",
    "        self.lr_D = tf.placeholder(tf.float32, name='learning_rate_D')\n",
    "        self.lr_G = tf.placeholder(tf.float32, name='learning_rate_G')\n",
    "        \n",
    "        # Iterate from train_data_A and train_data_A\n",
    "        self.domain_A = tf.placeholder(tf.float32, shape=[self.batch_size, self.audio_ch, self.audio_len], name='domain_a')\n",
    "        self.domain_B = tf.placeholder(tf.float32, shape=[self.batch_size, self.audio_ch, self.audio_len], name='domain_b')\n",
    "    \n",
    "        self.style_a = tf.placeholder(tf.float32, shape=[self.batch_size, 1, self.style_dim], name='style_a')\n",
    "        self.style_b = tf.placeholder(tf.float32, shape=[self.batch_size, 1, self.style_dim], name='style_b')  \n",
    "    \n",
    "        # encode\n",
    "        content_a, style_a_prime = self.Encoder_A(self.domain_A)\n",
    "        content_b, style_b_prime = self.Encoder_B(self.domain_B)\n",
    "\n",
    "        # decode (within domain)\n",
    "        x_aa = self.Decoder_A(content_B=content_a, style_A=style_a_prime)\n",
    "        x_bb = self.Decoder_B(content_A=content_b, style_B=style_b_prime)\n",
    "    \n",
    "        # decode (cross domain)\n",
    "        x_ba = self.Decoder_A(content_B=content_b, style_A=self.style_a, reuse=True)\n",
    "        x_ab = self.Decoder_B(content_A=content_a, style_B=self.style_b, reuse=True)   \n",
    "    \n",
    "        # encode again\n",
    "        content_b_, style_a_ = self.Encoder_A(x_ba, reuse=True)\n",
    "        content_a_, style_b_ = self.Encoder_B(x_ab, reuse=True)    \n",
    "    \n",
    "        # decode again (if needed)\n",
    "        if self.recon_x_cyc_w > 0 :\n",
    "            x_aba = self.Decoder_A(content_B=content_a_, style_A=style_a_prime, reuse=True)\n",
    "            x_bab = self.Decoder_B(content_A=content_b_, style_B=style_b_prime, reuse=True)\n",
    "\n",
    "            cyc_recon_A = L1_loss(x_aba, self.domain_A)\n",
    "            cyc_recon_B = L1_loss(x_bab, self.domain_B)\n",
    "\n",
    "        else :\n",
    "            cyc_recon_A = 0.0\n",
    "            cyc_recon_B = 0.0    \n",
    "      \n",
    "        real_A_logit, real_B_logit = self.discriminate_real(self.domain_A, self.domain_B)\n",
    "        fake_A_logit, fake_B_logit = self.discriminate_fake(x_ba, x_ab)   \n",
    "    \n",
    "    \n",
    "        \"\"\" Define Loss \"\"\"\n",
    "        # Adversarial Loss\n",
    "        G_ad_loss_a = generator_loss(self.gan_type, fake_A_logit)\n",
    "        G_ad_loss_b = generator_loss(self.gan_type, fake_B_logit)\n",
    "    \n",
    "        # Discrimination Loss (real/fake)\n",
    "        D_ad_loss_a = discriminator_loss(self.gan_type, real_A_logit, fake_A_logit)\n",
    "        D_ad_loss_b = discriminator_loss(self.gan_type, real_B_logit, fake_B_logit)\n",
    "    \n",
    "        # Reconstruction Loss\n",
    "        recon_A = L1_loss(x_aa, self.domain_A) # reconstruction\n",
    "        recon_B = L1_loss(x_bb, self.domain_B) # reconstruction   \n",
    "    \n",
    "        # Semi-CycleGAN Loss\n",
    "        # For style, encourages diverse outputs given different style codes\n",
    "        recon_style_A = L1_loss(style_a_, self.style_a)\n",
    "        recon_style_B = L1_loss(style_b_, self.style_b)\n",
    "    \n",
    "        # For content, encourages the translated image to preserve semantic content of the input image\n",
    "        recon_content_A = L1_loss(content_a_, content_a)\n",
    "        recon_content_B = L1_loss(content_b_, content_b)   \n",
    "    \n",
    "        # Attacker Loss\n",
    "        Generator_A_loss = self.gan_w * G_ad_loss_a + \\\n",
    "                                   self.recon_x_w * recon_A + \\\n",
    "                                   self.recon_s_w * recon_style_A + \\\n",
    "                                   self.recon_c_w * recon_content_A + \\\n",
    "                                   self.recon_x_cyc_w * cyc_recon_A\n",
    "\n",
    "        Generator_B_loss = self.gan_w * G_ad_loss_b + \\\n",
    "                           self.recon_x_w * recon_B + \\\n",
    "                           self.recon_s_w * recon_style_B + \\\n",
    "                           self.recon_c_w * recon_content_B + \\\n",
    "                           self.recon_x_cyc_w * cyc_recon_B   \n",
    "    \n",
    "        # Defender Loss\n",
    "        Discriminator_A_loss = self.gan_w * D_ad_loss_a\n",
    "        Discriminator_B_loss = self.gan_w * D_ad_loss_b\n",
    "    \n",
    "        # Total Loss\n",
    "        self.Generator_loss = Generator_A_loss + Generator_B_loss\n",
    "        self.Discriminator_loss = Discriminator_A_loss + Discriminator_B_loss\n",
    "    \n",
    "    \n",
    "        \"\"\" Training Variables \"\"\"\n",
    "        t_vars = tf.trainable_variables()\n",
    "        G_vars = [var for var in t_vars if 'decoder' in var.name or 'encoder' in var.name]\n",
    "        D_vars = [var for var in t_vars if 'discriminator' in var.name]\n",
    "    \n",
    "        self.G_optim = tf.train.AdamOptimizer(self.lr_G, beta1=0.5, beta2=0.999).minimize(self.Generator_loss, var_list=G_vars)\n",
    "        self.D_optim = tf.train.AdamOptimizer(self.lr_D, beta1=0.5, beta2=0.999).minimize(self.Discriminator_loss, var_list=D_vars)\n",
    "    \n",
    "        \"\"\"\" Summary \"\"\"\n",
    "        self.all_G_loss = tf.summary.scalar(\"Generator_loss\", self.Generator_loss)\n",
    "        self.all_D_loss = tf.summary.scalar(\"Discriminator_loss\", self.Discriminator_loss)\n",
    "        \n",
    "        self.R_A_loss = tf.summary.scalar(\"Reconstruction_A_loss\", recon_A)\n",
    "        self.R_B_loss = tf.summary.scalar(\"Reconstruction_B_loss\", recon_B)\n",
    "        self.recon_style_A = tf.summary.scalar(\"recon_style_A\", recon_style_A)\n",
    "        self.recon_style_B = tf.summary.scalar(\"recon_style_B\", recon_style_B)        \n",
    "        self.recon_content_A = tf.summary.scalar(\"recon_content_A\", recon_content_A)\n",
    "        self.recon_content_B = tf.summary.scalar(\"recon_content_B\", recon_content_B)         \n",
    "        \n",
    "        self.G_A_loss = tf.summary.scalar(\"G_A_loss\", Generator_A_loss)\n",
    "        self.G_B_loss = tf.summary.scalar(\"G_B_loss\", Generator_B_loss)\n",
    "        self.G_ad_loss_a = tf.summary.scalar(\"G_ad_loss_a\", G_ad_loss_a)\n",
    "        self.G_ad_loss_b = tf.summary.scalar(\"G_ad_loss_b\", G_ad_loss_b)\n",
    "        \n",
    "        self.D_A_loss = tf.summary.scalar(\"D_A_loss\", Discriminator_A_loss)\n",
    "        self.D_B_loss = tf.summary.scalar(\"D_B_loss\", Discriminator_B_loss)\n",
    "\n",
    "        self.G_loss = tf.summary.merge([self.R_A_loss, self.R_B_loss, self.recon_style_A, self.recon_style_B, self.recon_content_A, self.recon_content_B, self.G_ad_loss_a, self.G_ad_loss_b, self.G_A_loss, self.G_B_loss, self.all_G_loss])\n",
    "        self.D_loss = tf.summary.merge([self.D_A_loss, self.D_B_loss, self.all_D_loss])\n",
    "    \n",
    "    \n",
    "        \"\"\" Speech: real and fake \"\"\"\n",
    "        self.real_A = self.domain_A\n",
    "        self.real_B = self.domain_B\n",
    "\n",
    "        self.fake_A = x_ba\n",
    "        self.fake_B = x_ab \n",
    "    \n",
    "        \"\"\" Test Variables \"\"\"\n",
    "        self.test_domain_A = tf.placeholder(tf.float32, [1, self.audio_ch, None], name='test_domain_a') # [1 24 None]\n",
    "        self.test_domain_B = tf.placeholder(tf.float32, [1, self.audio_ch, None], name='test_domain_b') # [1 24 None]\n",
    "        \n",
    "        self.test_style_a = tf.placeholder(tf.float32, [1, 1, self.style_dim], name='test_style_a')   # [1 1 16]\n",
    "        self.test_style_b = tf.placeholder(tf.float32, [1, 1, self.style_dim], name='test_style_b')   # [1 1 16]\n",
    "        \n",
    "        test_content_a, test_style_a = self.Encoder_A(self.test_domain_A, reuse=True)\n",
    "        test_content_b, test_style_b = self.Encoder_B(self.test_domain_B, reuse=True)\n",
    "\n",
    "        self.test_fake_A = self.Decoder_A(content_B=test_content_b, style_A=self.test_style_a, reuse=True)\n",
    "        self.test_fake_B = self.Decoder_B(content_A=test_content_a, style_B=self.test_style_b, reuse=True)\n",
    "\n",
    "        self.test_recon_A = self.Decoder_A(content_B=test_content_a, style_A=test_style_a, reuse=True)\n",
    "        self.test_recon_B = self.Decoder_B(content_A=test_content_b, style_B=test_style_b, reuse=True)\n",
    "        \n",
    "        \n",
    "        \"\"\" Guided Speech Translation \"\"\"\n",
    "        self.content_audio = tf.placeholder(tf.float32, [1, self.audio_ch, self.audio_len], name='content_audio')\n",
    "        self.style_audio = tf.placeholder(tf.float32, [1, self.audio_ch, self.audio_len], name='guide_style_audio_ch')\n",
    "\n",
    "        if self.direction == 'A2B' :\n",
    "            guide_content_A, guide_style_A = self.Encoder_A(self.content_audio, reuse=True)\n",
    "            guide_content_B, guide_style_B = self.Encoder_B(self.style_audio, reuse=True)\n",
    "\n",
    "        else :\n",
    "            guide_content_B, guide_style_B = self.Encoder_B(self.content_audio, reuse=True)\n",
    "            guide_content_A, guide_style_A = self.Encoder_A(self.style_audio, reuse=True)\n",
    "\n",
    "        self.guide_fake_A = self.Decoder_A(content_B=guide_content_B, style_A=guide_style_A, reuse=True)\n",
    "        self.guide_fake_B = self.Decoder_B(content_A=guide_content_A, style_B=guide_style_B, reuse=True)\n",
    "    \n",
    "    \n",
    "    def data_prepare(self, f0s_A, f0s_B, coded_sps_norm_A, coded_sps_norm_B):\n",
    "        \n",
    "        train_data_A = sample_train_data03(sps=list(coded_sps_norm_A), f0s=list(f0s_A), n_frames=self.audio_len)\n",
    "        train_data_B = sample_train_data03(sps=list(coded_sps_norm_B), f0s=list(f0s_B), n_frames=self.audio_len)\n",
    "\n",
    "        minlen = min(len(train_data_A), len(train_data_B))\n",
    "        np.random.shuffle(train_data_A)\n",
    "        np.random.shuffle(train_data_B)\n",
    "        train_data_A = np.array(train_data_A[0:minlen])\n",
    "        train_data_B = np.array(train_data_B[0:minlen])\n",
    "\n",
    "        return train_data_A, train_data_B\n",
    "    \n",
    "    \n",
    "    def train(self):\n",
    "        # initialize all variables\n",
    "        tf.global_variables_initializer().run()\n",
    "        \n",
    "        # saver to save model\n",
    "        self.saver = tf.train.Saver()\n",
    "        \n",
    "        # summary writer\n",
    "        self.writer = tf.summary.FileWriter(self.log_dir + '/' + self.model_dir, self.sess.graph)\n",
    "        \n",
    "        # restore check-point if it exits\n",
    "        could_load, checkpoint_counter = self.load(self.checkpoint_dir)\n",
    "        if could_load:\n",
    "            start_epoch = (int)(checkpoint_counter / self.iteration)\n",
    "            start_batch_id = checkpoint_counter - start_epoch * self.iteration\n",
    "            counter = checkpoint_counter\n",
    "            print(\" [*] Load SUCCESS\")\n",
    "        else:\n",
    "            start_epoch = 0\n",
    "            start_batch_id = 0\n",
    "            counter = 1\n",
    "            print(\" [!] Load FAILED...\")\n",
    "            \n",
    "        # check sample_dir    \n",
    "        check_folder(self.sample_dir)\n",
    "        \n",
    "        \n",
    "        '''Training loop for epoch'''\n",
    "        \n",
    "        # load data and extract features\n",
    "        f0s_A, coded_sps_norm_A, log_f0s_mean_A, log_f0s_std_A, coded_sps_mean_A, coded_sps_std_A = vocoder_extract(self.train_A_dir)\n",
    "        f0s_B, coded_sps_norm_B, log_f0s_mean_B, log_f0s_std_B, coded_sps_mean_B, coded_sps_std_B = vocoder_extract(self.train_B_dir)\n",
    "        \n",
    "        # load validation data\n",
    "        wavs_val_A = load_wavs(wav_dir=self.validation_A_dir, sr=self.sampling_rate)\n",
    "        wavs_val_B = load_wavs(wav_dir=self.validation_B_dir, sr=self.sampling_rate)\n",
    "\n",
    "        start_time = time.time()\n",
    "        for epoch in range(start_epoch, self.epoch):\n",
    "            \n",
    "            train_data_A, train_data_B = self.data_prepare(f0s_A, f0s_B, coded_sps_norm_A, coded_sps_norm_B)\n",
    "            print('Epoch[%d]: Input data sampled from %d A and %d B audio files: train_data_A' %(epoch, len(f0s_A), len(f0s_B)), np.shape(train_data_A), 'train_data_B', np.shape(train_data_B))\n",
    "\n",
    "            lr_D, lr_G = self.init_lr_D * pow(0.995, epoch), self.init_lr_G * pow(0.995, epoch)\n",
    "            for idx in range(start_batch_id, self.iteration):\n",
    "                style_a = np.random.normal(loc=0.0, scale=1.0, size=[self.batch_size, 1, self.style_dim])\n",
    "                style_b = np.random.normal(loc=0.0, scale=1.0, size=[self.batch_size, 1, self.style_dim])\n",
    "                \n",
    "                idx_A = idx%len(train_data_A)\n",
    "                idx_B = idx%len(train_data_B)\n",
    "                domain_A = train_data_A[idx_A:idx_A+1].astype('float32')\n",
    "                domain_B = train_data_B[idx_B:idx_B+1].astype('float32')\n",
    "                \n",
    "                train_feed_dict = {\n",
    "                    self.style_a : style_a,\n",
    "                    self.style_b : style_b,\n",
    "                    self.lr_D : lr_D,\n",
    "                    self.lr_G : lr_G,\n",
    "                    self.domain_A : domain_A,\n",
    "                    self.domain_B : domain_B\n",
    "                }\n",
    "                \n",
    "                # Update D\n",
    "                _, d_loss, summary_str = self.sess.run([self.D_optim, self.Discriminator_loss, self.D_loss], feed_dict = train_feed_dict)\n",
    "                self.writer.add_summary(summary_str, counter)\n",
    "            \n",
    "                # Update G\n",
    "                batch_A_audios, batch_B_audios, fake_A, fake_B, _, g_loss, summary_str = \\\n",
    "                self.sess.run([self.real_A, self.real_B, self.fake_A, self.fake_B, self.G_optim, \\\n",
    "                               self.Generator_loss, self.G_loss], feed_dict = train_feed_dict)\n",
    "                self.writer.add_summary(summary_str, counter)           \n",
    "            \n",
    "                # display training status\n",
    "                counter += 1\n",
    "                print(\"Epoch: [%2d] [%6d/%6d] time: %4.4f d_loss: %.8f, g_loss: %.8f\" \\\n",
    "                      % (epoch, idx, self.iteration, time.time() - start_time, d_loss, g_loss), end='\\r')\n",
    "            \n",
    "                # save generated samples\n",
    "                if np.mod(counter+1, self.sample_freq) == 0:\n",
    "                    # A2B\n",
    "                    idx_val_A = (counter//self.sample_freq)%len(wavs_val_A)\n",
    "                    wav = wavs_val_A[idx_val_A]\n",
    "                    wav = wav_padding(wav = wav, sr = self.sampling_rate, frame_period = self.frame_period, multiple = 4)\n",
    "                    # f0 conversion\n",
    "                    f0, timeaxis, sp, ap = world_decompose(wav = wav, fs = self.sampling_rate, frame_period = self.frame_period)\n",
    "                    f0_converted = pitch_conversion(f0 = f0, mean_log_src = log_f0s_mean_A, std_log_src = log_f0s_std_A, mean_log_target = log_f0s_mean_B, std_log_target = log_f0s_std_B)\n",
    "                    # sp normalization\n",
    "                    coded_sp = world_encode_spectral_envelop(sp = sp, fs = self.sampling_rate, dim = self.num_mcep)\n",
    "                    coded_sp_transposed = coded_sp.T\n",
    "                    coded_sp_norm = (coded_sp_transposed - coded_sps_mean_A) / coded_sps_std_A\n",
    "                    # random sampled style\n",
    "                    test_style_b = np.random.normal(loc=0.0, scale=1.0, size=[1, 1, self.style_dim])\n",
    "                    # sp conversion (A2B)\n",
    "                    coded_sp_converted_norm = self.sess.run(self.test_fake_B, feed_dict = {self.test_domain_A: np.array([coded_sp_norm]), self.test_style_b : test_style_b})\n",
    "                    coded_sp_converted_norm_recon = self.sess.run(self.test_recon_A, feed_dict = {self.test_domain_A: np.array([coded_sp_norm])})\n",
    "                    # [1,24,None]\n",
    "                    # de-normalization\n",
    "                    coded_sp_converted = coded_sp_converted_norm[0] * coded_sps_std_B + coded_sps_mean_B\n",
    "                    coded_sp_converted = coded_sp_converted.T\n",
    "                    coded_sp_converted = np.ascontiguousarray(coded_sp_converted)\n",
    "                    coded_sp_converted_recon = coded_sp_converted_norm_recon[0] * coded_sps_std_A + coded_sps_mean_A\n",
    "                    coded_sp_converted_recon = coded_sp_converted_recon.T\n",
    "                    coded_sp_converted_recon = np.ascontiguousarray(coded_sp_converted_recon)\n",
    "                    # combine converted f0, sp and ap\n",
    "                    decoded_sp_converted = world_decode_spectral_envelop(coded_sp = coded_sp_converted, fs = self.sampling_rate)\n",
    "                    decoded_sp_converted_recon = world_decode_spectral_envelop(coded_sp = coded_sp_converted_recon, fs = self.sampling_rate)                   \n",
    "                    wav_transformed = world_speech_synthesis(f0 = f0_converted, decoded_sp = decoded_sp_converted, ap = ap, fs = self.sampling_rate, frame_period = self.frame_period)\n",
    "                    wav_transformed_recon = world_speech_synthesis(f0 = f0, decoded_sp = decoded_sp_converted_recon, ap = ap, fs = self.sampling_rate, frame_period = self.frame_period)\n",
    "                    # write .wav file\n",
    "                    path_A2B = './{}/fake_A2B_id{:03d}_iter{:03d}K.wav'.format(self.sample_dir, idx_val_A, counter//1000)\n",
    "                    path_A2A = './{}/recon_A2A_id{:03d}_iter{:03d}K.wav'.format(self.sample_dir, idx_val_A, counter//1000)\n",
    "                    save_audio(wav=wav_transformed, path=path_A2B, sr=self.sampling_rate)\n",
    "                    save_audio(wav=wav_transformed_recon, path=path_A2A, sr=self.sampling_rate)\n",
    "                    \n",
    "                \n",
    "                # save checkpoints\n",
    "                if np.mod(counter+1, self.save_freq) == 0 :\n",
    "                    self.save(self.checkpoint_dir, counter)\n",
    "        \n",
    "            # After an epoch, start_batch_id reset to zero\n",
    "            # non-zero value is only for the first epoch after loading pre-trained model\n",
    "            start_batch_id = 0\n",
    "\n",
    "            # save model for final step\n",
    "            self.save(self.checkpoint_dir, counter)\n",
    "            \n",
    "        print(\" [*] Training finished!\")\n",
    "        \n",
    "    \n",
    "    def test(self):\n",
    "        # initialize all variables\n",
    "        tf.global_variables_initializer().run()\n",
    "               \n",
    "        # saver to save model\n",
    "        self.saver = tf.train.Saver()\n",
    "    \n",
    "        # load check-point if it exits\n",
    "        could_load, checkpoint_counter = self.load(self.checkpoint_dir)\n",
    "    \n",
    "        if could_load :\n",
    "            print(\" [*] Load SUCCESS\")\n",
    "        else :\n",
    "            print(\" [!] Load FAILED...\")\n",
    "    \n",
    "        # check result_dir\n",
    "        check_folder(self.result_dir)\n",
    "        \n",
    "        # write html for visual comparison\n",
    "        \n",
    "        \n",
    "        # Get statistic from train_A, train_B\n",
    "        _, _, log_f0s_mean_A, log_f0s_std_A, coded_sps_A_mean, coded_sps_A_std = vocoder_extract(self.train_A_dir)\n",
    "        _, _, log_f0s_mean_B, log_f0s_std_B, coded_sps_B_mean, coded_sps_B_std = vocoder_extract(self.train_B_dir) \n",
    "        print('std_log_src:', log_f0s_std_A, 'std_log_target', log_f0s_std_B)\n",
    "        \n",
    "        \n",
    "        # A2B\n",
    "        test_files_A = self.validation_A_dir\n",
    "        for i in range(len(test_files_A)):\n",
    "            file = test_files_A[i]\n",
    "            # filepath = os.path.join(self.validation_A_dir, file)\n",
    "            wav, _ = librosa.load(file, sr = self.sampling_rate, mono = True)\n",
    "            wav = wav_padding(wav = wav, sr = self.sampling_rate, frame_period = self.frame_period, multiple = 4)\n",
    "            f0, timeaxis, sp, ap = world_decompose(wav = wav, fs = self.sampling_rate, frame_period = self.frame_period)\n",
    "            \n",
    "            # f0 conversion\n",
    "            f0_converted = pitch_conversion(f0 = f0, mean_log_src = log_f0s_mean_A, std_log_src = log_f0s_std_A, mean_log_target = log_f0s_mean_B, std_log_target = log_f0s_std_B)\n",
    "\n",
    "            # sp normalization\n",
    "            coded_sp = world_encode_spectral_envelop(sp = sp, fs = self.sampling_rate, dim = self.num_mcep)\n",
    "            coded_sp_transposed = coded_sp.T\n",
    "            coded_sp_norm = (coded_sp_transposed - coded_sps_A_mean) / coded_sps_A_std\n",
    "            \n",
    "            # random sampled style\n",
    "            test_style_b = np.random.normal(loc=0.0, scale=1.0, size=[1, 1, self.style_dim])\n",
    "            \n",
    "            # sp conversion (A2B)\n",
    "            coded_sp_converted_norm = self.sess.run(self.test_fake_B, feed_dict = {self.test_domain_A: np.array([coded_sp_norm]), self.test_style_b : test_style_b})\n",
    "            # [1,24,None]\n",
    "            \n",
    "            # print('coded_sp_converted_norm', np.shape(coded_sp_converted_norm[0]), 'coded_sps_B_mean', np.shape(coded_sps_B_mean), 'coded_sps_B_std:', np.shape(coded_sps_B_std))          \n",
    "            coded_sp_converted = coded_sp_converted_norm[0] * coded_sps_B_std + coded_sps_B_mean\n",
    "            coded_sp_converted = coded_sp_converted.T\n",
    "            coded_sp_converted = np.ascontiguousarray(coded_sp_converted)\n",
    "            decoded_sp_converted = world_decode_spectral_envelop(coded_sp = coded_sp_converted, fs = self.sampling_rate)\n",
    "            wav_transformed = world_speech_synthesis(f0 = f0_converted, decoded_sp = decoded_sp_converted, ap = ap, fs = self.sampling_rate, frame_period = self.frame_period)\n",
    "            librosa.output.write_wav(os.path.join(self.result_dir, os.path.basename(file)), wav_transformed, self.sampling_rate)\n",
    "            \n",
    "            print('converting test samples: [%d/%d]' %(i+1, len(test_files_A)), end='\\r')\n",
    "            \n",
    "        print(\" [*] Testing finished!\")\n",
    "        \n",
    "        \n",
    "        \n",
    "    @property\n",
    "    def model_dir(self):\n",
    "        return \"{}_{}_{}\".format(self.model_name, self.dataset_name, self.gan_type)\n",
    "    \n",
    "    \n",
    "    def load(self, checkpoint_dir):\n",
    "        import re\n",
    "        print(\" [*] Reading checkpoints...\")\n",
    "        checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\n",
    "\n",
    "        ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\n",
    "        if ckpt and ckpt.model_checkpoint_path:\n",
    "            ckpt_name = os.path.basename(ckpt.model_checkpoint_path)\n",
    "            self.saver.restore(self.sess, os.path.join(checkpoint_dir, ckpt_name))\n",
    "            counter = int(next(re.finditer(\"(\\d+)(?!.*\\d)\", ckpt_name)).group(0))\n",
    "            print(\" [*] Success to read {}\".format(ckpt_name))\n",
    "            return True, counter\n",
    "        else:\n",
    "            print(\" [*] Failed to find a checkpoint\")\n",
    "            return False, 0\n",
    "        \n",
    "        \n",
    "    def save(self, checkpoint_dir, step):\n",
    "        checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\n",
    "\n",
    "        if not os.path.exists(checkpoint_dir):\n",
    "            os.makedirs(checkpoint_dir)\n",
    "\n",
    "        self.saver.save(self.sess, os.path.join(checkpoint_dir, self.model_name + '.model'), global_step=step)        \n",
    "        \n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " [*] Reading checkpoints...\n",
      "INFO:tensorflow:Restoring parameters from checkpoint\\EmoMUNIT_ang2neu_lsgan\\EmoMUNIT.model-2001\n",
      " [*] Success to read EmoMUNIT.model-2001\n",
      " [*] Load SUCCESS\n",
      " [*] Training finished!\n",
      " [*] Reading checkpoints...\n",
      "INFO:tensorflow:Restoring parameters from checkpoint\\EmoMUNIT_ang2neu_lsgan\\EmoMUNIT.model-2001\n",
      " [*] Success to read EmoMUNIT.model-2001\n",
      " [*] Load SUCCESS\n",
      "std_log_src: 0.2626334012716565 std_log_target 0.4202389016849519\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "listdir: illegal type for path parameter",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-16-60adc8a5ae57>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbuild_model\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m     \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtest\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-15-67966430a264>\u001b[0m in \u001b[0;36mtest\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    384\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    385\u001b[0m         \u001b[1;31m# A2B\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 386\u001b[1;33m         \u001b[0mtest_files_A\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlistdir\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalidation_A_dir\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    387\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_files_A\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    388\u001b[0m             \u001b[0mfile\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtest_files_A\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: listdir: illegal type for path parameter"
     ]
    }
   ],
   "source": [
    "with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess:\n",
    "    model = EmoMUNIT(sess)\n",
    "    model.build_model()\n",
    "    model.train()\n",
    "    model.test()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Module: CYCLE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils import *\n",
    "from ops_c import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator(inputs, reuse = False, scope_name = 'generator'):\n",
    "\n",
    "    # inputs has shape [batch_size, num_features, time]\n",
    "    # we need to convert it to [batch_size, time, num_features] for 1D convolution\n",
    "    inputs = tf.transpose(inputs, perm = [0, 2, 1], name = 'input_transpose')\n",
    "\n",
    "    with tf.variable_scope(scope_name) as scope:\n",
    "        # Discriminator would be reused in CycleGAN\n",
    "        if reuse:\n",
    "            scope.reuse_variables()\n",
    "        else:\n",
    "            assert scope.reuse is False\n",
    "\n",
    "        h1 = conv1d_layer(inputs = inputs, filters = 128, kernel_size = 15, strides = 1, activation = None, name = 'h1_conv')\n",
    "        h1_gates = conv1d_layer(inputs = inputs, filters = 128, kernel_size = 15, strides = 1, activation = None, name = 'h1_conv_gates')\n",
    "        h1_glu = gated_linear_layer(inputs = h1, gates = h1_gates, name = 'h1_glu')\n",
    "\n",
    "        # Downsample\n",
    "        d1 = downsample1d_block(inputs = h1_glu, filters = 256, kernel_size = 5, strides = 2, name_prefix = 'downsample1d_block1_')\n",
    "        d2 = downsample1d_block(inputs = d1, filters = 512, kernel_size = 5, strides = 2, name_prefix = 'downsample1d_block2_')\n",
    "\n",
    "        # Residual blocks\n",
    "        r1 = residual1d_block(inputs = d2, filters = 1024, kernel_size = 3, strides = 1, name_prefix = 'residual1d_block1_')\n",
    "        r2 = residual1d_block(inputs = r1, filters = 1024, kernel_size = 3, strides = 1, name_prefix = 'residual1d_block2_')\n",
    "        r3 = residual1d_block(inputs = r2, filters = 1024, kernel_size = 3, strides = 1, name_prefix = 'residual1d_block3_')\n",
    "        r4 = residual1d_block(inputs = r3, filters = 1024, kernel_size = 3, strides = 1, name_prefix = 'residual1d_block4_')\n",
    "        r5 = residual1d_block(inputs = r4, filters = 1024, kernel_size = 3, strides = 1, name_prefix = 'residual1d_block5_')\n",
    "        r6 = residual1d_block(inputs = r5, filters = 1024, kernel_size = 3, strides = 1, name_prefix = 'residual1d_block6_')\n",
    "\n",
    "        # Upsample\n",
    "        u1 = upsample1d_block(inputs = r6, filters = 1024, kernel_size = 5, strides = 1, shuffle_size = 2, name_prefix = 'upsample1d_block1_')\n",
    "        u2 = upsample1d_block(inputs = u1, filters = 512, kernel_size = 5, strides = 1, shuffle_size = 2, name_prefix = 'upsample1d_block2_')\n",
    "\n",
    "        # Output\n",
    "        o1 = conv1d_layer(inputs = u2, filters = 24, kernel_size = 15, strides = 1, activation = None, name = 'o1_conv')\n",
    "        o2 = tf.transpose(o1, perm = [0, 2, 1], name = 'output_transpose')\n",
    "\n",
    "    return o2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discriminator(inputs, reuse = False, scope_name = 'discriminator'):\n",
    "\n",
    "    # inputs has shape [batch_size, num_features, time]\n",
    "    # we need to add channel for 2D convolution [batch_size, num_features, time, 1]\n",
    "    inputs = tf.expand_dims(inputs, -1)\n",
    "\n",
    "    with tf.variable_scope(scope_name) as scope:\n",
    "        # Discriminator would be reused in CycleGAN\n",
    "        if reuse:\n",
    "            scope.reuse_variables()\n",
    "        else:\n",
    "            assert scope.reuse is False\n",
    "\n",
    "        h1 = conv2d_layer(inputs = inputs, filters = 128, kernel_size = [3, 3], strides = [1, 2], activation = None, name = 'h1_conv')\n",
    "        h1_gates = conv2d_layer(inputs = inputs, filters = 128, kernel_size = [3, 3], strides = [1, 2], activation = None, name = 'h1_conv_gates')\n",
    "        h1_glu = gated_linear_layer(inputs = h1, gates = h1_gates, name = 'h1_glu')\n",
    "\n",
    "        # Downsample\n",
    "        d1 = downsample2d_block(inputs = h1_glu, filters = 256, kernel_size = [3, 3], strides = [2, 2], name_prefix = 'downsample2d_block1_')\n",
    "        d2 = downsample2d_block(inputs = d1, filters = 512, kernel_size = [3, 3], strides = [2, 2], name_prefix = 'downsample2d_block2_')\n",
    "        d3 = downsample2d_block(inputs = d2, filters = 1024, kernel_size = [6, 3], strides = [1, 2], name_prefix = 'downsample2d_block3_')\n",
    "\n",
    "        # Output\n",
    "        o1 = tf.layers.dense(inputs = d3, units = 1, activation = tf.nn.sigmoid)\n",
    "\n",
    "        return o1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discriminator_loss(type, real, fake):\n",
    "    real = [real]\n",
    "    fake = [fake]\n",
    "    \n",
    "    n_scale = len(real)\n",
    "    loss = []\n",
    "\n",
    "    real_loss = 0\n",
    "    fake_loss = 0\n",
    "\n",
    "    for i in range(n_scale) :\n",
    "        if type == 'lsgan' :\n",
    "            real_loss = tf.reduce_mean(tf.squared_difference(real[i], 1.0))\n",
    "            fake_loss = tf.reduce_mean(tf.square(fake[i]))\n",
    "\n",
    "        if type == 'gan' :\n",
    "            real_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.ones_like(real[i]), logits=real[i]))\n",
    "            fake_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.zeros_like(fake[i]), logits=fake[i]))\n",
    "\n",
    "        loss.append(real_loss + fake_loss)\n",
    "\n",
    "    return sum(loss)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator_loss(type, fake):\n",
    "    fake = [fake]\n",
    "    n_scale = len(fake)\n",
    "    loss = []\n",
    "\n",
    "    fake_loss = 0\n",
    "\n",
    "    for i in range(n_scale) :\n",
    "        if type == 'lsgan' :\n",
    "            fake_loss = tf.reduce_mean(tf.squared_difference(fake[i], 1.0))\n",
    "\n",
    "        if type == 'gan' :\n",
    "            fake_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.ones_like(fake[i]), logits=fake[i]))\n",
    "\n",
    "        loss.append(fake_loss)\n",
    "\n",
    "    return sum(loss)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CYCLE(object):\n",
    "    def __init__(self, sess, folder='S01/', source='neu', target='sad'):\n",
    "        \n",
    "        self.train_A_dir = './../../../Database/Emotion/' + folder + source + '_' + target + '/' + source\n",
    "        self.train_B_dir = './../../../Database/Emotion/' + folder + source + '_' + target + '/' + target\n",
    "        self.validation_A_dir = './../../../Database/Emotion/' + folder + source + '_' + target + '/' + 'val_' + source\n",
    "        self.validation_B_dir = './../../../Database/Emotion/' + folder + source + '_' + target + '/' + 'val_' + target\n",
    "        \n",
    "        self.discriminator = discriminator\n",
    "        self.generator = generator\n",
    "        \n",
    "        self.batch_size = 1\n",
    "        self.max_samples = 1000\n",
    "        \n",
    "        self.frame_period = 5.0\n",
    "        self.num_mcep = 24\n",
    "        self.audio_ch = self.num_mcep\n",
    "        self.audio_len = 128                              # audio_len == n_frames, time_length\n",
    "        self.sampling_rate = 16000\n",
    "        \n",
    "        self.input_shape = [None, self.audio_ch, None]    # [batch_size, num_features, num_frames]\n",
    "    \n",
    "        self.init_lr_G = 0.0002\n",
    "        self.init_lr_D = 0.0001\n",
    "        self.lr_G_decay = self.init_lr_G / 200000\n",
    "        self.lr_D_decay = self.init_lr_D / 200000  \n",
    "        \n",
    "        self.cycle_w = 10.0\n",
    "        self.identity_w = 5.0\n",
    "        \n",
    "        \n",
    "        self.dataset_name = source + '_' + target\n",
    "        self.model_name = 'C'\n",
    "        self.gan_type = 'lsgan'\n",
    "        self.log_dir = \"logs/\" # + datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
    "        self.sample_dir = 'samples'\n",
    "        self.checkpoint_dir = 'checkpoint'\n",
    "        self.A2B_dir = 'results/' + source + '2' + target\n",
    "        self.B2A_dir = 'results/' + target + '2' + source\n",
    "        \n",
    "        self.sample_freq = 1000\n",
    "        self.save_freq = 1000\n",
    "        \n",
    "        self.sess = sess\n",
    "        self.epoch = 200\n",
    "        self.iteration = 1000\n",
    "\n",
    "\n",
    "    def build_model(self):\n",
    "        # Placeholders for learning rate\n",
    "        self.lr_D = tf.placeholder(tf.float32, name='learning_rate_D')\n",
    "        self.lr_G = tf.placeholder(tf.float32, name='learning_rate_G')\n",
    "        \n",
    "        # Placeholders for real training samples\n",
    "        self.x_a = tf.placeholder(tf.float32, shape=self.input_shape, name='real_a')\n",
    "        self.x_b = tf.placeholder(tf.float32, shape=self.input_shape, name='real_b')\n",
    "        \n",
    "        # Placeholder for real test samples\n",
    "        self.x_a_test = tf.placeholder(tf.float32, shape = self.input_shape, name = 'real_a_test')\n",
    "        self.x_b_test = tf.placeholder(tf.float32, shape = self.input_shape, name = 'real_b_test')\n",
    "        \n",
    "        # Generation\n",
    "        x_ba = self.generator(inputs = self.x_a, reuse = False, scope_name = 'generator_A2B')\n",
    "        x_aba = self.generator(inputs = x_ba, reuse = False, scope_name = 'generator_B2A')\n",
    "        \n",
    "        x_ab = self.generator(inputs = self.x_b, reuse = True, scope_name = 'generator_B2A')\n",
    "        x_bab = self.generator(inputs = x_ab, reuse = True, scope_name = 'generator_A2B')        \n",
    "        \n",
    "        x_aa = self.generator(inputs = self.x_a, reuse = True, scope_name = 'generator_B2A')\n",
    "        x_bb = self.generator(inputs = self.x_b, reuse = True, scope_name = 'generator_A2B')\n",
    "        \n",
    "        # Discrimination\n",
    "        fake_A_logit = self.discriminator(inputs = x_ab, reuse = False, scope_name = 'discriminator_A')\n",
    "        fake_B_logit = self.discriminator(inputs = x_ba, reuse = False, scope_name = 'discriminator_B')\n",
    "        \n",
    "        real_A_logit = self.discriminator(inputs = self.x_a, reuse = True, scope_name = 'discriminator_A')\n",
    "        real_B_logit = self.discriminator(inputs = self.x_b, reuse = True, scope_name = 'discriminator_B')\n",
    "        \n",
    "        # Reserved for test\n",
    "        x_ba_test = self.generator(inputs = self.x_a_test, reuse = True, scope_name = 'generator_A2B')\n",
    "        x_aba_test = self.generator(inputs = x_ba_test, reuse = True, scope_name = 'generator_B2A')\n",
    "        \n",
    "        x_ab_test = self.generator(inputs = self.x_b_test, reuse = True, scope_name = 'generator_B2A')\n",
    "        x_bab_test = self.generator(inputs = x_ab_test, reuse = True, scope_name = 'generator_A2B')\n",
    "        \n",
    "        \n",
    "        \"\"\" Define Loss \"\"\"\n",
    "        # Cycle loss\n",
    "        cycle_loss = l1_loss(y = self.x_a, y_hat = x_aba) + l1_loss(y = self.x_b, y_hat = x_bab)\n",
    "        \n",
    "        # Identity loss\n",
    "        identity_loss = l1_loss(y = self.x_a, y_hat = x_aa) + l1_loss(y = self.x_b, y_hat = x_bb)\n",
    "\n",
    "        # adversarial Loss\n",
    "        G_ad_loss_a = l2_loss(y=tf.ones_like(fake_A_logit), y_hat=fake_A_logit)\n",
    "        G_ad_loss_b = l2_loss(y=tf.ones_like(fake_B_logit), y_hat=fake_B_logit)\n",
    "#         G_ad_loss_a = generator_loss(self.gan_type, fake_A_logit)\n",
    "#         G_ad_loss_b = generator_loss(self.gan_type, fake_B_logit)\n",
    "    \n",
    "        # Generator loss\n",
    "        self.Generator_loss = G_ad_loss_a + G_ad_loss_b + self.cycle_w*cycle_loss + self.identity_w*identity_loss\n",
    "    \n",
    "    \n",
    "        # real/fake Loss\n",
    "        D_loss_A_real = l2_loss(y = tf.ones_like(real_A_logit), y_hat = real_A_logit)\n",
    "        D_loss_A_fake = l2_loss(y = tf.zeros_like(fake_A_logit), y_hat = fake_A_logit)\n",
    "        D_ad_loss_a = (D_loss_A_real + D_loss_A_fake) / 2.0\n",
    "        \n",
    "        D_loss_B_real = l2_loss(y = tf.ones_like(real_B_logit), y_hat = real_B_logit)\n",
    "        D_loss_B_fake = l2_loss(y = tf.zeros_like(fake_B_logit), y_hat = fake_B_logit)\n",
    "        D_ad_loss_b = (D_loss_B_real + D_loss_B_fake) / 2.0\n",
    "#         D_ad_loss_a = discriminator_loss(self.gan_type, real_A_logit, fake_A_logit)\n",
    "#         D_ad_loss_b = discriminator_loss(self.gan_type, real_B_logit, fake_B_logit)\n",
    "        \n",
    "        # Discrimination Loss \n",
    "        self.Discriminator_loss = D_ad_loss_a + D_ad_loss_b\n",
    "    \n",
    "    \n",
    "        \"\"\" Training Variables \"\"\"\n",
    "        # Categorize variables to optimize D_vars and G_vars separately\n",
    "        t_vars = tf.trainable_variables()\n",
    "        G_vars = [var for var in t_vars if 'generator' in var.name]\n",
    "        D_vars = [var for var in t_vars if 'discriminator' in var.name]\n",
    "\n",
    "        self.G_optim = tf.train.AdamOptimizer(self.lr_G, beta1=0.5, beta2=0.999).minimize(self.Generator_loss, var_list=G_vars)\n",
    "        self.D_optim = tf.train.AdamOptimizer(self.lr_D, beta1=0.5, beta2=0.999).minimize(self.Discriminator_loss, var_list=D_vars)\n",
    "    \n",
    "    \n",
    "        \"\"\"\" Summary \"\"\"\n",
    "        self.all_G_loss = tf.summary.scalar(\"Generator_loss\", self.Generator_loss)\n",
    "        self.all_D_loss = tf.summary.scalar(\"Discriminator_loss\", self.Discriminator_loss)\n",
    "        \n",
    "        self.Cycle_loss = tf.summary.scalar(\"Cycle_loss\", cycle_loss)\n",
    "        self.Identity_loss = tf.summary.scalar(\"Identity_loss\", identity_loss)\n",
    "\n",
    "        self.G_ad_loss_a = tf.summary.scalar(\"G_ad_loss_a\", G_ad_loss_a)\n",
    "        self.G_ad_loss_b = tf.summary.scalar(\"G_ad_loss_b\", G_ad_loss_b)\n",
    "        \n",
    "        self.D_ad_loss_a = tf.summary.scalar(\"D_ad_loss_a\", D_ad_loss_a)\n",
    "        self.D_ad_loss_b = tf.summary.scalar(\"D_ad_loss_b\", D_ad_loss_b)\n",
    "\n",
    "        self.G_loss = tf.summary.merge([self.G_ad_loss_a, self.G_ad_loss_b, self.Cycle_loss, self.Identity_loss, self.all_G_loss])\n",
    "        self.D_loss = tf.summary.merge([self.D_ad_loss_a, self.D_ad_loss_b, self.all_D_loss])\n",
    "    \n",
    "    \n",
    "        \"\"\" Speech: real and fake \"\"\"\n",
    "        self.real_A = self.x_a\n",
    "        self.real_B = self.x_b\n",
    "\n",
    "        self.fake_A = x_ab\n",
    "        self.fake_B = x_ba\n",
    "        \n",
    "        self.test_fake_A = x_ab_test\n",
    "        self.test_fake_B = x_ba_test\n",
    "        \n",
    "        self.test_cycle_A = x_aba_test\n",
    "        self.test_cycle_B = x_bab_test\n",
    "    \n",
    "    \n",
    "    def data_prepare(self, f0s_A, f0s_B, coded_sps_norm_A, coded_sps_norm_B):\n",
    "        \n",
    "        train_data_A = sample_train_data03(sps=list(coded_sps_norm_A), f0s=list(f0s_A), n_frames=self.audio_len)\n",
    "        train_data_B = sample_train_data03(sps=list(coded_sps_norm_B), f0s=list(f0s_B), n_frames=self.audio_len)\n",
    "\n",
    "        minlen = min(len(train_data_A), len(train_data_B))\n",
    "        np.random.shuffle(train_data_A)\n",
    "        np.random.shuffle(train_data_B)\n",
    "        train_data_A = np.array(train_data_A[0:minlen])\n",
    "        train_data_B = np.array(train_data_B[0:minlen])\n",
    "\n",
    "        return train_data_A, train_data_B\n",
    "    \n",
    "    \n",
    "    def train(self):\n",
    "        # initialize all variables\n",
    "        tf.global_variables_initializer().run()\n",
    "        \n",
    "        # saver to save model\n",
    "        self.saver = tf.train.Saver()\n",
    "        \n",
    "        # summary writer\n",
    "        self.writer = tf.summary.FileWriter(self.log_dir + '/' + self.model_dir, self.sess.graph)\n",
    "        \n",
    "        # restore check-point if it exits\n",
    "        could_load, checkpoint_counter = self.load(self.checkpoint_dir)\n",
    "        if could_load:\n",
    "            start_epoch = (int)(checkpoint_counter / self.iteration)\n",
    "            start_batch_id = checkpoint_counter - start_epoch * self.iteration\n",
    "            counter = checkpoint_counter\n",
    "            print(\" [*] Load SUCCESS\")\n",
    "        else:\n",
    "            start_epoch = 0\n",
    "            start_batch_id = 0\n",
    "            counter = 1\n",
    "            print(\" [!] Load FAILED...\")\n",
    "            \n",
    "        # check sample_dir    \n",
    "        check_folder(self.sample_dir)\n",
    "        \n",
    "        \n",
    "        '''Training loop for epoch'''\n",
    "        \n",
    "        # load data and extract features\n",
    "        f0s_A, coded_sps_norm_A, log_f0s_mean_A, log_f0s_std_A, coded_sps_mean_A, coded_sps_std_A = vocoder_extract(self.train_A_dir)\n",
    "        f0s_B, coded_sps_norm_B, log_f0s_mean_B, log_f0s_std_B, coded_sps_mean_B, coded_sps_std_B = vocoder_extract(self.train_B_dir)\n",
    "        \n",
    "        # load validation data\n",
    "        wavs_val_A = load_wavs(wav_dir=self.validation_A_dir, sr=self.sampling_rate)\n",
    "        wavs_val_B = load_wavs(wav_dir=self.validation_B_dir, sr=self.sampling_rate)\n",
    "\n",
    "        start_time = time.time()\n",
    "        for epoch in range(start_epoch, self.epoch):\n",
    "            \n",
    "            train_data_A, train_data_B = self.data_prepare(f0s_A, f0s_B, coded_sps_norm_A, coded_sps_norm_B)\n",
    "            print('Epoch[%d]: Input data sampled from %d A and %d B audio files: train_data_A' %(epoch, len(f0s_A), len(f0s_B)), np.shape(train_data_A), 'train_data_B', np.shape(train_data_B))\n",
    "\n",
    "            lr_D = self.init_lr_D\n",
    "            lr_G = self.init_lr_G\n",
    "            if counter > 20000:\n",
    "                self.identity_w = 0.0                            # deactivate identity loss\n",
    "#             if counter > 150000:\n",
    "#                 lr_G = max(0.0, lr_G - self.lr_G_decay)\n",
    "#                 lr_D = max(0.0, lr_D - self.lr_D_decay)\n",
    "#             lr_D = self.init_lr_D * pow(0.995, epoch)\n",
    "#             lr_G = self.init_lr_G * pow(0.995, epoch)\n",
    "\n",
    "            if counter < 100000:\n",
    "                G_iter = 2\n",
    "            elif 100000 <= counter < 150000:\n",
    "                G_iter = np.random.randint(2) + 1\n",
    "            else:\n",
    "                G_iter = 1\n",
    "\n",
    "#             n_iter = len(train_data_A)\n",
    "            n_iter = self.iteration\n",
    "        \n",
    "            for idx in range(start_batch_id, n_iter):\n",
    "\n",
    "                idx_A = idx%len(train_data_A)\n",
    "                idx_B = idx%len(train_data_B)\n",
    "                domain_A = train_data_A[idx_A:idx_A+1].astype('float32')\n",
    "                domain_B = train_data_B[idx_B:idx_B+1].astype('float32')\n",
    "                \n",
    "                train_feed_dict = {\n",
    "                    self.lr_D : lr_D,\n",
    "                    self.lr_G : lr_G,\n",
    "                    self.x_a : domain_A,\n",
    "                    self.x_b : domain_B\n",
    "                }\n",
    "                \n",
    "                # Update D\n",
    "                if counter % G_iter == G_iter - 1:\n",
    "                    _, d_loss, summary_str = self.sess.run([self.D_optim, self.Discriminator_loss, self.D_loss], feed_dict = train_feed_dict)\n",
    "                    self.writer.add_summary(summary_str, counter)\n",
    "            \n",
    "                # Update G\n",
    "                batch_A_audios, batch_B_audios, fake_A, fake_B, _, g_loss, summary_str = \\\n",
    "                self.sess.run([self.real_A, self.real_B, self.fake_A, self.fake_B, self.G_optim, \\\n",
    "                               self.Generator_loss, self.G_loss], feed_dict = train_feed_dict)\n",
    "                self.writer.add_summary(summary_str, counter)\n",
    "            \n",
    "            \n",
    "                ''' Display Training Status '''\n",
    "                counter += 1\n",
    "                print(\"Epoch: [%2d] [%6d/%6d] time: %4.4f d_loss: %.8f, g_loss: %.8f\" \\\n",
    "                      % (epoch, idx, n_iter, time.time() - start_time, d_loss, g_loss), end='\\r')\n",
    "            \n",
    "                # save generated samples\n",
    "                if np.mod(counter+1, self.sample_freq) == 0:\n",
    "                    # A2B\n",
    "                    idx_val_A = (counter//self.sample_freq)%len(wavs_val_A)\n",
    "                    wav = wavs_val_A[idx_val_A]\n",
    "                    wav = wav_padding(wav = wav, sr = self.sampling_rate, frame_period = self.frame_period, multiple = 4)\n",
    "                    \n",
    "                    # f0 conversion\n",
    "                    f0, timeaxis, sp, ap = world_decompose(wav = wav, fs = self.sampling_rate, frame_period = self.frame_period)\n",
    "                    f0_converted = pitch_conversion(f0 = f0, mean_log_src = log_f0s_mean_A, std_log_src = log_f0s_std_A, mean_log_target = log_f0s_mean_B, std_log_target = log_f0s_std_B)\n",
    "                    \n",
    "                    # sp normalization\n",
    "                    coded_sp = world_encode_spectral_envelop(sp = sp, fs = self.sampling_rate, dim = self.num_mcep)\n",
    "                    coded_sp_transposed = coded_sp.T\n",
    "                    coded_sp_norm = (coded_sp_transposed - coded_sps_mean_A) / coded_sps_std_A\n",
    "\n",
    "                    # sp conversion (A2B)\n",
    "                    coded_sp_converted_norm = self.sess.run(self.test_fake_B, feed_dict = {self.x_a_test: np.array([coded_sp_norm])})\n",
    "                    coded_sp_converted_norm_cycle = self.sess.run(self.test_cycle_A, feed_dict = {self.x_a_test: np.array([coded_sp_norm])})\n",
    "                    # [1,24,None]\n",
    "                    \n",
    "                    # de-normalization\n",
    "                    coded_sp_converted = coded_sp_converted_norm[0] * coded_sps_std_B + coded_sps_mean_B\n",
    "                    coded_sp_converted = coded_sp_converted.T\n",
    "                    coded_sp_converted = np.ascontiguousarray(coded_sp_converted)\n",
    "                    coded_sp_converted_cycle = coded_sp_converted_norm_cycle[0] * coded_sps_std_A + coded_sps_mean_A\n",
    "                    coded_sp_converted_cycle = coded_sp_converted_cycle.T\n",
    "                    coded_sp_converted_cycle = np.ascontiguousarray(coded_sp_converted_cycle)\n",
    "                    \n",
    "                    # combine converted f0, sp and ap\n",
    "                    decoded_sp_converted = world_decode_spectral_envelop(coded_sp = coded_sp_converted, fs = self.sampling_rate)\n",
    "                    decoded_sp_converted_cycle = world_decode_spectral_envelop(coded_sp = coded_sp_converted_cycle, fs = self.sampling_rate)                   \n",
    "                    wav_transformed = world_speech_synthesis(f0 = f0_converted, decoded_sp = decoded_sp_converted, ap = ap, fs = self.sampling_rate, frame_period = self.frame_period)\n",
    "                    wav_transformed_cycle = world_speech_synthesis(f0 = f0, decoded_sp = decoded_sp_converted_cycle, ap = ap, fs = self.sampling_rate, frame_period = self.frame_period)\n",
    "                    \n",
    "                    # write .wav file\n",
    "                    path_A2B = './{}/fake_A2B_id{:03d}_iter{:03d}K.wav'.format(self.sample_dir, idx_val_A, counter//1000)\n",
    "                    path_A2A = './{}/cycle_A2A_id{:03d}_iter{:03d}K.wav'.format(self.sample_dir, idx_val_A, counter//1000)\n",
    "                    save_audio(wav=wav_transformed, path=path_A2B, sr=self.sampling_rate)\n",
    "                    save_audio(wav=wav_transformed_cycle, path=path_A2A, sr=self.sampling_rate)\n",
    "                    \n",
    "                \n",
    "                # save checkpoints\n",
    "                if np.mod(counter+1, self.save_freq) == 0 :\n",
    "                    self.save(self.checkpoint_dir, counter)\n",
    "        \n",
    "            # After an epoch, start_batch_id reset to zero\n",
    "            # non-zero value is only for the first epoch after loading pre-trained model\n",
    "            start_batch_id = 0\n",
    "\n",
    "            # save model for final step\n",
    "            self.save(self.checkpoint_dir, counter)\n",
    "            \n",
    "        print(\" [*] Training finished!\")\n",
    "        \n",
    "    \n",
    "    def test(self):\n",
    "        # initialize all variables\n",
    "        tf.global_variables_initializer().run()\n",
    "               \n",
    "        # saver to save model\n",
    "        self.saver = tf.train.Saver()\n",
    "    \n",
    "        # load check-point if it exits\n",
    "        could_load, checkpoint_counter = self.load(self.checkpoint_dir)\n",
    "    \n",
    "        if could_load :\n",
    "            print(\" [*] Load SUCCESS\")\n",
    "        else :\n",
    "            print(\" [!] Load FAILED...\")\n",
    "    \n",
    "        # check result_dir\n",
    "        check_folder(self.A2B_dir)\n",
    "        check_folder(self.B2A_dir)\n",
    "        \n",
    "        # Get statistic from train_A, train_B\n",
    "        _, _, log_f0s_mean_A, log_f0s_std_A, coded_sps_A_mean, coded_sps_A_std = vocoder_extract(self.train_A_dir)\n",
    "        _, _, log_f0s_mean_B, log_f0s_std_B, coded_sps_B_mean, coded_sps_B_std = vocoder_extract(self.train_B_dir) \n",
    "        print('std_log_src:', log_f0s_std_A, 'std_log_target', log_f0s_std_B)\n",
    "        \n",
    "        \n",
    "        # A2B\n",
    "        test_files_A = os.listdir(self.validation_A_dir)\n",
    "        for i in range(len(test_files_A)):\n",
    "            file = test_files_A[i]\n",
    "            filepath = os.path.join(self.validation_A_dir, file)\n",
    "            wav, _ = librosa.load(filepath, sr = self.sampling_rate, mono = True)\n",
    "            wav = wav_padding(wav = wav, sr = self.sampling_rate, frame_period = self.frame_period, multiple = 4)\n",
    "            f0, timeaxis, sp, ap = world_decompose(wav = wav, fs = self.sampling_rate, frame_period = self.frame_period)\n",
    "            \n",
    "            # f0 conversion\n",
    "            f0_converted = pitch_conversion(f0 = f0, mean_log_src = log_f0s_mean_A, std_log_src = log_f0s_std_A, mean_log_target = log_f0s_mean_B, std_log_target = log_f0s_std_B)\n",
    "\n",
    "            # sp normalization\n",
    "            coded_sp = world_encode_spectral_envelop(sp = sp, fs = self.sampling_rate, dim = self.num_mcep)\n",
    "            coded_sp_transposed = coded_sp.T\n",
    "            coded_sp_norm = (coded_sp_transposed - coded_sps_A_mean) / coded_sps_A_std\n",
    "            \n",
    "            # sp conversion (A2B)\n",
    "            coded_sp_converted_norm = self.sess.run(self.test_fake_B, feed_dict = {self.x_a_test: np.array([coded_sp_norm])})\n",
    "            # [1,24,None]\n",
    "            \n",
    "            # print('coded_sp_converted_norm', np.shape(coded_sp_converted_norm[0]), 'coded_sps_B_mean', np.shape(coded_sps_B_mean), 'coded_sps_B_std:', np.shape(coded_sps_B_std))          \n",
    "            coded_sp_converted = coded_sp_converted_norm[0] * coded_sps_B_std + coded_sps_B_mean\n",
    "            coded_sp_converted = coded_sp_converted.T\n",
    "            coded_sp_converted = np.ascontiguousarray(coded_sp_converted)\n",
    "            decoded_sp_converted = world_decode_spectral_envelop(coded_sp = coded_sp_converted, fs = self.sampling_rate)\n",
    "            wav_transformed = world_speech_synthesis(f0 = f0_converted, decoded_sp = decoded_sp_converted, ap = ap, fs = self.sampling_rate, frame_period = self.frame_period)\n",
    "            librosa.output.write_wav(os.path.join(self.A2B_dir, os.path.basename(file)), wav_transformed, self.sampling_rate)\n",
    "            \n",
    "            print('converting test samples A2B: [%d/%d]' %(i+1, len(test_files_A)), end='\\r')\n",
    "        \n",
    "        # B2A\n",
    "        test_files_B = os.listdir(self.validation_B_dir)\n",
    "        for i in range(len(test_files_B)):\n",
    "            file = test_files_B[i]\n",
    "            filepath = os.path.join(self.validation_B_dir, file)\n",
    "            wav, _ = librosa.load(filepath, sr = self.sampling_rate, mono = True)\n",
    "            wav = wav_padding(wav = wav, sr = self.sampling_rate, frame_period = self.frame_period, multiple = 4)\n",
    "            f0, timeaxis, sp, ap = world_decompose(wav = wav, fs = self.sampling_rate, frame_period = self.frame_period)\n",
    "            \n",
    "            # f0 conversion\n",
    "            f0_converted = pitch_conversion(f0 = f0, mean_log_src = log_f0s_mean_B, std_log_src = log_f0s_std_B, mean_log_target = log_f0s_mean_A, std_log_target = log_f0s_std_A)\n",
    "\n",
    "            # sp normalization\n",
    "            coded_sp = world_encode_spectral_envelop(sp = sp, fs = self.sampling_rate, dim = self.num_mcep)\n",
    "            coded_sp_transposed = coded_sp.T\n",
    "            coded_sp_norm = (coded_sp_transposed - coded_sps_B_mean) / coded_sps_B_std\n",
    "            \n",
    "            # sp conversion (A2B)\n",
    "            coded_sp_converted_norm = self.sess.run(self.test_fake_A, feed_dict = {self.x_b_test: np.array([coded_sp_norm])})\n",
    "            # [1,24,None]\n",
    "            \n",
    "            # print('coded_sp_converted_norm', np.shape(coded_sp_converted_norm[0]), 'coded_sps_A_mean', np.shape(coded_sps_A_mean), 'coded_sps_A_std:', np.shape(coded_sps_A_std))          \n",
    "            coded_sp_converted = coded_sp_converted_norm[0] * coded_sps_A_std + coded_sps_A_mean\n",
    "            coded_sp_converted = coded_sp_converted.T\n",
    "            coded_sp_converted = np.ascontiguousarray(coded_sp_converted)\n",
    "            decoded_sp_converted = world_decode_spectral_envelop(coded_sp = coded_sp_converted, fs = self.sampling_rate)\n",
    "            wav_transformed = world_speech_synthesis(f0 = f0_converted, decoded_sp = decoded_sp_converted, ap = ap, fs = self.sampling_rate, frame_period = self.frame_period)\n",
    "            librosa.output.write_wav(os.path.join(self.B2A_dir, os.path.basename(file)), wav_transformed, self.sampling_rate)\n",
    "            \n",
    "            print('converting test samples B2A: [%d/%d]' %(i+1, len(test_files_B)), end='\\r')\n",
    "        \n",
    "        \n",
    "        print(\" [*] Testing finished!\")\n",
    "        \n",
    "        \n",
    "        \n",
    "    @property\n",
    "    def model_dir(self):\n",
    "        return \"{}_{}_{}\".format(self.model_name, self.dataset_name, self.gan_type)\n",
    "    \n",
    "    \n",
    "    def load(self, checkpoint_dir):\n",
    "        import re\n",
    "        print(\" [*] Reading checkpoints...\")\n",
    "        checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\n",
    "\n",
    "        ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\n",
    "        if ckpt and ckpt.model_checkpoint_path:\n",
    "            ckpt_name = os.path.basename(ckpt.model_checkpoint_path)\n",
    "            self.saver.restore(self.sess, os.path.join(checkpoint_dir, ckpt_name))\n",
    "            counter = int(next(re.finditer(\"(\\d+)(?!.*\\d)\", ckpt_name)).group(0))\n",
    "            print(\" [*] Success to read {}\".format(ckpt_name))\n",
    "            return True, counter\n",
    "        else:\n",
    "            print(\" [*] Failed to find a checkpoint\")\n",
    "            return False, 0\n",
    "        \n",
    "        \n",
    "    def save(self, checkpoint_dir, step):\n",
    "        checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\n",
    "\n",
    "        if not os.path.exists(checkpoint_dir):\n",
    "            os.makedirs(checkpoint_dir)\n",
    "\n",
    "        self.saver.save(self.sess, os.path.join(checkpoint_dir, self.model_name + '.model'), global_step=step)        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " [*] Reading checkpoints...\n",
      "INFO:tensorflow:Restoring parameters from checkpoint/C_hap_sad_lsgan/C.model-40001\n",
      " [*] Success to read C.model-40001\n",
      " [*] Load SUCCESS\n",
      "Epoch[40]: Input data sampled from 127 A and 106 B audio files: train_data_A (398, 24, 128) train_data_B (398, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id008_iter040K.wav shape: (18240,)ss: 9.837600711\n",
      "saved file at ./samples/cycle_A2A_id008_iter040K.wav shape: (18240,)\n",
      "Epoch[41]: Input data sampled from 127 A and 106 B audio files: train_data_A (397, 24, 128) train_data_B (397, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id009_iter041K.wav shape: (72640,)ss: 9.334611899\n",
      "saved file at ./samples/cycle_A2A_id009_iter041K.wav shape: (72640,)\n",
      "Epoch[42]: Input data sampled from 127 A and 106 B audio files: train_data_A (400, 24, 128) train_data_B (400, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id010_iter042K.wav shape: (65920,)ss: 8.806545260\n",
      "saved file at ./samples/cycle_A2A_id010_iter042K.wav shape: (65920,)\n",
      "Epoch[43]: Input data sampled from 127 A and 106 B audio files: train_data_A (411, 24, 128) train_data_B (411, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id011_iter043K.wav shape: (32640,)ss: 9.064408303\n",
      "saved file at ./samples/cycle_A2A_id011_iter043K.wav shape: (32640,)\n",
      "Epoch[44]: Input data sampled from 127 A and 106 B audio files: train_data_A (408, 24, 128) train_data_B (408, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id012_iter044K.wav shape: (24320,)oss: 8.422234543\n",
      "saved file at ./samples/cycle_A2A_id012_iter044K.wav shape: (24320,)\n",
      "Epoch[45]: Input data sampled from 127 A and 106 B audio files: train_data_A (406, 24, 128) train_data_B (406, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id013_iter045K.wav shape: (69760,)oss: 9.041610728\n",
      "saved file at ./samples/cycle_A2A_id013_iter045K.wav shape: (69760,)\n",
      "Epoch[46]: Input data sampled from 127 A and 106 B audio files: train_data_A (410, 24, 128) train_data_B (410, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id014_iter046K.wav shape: (24320,)oss: 8.927204136\n",
      "saved file at ./samples/cycle_A2A_id014_iter046K.wav shape: (24320,)\n",
      "Epoch[47]: Input data sampled from 127 A and 106 B audio files: train_data_A (408, 24, 128) train_data_B (408, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id015_iter047K.wav shape: (22400,)oss: 8.668366437\n",
      "saved file at ./samples/cycle_A2A_id015_iter047K.wav shape: (22400,)\n",
      "Epoch[48]: Input data sampled from 127 A and 106 B audio files: train_data_A (416, 24, 128) train_data_B (416, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id016_iter048K.wav shape: (98240,)oss: 9.369846344\n",
      "saved file at ./samples/cycle_A2A_id016_iter048K.wav shape: (98240,)\n",
      "Epoch[49]: Input data sampled from 127 A and 106 B audio files: train_data_A (416, 24, 128) train_data_B (416, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id017_iter049K.wav shape: (55680,)oss: 9.219497682\n",
      "saved file at ./samples/cycle_A2A_id017_iter049K.wav shape: (55680,)\n",
      "Epoch[50]: Input data sampled from 127 A and 106 B audio files: train_data_A (394, 24, 128) train_data_B (394, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id018_iter050K.wav shape: (68160,)oss: 8.515897754\n",
      "saved file at ./samples/cycle_A2A_id018_iter050K.wav shape: (68160,)\n",
      "Epoch[51]: Input data sampled from 127 A and 106 B audio files: train_data_A (408, 24, 128) train_data_B (408, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id019_iter051K.wav shape: (35520,)oss: 9.290553092\n",
      "saved file at ./samples/cycle_A2A_id019_iter051K.wav shape: (35520,)\n",
      "Epoch[52]: Input data sampled from 127 A and 106 B audio files: train_data_A (395, 24, 128) train_data_B (395, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id020_iter052K.wav shape: (61760,)oss: 9.153966903\n",
      "saved file at ./samples/cycle_A2A_id020_iter052K.wav shape: (61760,)\n",
      "Epoch[53]: Input data sampled from 127 A and 106 B audio files: train_data_A (404, 24, 128) train_data_B (404, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id021_iter053K.wav shape: (18880,)oss: 8.127323159\n",
      "saved file at ./samples/cycle_A2A_id021_iter053K.wav shape: (18880,)\n",
      "Epoch[54]: Input data sampled from 127 A and 106 B audio files: train_data_A (411, 24, 128) train_data_B (411, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id022_iter054K.wav shape: (19840,)oss: 8.566041956\n",
      "saved file at ./samples/cycle_A2A_id022_iter054K.wav shape: (19840,)\n",
      "Epoch[55]: Input data sampled from 127 A and 106 B audio files: train_data_A (401, 24, 128) train_data_B (401, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id023_iter055K.wav shape: (42240,)oss: 7.982484344\n",
      "saved file at ./samples/cycle_A2A_id023_iter055K.wav shape: (42240,)\n",
      "Epoch[56]: Input data sampled from 127 A and 106 B audio files: train_data_A (402, 24, 128) train_data_B (402, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id024_iter056K.wav shape: (31680,)oss: 7.726760869\n",
      "saved file at ./samples/cycle_A2A_id024_iter056K.wav shape: (31680,)\n",
      "Epoch[57]: Input data sampled from 127 A and 106 B audio files: train_data_A (412, 24, 128) train_data_B (412, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id025_iter057K.wav shape: (30720,)oss: 7.590470313\n",
      "saved file at ./samples/cycle_A2A_id025_iter057K.wav shape: (30720,)\n",
      "Epoch[58]: Input data sampled from 127 A and 106 B audio files: train_data_A (402, 24, 128) train_data_B (402, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id026_iter058K.wav shape: (80320,)oss: 7.223468782\n",
      "saved file at ./samples/cycle_A2A_id026_iter058K.wav shape: (80320,)\n",
      "Epoch[59]: Input data sampled from 127 A and 106 B audio files: train_data_A (396, 24, 128) train_data_B (396, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id027_iter059K.wav shape: (110400,)ss: 7.270111084\n",
      "saved file at ./samples/cycle_A2A_id027_iter059K.wav shape: (110400,)\n",
      "Epoch[60]: Input data sampled from 127 A and 106 B audio files: train_data_A (399, 24, 128) train_data_B (399, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id028_iter060K.wav shape: (49600,)oss: 8.970909129\n",
      "saved file at ./samples/cycle_A2A_id028_iter060K.wav shape: (49600,)\n",
      "Epoch[61]: Input data sampled from 127 A and 106 B audio files: train_data_A (404, 24, 128) train_data_B (404, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id029_iter061K.wav shape: (119040,)ss: 8.027072918\n",
      "saved file at ./samples/cycle_A2A_id029_iter061K.wav shape: (119040,)\n",
      "Epoch[62]: Input data sampled from 127 A and 106 B audio files: train_data_A (409, 24, 128) train_data_B (409, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id030_iter062K.wav shape: (55040,)oss: 7.961955558\n",
      "saved file at ./samples/cycle_A2A_id030_iter062K.wav shape: (55040,)\n",
      "Epoch[63]: Input data sampled from 127 A and 106 B audio files: train_data_A (409, 24, 128) train_data_B (409, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id031_iter063K.wav shape: (98240,)oss: 7.598352436\n",
      "saved file at ./samples/cycle_A2A_id031_iter063K.wav shape: (98240,)\n",
      "Epoch[64]: Input data sampled from 127 A and 106 B audio files: train_data_A (406, 24, 128) train_data_B (406, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id000_iter064K.wav shape: (77440,)oss: 7.325535777\n",
      "saved file at ./samples/cycle_A2A_id000_iter064K.wav shape: (77440,)\n",
      "Epoch[65]: Input data sampled from 127 A and 106 B audio files: train_data_A (407, 24, 128) train_data_B (407, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id001_iter065K.wav shape: (31040,)oss: 7.743284238\n",
      "saved file at ./samples/cycle_A2A_id001_iter065K.wav shape: (31040,)\n",
      "Epoch[66]: Input data sampled from 127 A and 106 B audio files: train_data_A (410, 24, 128) train_data_B (410, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id002_iter066K.wav shape: (105280,)ss: 7.668717380\n",
      "saved file at ./samples/cycle_A2A_id002_iter066K.wav shape: (105280,)\n",
      "Epoch[67]: Input data sampled from 127 A and 106 B audio files: train_data_A (401, 24, 128) train_data_B (401, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id003_iter067K.wav shape: (32320,)oss: 8.325461398\n",
      "saved file at ./samples/cycle_A2A_id003_iter067K.wav shape: (32320,)\n",
      "Epoch[68]: Input data sampled from 127 A and 106 B audio files: train_data_A (401, 24, 128) train_data_B (401, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id004_iter068K.wav shape: (26880,)oss: 7.732913495\n",
      "saved file at ./samples/cycle_A2A_id004_iter068K.wav shape: (26880,)\n",
      "Epoch[69]: Input data sampled from 127 A and 106 B audio files: train_data_A (410, 24, 128) train_data_B (410, 24, 128)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saved file at ./samples/fake_A2B_id005_iter069K.wav shape: (54400,)oss: 7.155164248\n",
      "saved file at ./samples/cycle_A2A_id005_iter069K.wav shape: (54400,)\n",
      "Epoch[70]: Input data sampled from 127 A and 106 B audio files: train_data_A (404, 24, 128) train_data_B (404, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id006_iter070K.wav shape: (47360,)oss: 7.861928948\n",
      "saved file at ./samples/cycle_A2A_id006_iter070K.wav shape: (47360,)\n",
      "Epoch[71]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id007_iter071K.wav shape: (29120,)oss: 8.893438340\n",
      "saved file at ./samples/cycle_A2A_id007_iter071K.wav shape: (29120,)\n",
      "Epoch[72]: Input data sampled from 127 A and 106 B audio files: train_data_A (402, 24, 128) train_data_B (402, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id008_iter072K.wav shape: (18240,)oss: 7.492339614\n",
      "saved file at ./samples/cycle_A2A_id008_iter072K.wav shape: (18240,)\n",
      "Epoch[73]: Input data sampled from 127 A and 106 B audio files: train_data_A (402, 24, 128) train_data_B (402, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id009_iter073K.wav shape: (72640,)oss: 6.854361532\n",
      "saved file at ./samples/cycle_A2A_id009_iter073K.wav shape: (72640,)\n",
      "Epoch[74]: Input data sampled from 127 A and 106 B audio files: train_data_A (402, 24, 128) train_data_B (402, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id010_iter074K.wav shape: (65920,)oss: 7.267073156\n",
      "saved file at ./samples/cycle_A2A_id010_iter074K.wav shape: (65920,)\n",
      "Epoch[75]: Input data sampled from 127 A and 106 B audio files: train_data_A (411, 24, 128) train_data_B (411, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id011_iter075K.wav shape: (32640,)oss: 7.626396185\n",
      "saved file at ./samples/cycle_A2A_id011_iter075K.wav shape: (32640,)\n",
      "Epoch[76]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id012_iter076K.wav shape: (24320,)oss: 7.320059789\n",
      "saved file at ./samples/cycle_A2A_id012_iter076K.wav shape: (24320,)\n",
      "Epoch[77]: Input data sampled from 127 A and 106 B audio files: train_data_A (399, 24, 128) train_data_B (399, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id013_iter077K.wav shape: (69760,)oss: 7.933618070\n",
      "saved file at ./samples/cycle_A2A_id013_iter077K.wav shape: (69760,)\n",
      "Epoch[78]: Input data sampled from 127 A and 106 B audio files: train_data_A (406, 24, 128) train_data_B (406, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id014_iter078K.wav shape: (24320,)oss: 7.498089793\n",
      "saved file at ./samples/cycle_A2A_id014_iter078K.wav shape: (24320,)\n",
      "Epoch[79]: Input data sampled from 127 A and 106 B audio files: train_data_A (409, 24, 128) train_data_B (409, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id015_iter079K.wav shape: (22400,)oss: 7.722046857\n",
      "saved file at ./samples/cycle_A2A_id015_iter079K.wav shape: (22400,)\n",
      "Epoch[80]: Input data sampled from 127 A and 106 B audio files: train_data_A (399, 24, 128) train_data_B (399, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id016_iter080K.wav shape: (98240,)oss: 6.48268652\n",
      "saved file at ./samples/cycle_A2A_id016_iter080K.wav shape: (98240,)\n",
      "Epoch[81]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id017_iter081K.wav shape: (55680,)oss: 7.439033512\n",
      "saved file at ./samples/cycle_A2A_id017_iter081K.wav shape: (55680,)\n",
      "Epoch[82]: Input data sampled from 127 A and 106 B audio files: train_data_A (407, 24, 128) train_data_B (407, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id018_iter082K.wav shape: (68160,)oss: 7.11658382\n",
      "saved file at ./samples/cycle_A2A_id018_iter082K.wav shape: (68160,)\n",
      "Epoch[83]: Input data sampled from 127 A and 106 B audio files: train_data_A (416, 24, 128) train_data_B (416, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id019_iter083K.wav shape: (35520,)oss: 7.185904986\n",
      "saved file at ./samples/cycle_A2A_id019_iter083K.wav shape: (35520,)\n",
      "Epoch[84]: Input data sampled from 127 A and 106 B audio files: train_data_A (407, 24, 128) train_data_B (407, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id020_iter084K.wav shape: (61760,)oss: 7.52889252\n",
      "saved file at ./samples/cycle_A2A_id020_iter084K.wav shape: (61760,)\n",
      "Epoch[85]: Input data sampled from 127 A and 106 B audio files: train_data_A (398, 24, 128) train_data_B (398, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id021_iter085K.wav shape: (18880,)oss: 6.876747132\n",
      "saved file at ./samples/cycle_A2A_id021_iter085K.wav shape: (18880,)\n",
      "Epoch[86]: Input data sampled from 127 A and 106 B audio files: train_data_A (409, 24, 128) train_data_B (409, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id022_iter086K.wav shape: (19840,)loss: 7.08130169\n",
      "saved file at ./samples/cycle_A2A_id022_iter086K.wav shape: (19840,)\n",
      "Epoch[87]: Input data sampled from 127 A and 106 B audio files: train_data_A (407, 24, 128) train_data_B (407, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id023_iter087K.wav shape: (42240,)loss: 7.808192253\n",
      "saved file at ./samples/cycle_A2A_id023_iter087K.wav shape: (42240,)\n",
      "Epoch[88]: Input data sampled from 127 A and 106 B audio files: train_data_A (409, 24, 128) train_data_B (409, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id024_iter088K.wav shape: (31680,)loss: 6.386343003\n",
      "saved file at ./samples/cycle_A2A_id024_iter088K.wav shape: (31680,)\n",
      "Epoch[89]: Input data sampled from 127 A and 106 B audio files: train_data_A (404, 24, 128) train_data_B (404, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id025_iter089K.wav shape: (30720,)loss: 6.596085078\n",
      "saved file at ./samples/cycle_A2A_id025_iter089K.wav shape: (30720,)\n",
      "Epoch[90]: Input data sampled from 127 A and 106 B audio files: train_data_A (404, 24, 128) train_data_B (404, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id026_iter090K.wav shape: (80320,)loss: 7.361868861\n",
      "saved file at ./samples/cycle_A2A_id026_iter090K.wav shape: (80320,)\n",
      "Epoch[91]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id027_iter091K.wav shape: (110400,)oss: 7.43068981\n",
      "saved file at ./samples/cycle_A2A_id027_iter091K.wav shape: (110400,)\n",
      "Epoch[92]: Input data sampled from 127 A and 106 B audio files: train_data_A (401, 24, 128) train_data_B (401, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id028_iter092K.wav shape: (49600,)loss: 6.888661387\n",
      "saved file at ./samples/cycle_A2A_id028_iter092K.wav shape: (49600,)\n",
      "Epoch[93]: Input data sampled from 127 A and 106 B audio files: train_data_A (398, 24, 128) train_data_B (398, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id029_iter093K.wav shape: (119040,)oss: 6.27530622\n",
      "saved file at ./samples/cycle_A2A_id029_iter093K.wav shape: (119040,)\n",
      "Epoch[94]: Input data sampled from 127 A and 106 B audio files: train_data_A (409, 24, 128) train_data_B (409, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id030_iter094K.wav shape: (55040,)loss: 7.32409954\n",
      "saved file at ./samples/cycle_A2A_id030_iter094K.wav shape: (55040,)\n",
      "Epoch[95]: Input data sampled from 127 A and 106 B audio files: train_data_A (405, 24, 128) train_data_B (405, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id031_iter095K.wav shape: (98240,)loss: 7.088357932\n",
      "saved file at ./samples/cycle_A2A_id031_iter095K.wav shape: (98240,)\n",
      "Epoch[96]: Input data sampled from 127 A and 106 B audio files: train_data_A (404, 24, 128) train_data_B (404, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id000_iter096K.wav shape: (77440,)loss: 7.781532298\n",
      "saved file at ./samples/cycle_A2A_id000_iter096K.wav shape: (77440,)\n",
      "Epoch[97]: Input data sampled from 127 A and 106 B audio files: train_data_A (406, 24, 128) train_data_B (406, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id001_iter097K.wav shape: (31040,)loss: 6.702306273\n",
      "saved file at ./samples/cycle_A2A_id001_iter097K.wav shape: (31040,)\n",
      "Epoch[98]: Input data sampled from 127 A and 106 B audio files: train_data_A (405, 24, 128) train_data_B (405, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id002_iter098K.wav shape: (105280,)oss: 7.420437343\n",
      "saved file at ./samples/cycle_A2A_id002_iter098K.wav shape: (105280,)\n",
      "Epoch[99]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saved file at ./samples/fake_A2B_id003_iter099K.wav shape: (32320,)loss: 7.33263540\n",
      "saved file at ./samples/cycle_A2A_id003_iter099K.wav shape: (32320,)\n",
      "Epoch[100]: Input data sampled from 127 A and 106 B audio files: train_data_A (405, 24, 128) train_data_B (405, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id004_iter100K.wav shape: (26880,)_loss: 7.609492784\n",
      "saved file at ./samples/cycle_A2A_id004_iter100K.wav shape: (26880,)\n",
      "Epoch[101]: Input data sampled from 127 A and 106 B audio files: train_data_A (407, 24, 128) train_data_B (407, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id005_iter101K.wav shape: (54400,)_loss: 7.42034912\n",
      "saved file at ./samples/cycle_A2A_id005_iter101K.wav shape: (54400,)\n",
      "Epoch[102]: Input data sampled from 127 A and 106 B audio files: train_data_A (400, 24, 128) train_data_B (400, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id006_iter102K.wav shape: (47360,)_loss: 6.82165194\n",
      "saved file at ./samples/cycle_A2A_id006_iter102K.wav shape: (47360,)\n",
      "Epoch[103]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id007_iter103K.wav shape: (29120,)_loss: 6.68958712\n",
      "saved file at ./samples/cycle_A2A_id007_iter103K.wav shape: (29120,)\n",
      "Epoch[104]: Input data sampled from 127 A and 106 B audio files: train_data_A (400, 24, 128) train_data_B (400, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id008_iter104K.wav shape: (18240,)_loss: 7.32211113\n",
      "saved file at ./samples/cycle_A2A_id008_iter104K.wav shape: (18240,)\n",
      "Epoch[105]: Input data sampled from 127 A and 106 B audio files: train_data_A (410, 24, 128) train_data_B (410, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id009_iter105K.wav shape: (72640,)_loss: 6.84597826\n",
      "saved file at ./samples/cycle_A2A_id009_iter105K.wav shape: (72640,)\n",
      "Epoch[106]: Input data sampled from 127 A and 106 B audio files: train_data_A (409, 24, 128) train_data_B (409, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id010_iter106K.wav shape: (65920,)_loss: 7.11662626\n",
      "saved file at ./samples/cycle_A2A_id010_iter106K.wav shape: (65920,)\n",
      "Epoch[107]: Input data sampled from 127 A and 106 B audio files: train_data_A (413, 24, 128) train_data_B (413, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id011_iter107K.wav shape: (32640,)_loss: 6.47767496\n",
      "saved file at ./samples/cycle_A2A_id011_iter107K.wav shape: (32640,)\n",
      "Epoch[108]: Input data sampled from 127 A and 106 B audio files: train_data_A (393, 24, 128) train_data_B (393, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id012_iter108K.wav shape: (24320,)_loss: 7.233366975\n",
      "saved file at ./samples/cycle_A2A_id012_iter108K.wav shape: (24320,)\n",
      "Epoch[109]: Input data sampled from 127 A and 106 B audio files: train_data_A (406, 24, 128) train_data_B (406, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id013_iter109K.wav shape: (69760,)_loss: 6.55078650\n",
      "saved file at ./samples/cycle_A2A_id013_iter109K.wav shape: (69760,)\n",
      "Epoch[110]: Input data sampled from 127 A and 106 B audio files: train_data_A (401, 24, 128) train_data_B (401, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id014_iter110K.wav shape: (24320,)_loss: 6.75150204\n",
      "saved file at ./samples/cycle_A2A_id014_iter110K.wav shape: (24320,)\n",
      "Epoch[111]: Input data sampled from 127 A and 106 B audio files: train_data_A (405, 24, 128) train_data_B (405, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id015_iter111K.wav shape: (22400,)_loss: 6.814709667\n",
      "saved file at ./samples/cycle_A2A_id015_iter111K.wav shape: (22400,)\n",
      "Epoch[112]: Input data sampled from 127 A and 106 B audio files: train_data_A (405, 24, 128) train_data_B (405, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id016_iter112K.wav shape: (98240,)_loss: 6.98699760\n",
      "saved file at ./samples/cycle_A2A_id016_iter112K.wav shape: (98240,)\n",
      "Epoch[113]: Input data sampled from 127 A and 106 B audio files: train_data_A (397, 24, 128) train_data_B (397, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id017_iter113K.wav shape: (55680,)_loss: 6.82429600\n",
      "saved file at ./samples/cycle_A2A_id017_iter113K.wav shape: (55680,)\n",
      "Epoch[114]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id018_iter114K.wav shape: (68160,)_loss: 6.67974854\n",
      "saved file at ./samples/cycle_A2A_id018_iter114K.wav shape: (68160,)\n",
      "Epoch[115]: Input data sampled from 127 A and 106 B audio files: train_data_A (409, 24, 128) train_data_B (409, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id019_iter115K.wav shape: (35520,)_loss: 6.64029217\n",
      "saved file at ./samples/cycle_A2A_id019_iter115K.wav shape: (35520,)\n",
      "Epoch[116]: Input data sampled from 127 A and 106 B audio files: train_data_A (401, 24, 128) train_data_B (401, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id020_iter116K.wav shape: (61760,)_loss: 7.05068970\n",
      "saved file at ./samples/cycle_A2A_id020_iter116K.wav shape: (61760,)\n",
      "Epoch[117]: Input data sampled from 127 A and 106 B audio files: train_data_A (402, 24, 128) train_data_B (402, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id021_iter117K.wav shape: (18880,)_loss: 6.73053360\n",
      "saved file at ./samples/cycle_A2A_id021_iter117K.wav shape: (18880,)\n",
      "Epoch[118]: Input data sampled from 127 A and 106 B audio files: train_data_A (411, 24, 128) train_data_B (411, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id022_iter118K.wav shape: (19840,)_loss: 7.28474474\n",
      "saved file at ./samples/cycle_A2A_id022_iter118K.wav shape: (19840,)\n",
      "Epoch[119]: Input data sampled from 127 A and 106 B audio files: train_data_A (406, 24, 128) train_data_B (406, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id023_iter119K.wav shape: (42240,)_loss: 6.24434948\n",
      "saved file at ./samples/cycle_A2A_id023_iter119K.wav shape: (42240,)\n",
      "Epoch[120]: Input data sampled from 127 A and 106 B audio files: train_data_A (399, 24, 128) train_data_B (399, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id024_iter120K.wav shape: (31680,)_loss: 6.43603516\n",
      "saved file at ./samples/cycle_A2A_id024_iter120K.wav shape: (31680,)\n",
      "Epoch[121]: Input data sampled from 127 A and 106 B audio files: train_data_A (405, 24, 128) train_data_B (405, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id025_iter121K.wav shape: (30720,)_loss: 5.76480293\n",
      "saved file at ./samples/cycle_A2A_id025_iter121K.wav shape: (30720,)\n",
      "Epoch[122]: Input data sampled from 127 A and 106 B audio files: train_data_A (401, 24, 128) train_data_B (401, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id026_iter122K.wav shape: (80320,)_loss: 6.49400711\n",
      "saved file at ./samples/cycle_A2A_id026_iter122K.wav shape: (80320,)\n",
      "Epoch[123]: Input data sampled from 127 A and 106 B audio files: train_data_A (406, 24, 128) train_data_B (406, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id027_iter123K.wav shape: (110400,)loss: 6.53688478\n",
      "saved file at ./samples/cycle_A2A_id027_iter123K.wav shape: (110400,)\n",
      "Epoch[124]: Input data sampled from 127 A and 106 B audio files: train_data_A (407, 24, 128) train_data_B (407, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id028_iter124K.wav shape: (49600,)_loss: 6.12094545\n",
      "saved file at ./samples/cycle_A2A_id028_iter124K.wav shape: (49600,)\n",
      "Epoch[125]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id029_iter125K.wav shape: (119040,)loss: 6.87833214\n",
      "saved file at ./samples/cycle_A2A_id029_iter125K.wav shape: (119040,)\n",
      "Epoch[126]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id030_iter126K.wav shape: (55040,)_loss: 6.39955091\n",
      "saved file at ./samples/cycle_A2A_id030_iter126K.wav shape: (55040,)\n",
      "Epoch[127]: Input data sampled from 127 A and 106 B audio files: train_data_A (399, 24, 128) train_data_B (399, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id031_iter127K.wav shape: (98240,)_loss: 6.04647827\n",
      "saved file at ./samples/cycle_A2A_id031_iter127K.wav shape: (98240,)\n",
      "Epoch[128]: Input data sampled from 127 A and 106 B audio files: train_data_A (397, 24, 128) train_data_B (397, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id000_iter128K.wav shape: (77440,)_loss: 6.49154377\n",
      "saved file at ./samples/cycle_A2A_id000_iter128K.wav shape: (77440,)\n",
      "Epoch[129]: Input data sampled from 127 A and 106 B audio files: train_data_A (400, 24, 128) train_data_B (400, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id001_iter129K.wav shape: (31040,)_loss: 6.65234423\n",
      "saved file at ./samples/cycle_A2A_id001_iter129K.wav shape: (31040,)\n",
      "Epoch[130]: Input data sampled from 127 A and 106 B audio files: train_data_A (402, 24, 128) train_data_B (402, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id002_iter130K.wav shape: (105280,)loss: 6.12663841\n",
      "saved file at ./samples/cycle_A2A_id002_iter130K.wav shape: (105280,)\n",
      "Epoch[131]: Input data sampled from 127 A and 106 B audio files: train_data_A (397, 24, 128) train_data_B (397, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id003_iter131K.wav shape: (32320,)_loss: 6.41960096\n",
      "saved file at ./samples/cycle_A2A_id003_iter131K.wav shape: (32320,)\n",
      "Epoch[132]: Input data sampled from 127 A and 106 B audio files: train_data_A (397, 24, 128) train_data_B (397, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id004_iter132K.wav shape: (26880,)_loss: 6.12652636\n",
      "saved file at ./samples/cycle_A2A_id004_iter132K.wav shape: (26880,)\n",
      "Epoch[133]: Input data sampled from 127 A and 106 B audio files: train_data_A (408, 24, 128) train_data_B (408, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id005_iter133K.wav shape: (54400,)_loss: 6.28116703\n",
      "saved file at ./samples/cycle_A2A_id005_iter133K.wav shape: (54400,)\n",
      "Epoch[134]: Input data sampled from 127 A and 106 B audio files: train_data_A (404, 24, 128) train_data_B (404, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id006_iter134K.wav shape: (47360,)_loss: 6.37180805\n",
      "saved file at ./samples/cycle_A2A_id006_iter134K.wav shape: (47360,)\n",
      "Epoch[135]: Input data sampled from 127 A and 106 B audio files: train_data_A (410, 24, 128) train_data_B (410, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id007_iter135K.wav shape: (29120,)_loss: 6.66959572\n",
      "saved file at ./samples/cycle_A2A_id007_iter135K.wav shape: (29120,)\n",
      "Epoch[136]: Input data sampled from 127 A and 106 B audio files: train_data_A (400, 24, 128) train_data_B (400, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id008_iter136K.wav shape: (18240,)_loss: 6.13529968\n",
      "saved file at ./samples/cycle_A2A_id008_iter136K.wav shape: (18240,)\n",
      "Epoch[137]: Input data sampled from 127 A and 106 B audio files: train_data_A (398, 24, 128) train_data_B (398, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id009_iter137K.wav shape: (72640,)_loss: 6.36380053\n",
      "saved file at ./samples/cycle_A2A_id009_iter137K.wav shape: (72640,)\n",
      "Epoch[138]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id010_iter138K.wav shape: (65920,)_loss: 6.82092381\n",
      "saved file at ./samples/cycle_A2A_id010_iter138K.wav shape: (65920,)\n",
      "Epoch[139]: Input data sampled from 127 A and 106 B audio files: train_data_A (405, 24, 128) train_data_B (405, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id011_iter139K.wav shape: (32640,)_loss: 5.76184845\n",
      "saved file at ./samples/cycle_A2A_id011_iter139K.wav shape: (32640,)\n",
      "Epoch[140]: Input data sampled from 127 A and 106 B audio files: train_data_A (398, 24, 128) train_data_B (398, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id012_iter140K.wav shape: (24320,)_loss: 6.63711357\n",
      "saved file at ./samples/cycle_A2A_id012_iter140K.wav shape: (24320,)\n",
      "Epoch[141]: Input data sampled from 127 A and 106 B audio files: train_data_A (410, 24, 128) train_data_B (410, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id013_iter141K.wav shape: (69760,)_loss: 6.14204025\n",
      "saved file at ./samples/cycle_A2A_id013_iter141K.wav shape: (69760,)\n",
      "Epoch[142]: Input data sampled from 127 A and 106 B audio files: train_data_A (398, 24, 128) train_data_B (398, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id014_iter142K.wav shape: (24320,)_loss: 5.99358082\n",
      "saved file at ./samples/cycle_A2A_id014_iter142K.wav shape: (24320,)\n",
      "Epoch[143]: Input data sampled from 127 A and 106 B audio files: train_data_A (402, 24, 128) train_data_B (402, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id015_iter143K.wav shape: (22400,)_loss: 5.91499376\n",
      "saved file at ./samples/cycle_A2A_id015_iter143K.wav shape: (22400,)\n",
      "Epoch[144]: Input data sampled from 127 A and 106 B audio files: train_data_A (406, 24, 128) train_data_B (406, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id016_iter144K.wav shape: (98240,)_loss: 6.66267490\n",
      "saved file at ./samples/cycle_A2A_id016_iter144K.wav shape: (98240,)\n",
      "Epoch[145]: Input data sampled from 127 A and 106 B audio files: train_data_A (418, 24, 128) train_data_B (418, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id017_iter145K.wav shape: (55680,)_loss: 6.00442410\n",
      "saved file at ./samples/cycle_A2A_id017_iter145K.wav shape: (55680,)\n",
      "Epoch[146]: Input data sampled from 127 A and 106 B audio files: train_data_A (416, 24, 128) train_data_B (416, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id018_iter146K.wav shape: (68160,)_loss: 6.45683336\n",
      "saved file at ./samples/cycle_A2A_id018_iter146K.wav shape: (68160,)\n",
      "Epoch[147]: Input data sampled from 127 A and 106 B audio files: train_data_A (415, 24, 128) train_data_B (415, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id019_iter147K.wav shape: (35520,)_loss: 5.90018463\n",
      "saved file at ./samples/cycle_A2A_id019_iter147K.wav shape: (35520,)\n",
      "Epoch[148]: Input data sampled from 127 A and 106 B audio files: train_data_A (404, 24, 128) train_data_B (404, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id020_iter148K.wav shape: (61760,)_loss: 5.58433056\n",
      "saved file at ./samples/cycle_A2A_id020_iter148K.wav shape: (61760,)\n",
      "Epoch[149]: Input data sampled from 127 A and 106 B audio files: train_data_A (414, 24, 128) train_data_B (414, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id021_iter149K.wav shape: (18880,)_loss: 6.06860685\n",
      "saved file at ./samples/cycle_A2A_id021_iter149K.wav shape: (18880,)\n",
      "Epoch[150]: Input data sampled from 127 A and 106 B audio files: train_data_A (395, 24, 128) train_data_B (395, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id022_iter150K.wav shape: (19840,)_loss: 5.69418716\n",
      "saved file at ./samples/cycle_A2A_id022_iter150K.wav shape: (19840,)\n",
      "Epoch[151]: Input data sampled from 127 A and 106 B audio files: train_data_A (394, 24, 128) train_data_B (394, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id023_iter151K.wav shape: (42240,)_loss: 6.22831011\n",
      "saved file at ./samples/cycle_A2A_id023_iter151K.wav shape: (42240,)\n",
      "Epoch[152]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id024_iter152K.wav shape: (31680,)_loss: 6.29978848\n",
      "saved file at ./samples/cycle_A2A_id024_iter152K.wav shape: (31680,)\n",
      "Epoch[153]: Input data sampled from 127 A and 106 B audio files: train_data_A (409, 24, 128) train_data_B (409, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id025_iter153K.wav shape: (30720,)_loss: 6.32823372\n",
      "saved file at ./samples/cycle_A2A_id025_iter153K.wav shape: (30720,)\n",
      "Epoch[154]: Input data sampled from 127 A and 106 B audio files: train_data_A (405, 24, 128) train_data_B (405, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id026_iter154K.wav shape: (80320,)_loss: 6.32993412\n",
      "saved file at ./samples/cycle_A2A_id026_iter154K.wav shape: (80320,)\n",
      "Epoch[155]: Input data sampled from 127 A and 106 B audio files: train_data_A (409, 24, 128) train_data_B (409, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id027_iter155K.wav shape: (110400,)loss: 5.82966661\n",
      "saved file at ./samples/cycle_A2A_id027_iter155K.wav shape: (110400,)\n",
      "Epoch[156]: Input data sampled from 127 A and 106 B audio files: train_data_A (411, 24, 128) train_data_B (411, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id028_iter156K.wav shape: (49600,)_loss: 5.63903856\n",
      "saved file at ./samples/cycle_A2A_id028_iter156K.wav shape: (49600,)\n",
      "Epoch[157]: Input data sampled from 127 A and 106 B audio files: train_data_A (406, 24, 128) train_data_B (406, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id029_iter157K.wav shape: (119040,)loss: 6.50039721\n",
      "saved file at ./samples/cycle_A2A_id029_iter157K.wav shape: (119040,)\n",
      "Epoch[158]: Input data sampled from 127 A and 106 B audio files: train_data_A (410, 24, 128) train_data_B (410, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id030_iter158K.wav shape: (55040,)_loss: 6.55728483\n",
      "saved file at ./samples/cycle_A2A_id030_iter158K.wav shape: (55040,)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch[159]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id031_iter159K.wav shape: (98240,)_loss: 5.84276438\n",
      "saved file at ./samples/cycle_A2A_id031_iter159K.wav shape: (98240,)\n",
      "Epoch[160]: Input data sampled from 127 A and 106 B audio files: train_data_A (417, 24, 128) train_data_B (417, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id000_iter160K.wav shape: (77440,)_loss: 5.73384666\n",
      "saved file at ./samples/cycle_A2A_id000_iter160K.wav shape: (77440,)\n",
      "Epoch[161]: Input data sampled from 127 A and 106 B audio files: train_data_A (398, 24, 128) train_data_B (398, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id001_iter161K.wav shape: (31040,)_loss: 5.68218470\n",
      "saved file at ./samples/cycle_A2A_id001_iter161K.wav shape: (31040,)\n",
      "Epoch[162]: Input data sampled from 127 A and 106 B audio files: train_data_A (396, 24, 128) train_data_B (396, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id002_iter162K.wav shape: (105280,)loss: 5.65581512\n",
      "saved file at ./samples/cycle_A2A_id002_iter162K.wav shape: (105280,)\n",
      "Epoch[163]: Input data sampled from 127 A and 106 B audio files: train_data_A (399, 24, 128) train_data_B (399, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id003_iter163K.wav shape: (32320,)_loss: 6.00020218\n",
      "saved file at ./samples/cycle_A2A_id003_iter163K.wav shape: (32320,)\n",
      "Epoch[164]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id004_iter164K.wav shape: (26880,)_loss: 5.89154291\n",
      "saved file at ./samples/cycle_A2A_id004_iter164K.wav shape: (26880,)\n",
      "Epoch[165]: Input data sampled from 127 A and 106 B audio files: train_data_A (395, 24, 128) train_data_B (395, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id005_iter165K.wav shape: (54400,)_loss: 5.88394833\n",
      "saved file at ./samples/cycle_A2A_id005_iter165K.wav shape: (54400,)\n",
      "Epoch[166]: Input data sampled from 127 A and 106 B audio files: train_data_A (397, 24, 128) train_data_B (397, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id006_iter166K.wav shape: (47360,)_loss: 5.61415482\n",
      "saved file at ./samples/cycle_A2A_id006_iter166K.wav shape: (47360,)\n",
      "Epoch[167]: Input data sampled from 127 A and 106 B audio files: train_data_A (399, 24, 128) train_data_B (399, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id007_iter167K.wav shape: (29120,)_loss: 5.51066017\n",
      "saved file at ./samples/cycle_A2A_id007_iter167K.wav shape: (29120,)\n",
      "Epoch[168]: Input data sampled from 127 A and 106 B audio files: train_data_A (409, 24, 128) train_data_B (409, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id008_iter168K.wav shape: (18240,)_loss: 5.97432184\n",
      "saved file at ./samples/cycle_A2A_id008_iter168K.wav shape: (18240,)\n",
      "Epoch[169]: Input data sampled from 127 A and 106 B audio files: train_data_A (405, 24, 128) train_data_B (405, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id009_iter169K.wav shape: (72640,)_loss: 6.13064098\n",
      "saved file at ./samples/cycle_A2A_id009_iter169K.wav shape: (72640,)\n",
      "Epoch[170]: Input data sampled from 127 A and 106 B audio files: train_data_A (400, 24, 128) train_data_B (400, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id010_iter170K.wav shape: (65920,)_loss: 5.46687508\n",
      "saved file at ./samples/cycle_A2A_id010_iter170K.wav shape: (65920,)\n",
      "Epoch[171]: Input data sampled from 127 A and 106 B audio files: train_data_A (413, 24, 128) train_data_B (413, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id011_iter171K.wav shape: (32640,)_loss: 5.63874006\n",
      "saved file at ./samples/cycle_A2A_id011_iter171K.wav shape: (32640,)\n",
      "Epoch[172]: Input data sampled from 127 A and 106 B audio files: train_data_A (407, 24, 128) train_data_B (407, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id012_iter172K.wav shape: (24320,)_loss: 5.90250444\n",
      "saved file at ./samples/cycle_A2A_id012_iter172K.wav shape: (24320,)\n",
      "Epoch[173]: Input data sampled from 127 A and 106 B audio files: train_data_A (398, 24, 128) train_data_B (398, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id013_iter173K.wav shape: (69760,)_loss: 5.74032211\n",
      "saved file at ./samples/cycle_A2A_id013_iter173K.wav shape: (69760,)\n",
      "Epoch[174]: Input data sampled from 127 A and 106 B audio files: train_data_A (404, 24, 128) train_data_B (404, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id014_iter174K.wav shape: (24320,)_loss: 5.93188047\n",
      "saved file at ./samples/cycle_A2A_id014_iter174K.wav shape: (24320,)\n",
      "Epoch[175]: Input data sampled from 127 A and 106 B audio files: train_data_A (406, 24, 128) train_data_B (406, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id015_iter175K.wav shape: (22400,)_loss: 6.00448418\n",
      "saved file at ./samples/cycle_A2A_id015_iter175K.wav shape: (22400,)\n",
      "Epoch[176]: Input data sampled from 127 A and 106 B audio files: train_data_A (413, 24, 128) train_data_B (413, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id016_iter176K.wav shape: (98240,)_loss: 5.55228662\n",
      "saved file at ./samples/cycle_A2A_id016_iter176K.wav shape: (98240,)\n",
      "Epoch[177]: Input data sampled from 127 A and 106 B audio files: train_data_A (408, 24, 128) train_data_B (408, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id017_iter177K.wav shape: (55680,)_loss: 5.85499001\n",
      "saved file at ./samples/cycle_A2A_id017_iter177K.wav shape: (55680,)\n",
      "Epoch[178]: Input data sampled from 127 A and 106 B audio files: train_data_A (398, 24, 128) train_data_B (398, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id018_iter178K.wav shape: (68160,)_loss: 5.57448721\n",
      "saved file at ./samples/cycle_A2A_id018_iter178K.wav shape: (68160,)\n",
      "Epoch[179]: Input data sampled from 127 A and 106 B audio files: train_data_A (409, 24, 128) train_data_B (409, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id019_iter179K.wav shape: (35520,)_loss: 5.63554764\n",
      "saved file at ./samples/cycle_A2A_id019_iter179K.wav shape: (35520,)\n",
      "Epoch[180]: Input data sampled from 127 A and 106 B audio files: train_data_A (407, 24, 128) train_data_B (407, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id020_iter180K.wav shape: (61760,)_loss: 5.54024220\n",
      "saved file at ./samples/cycle_A2A_id020_iter180K.wav shape: (61760,)\n",
      "Epoch[181]: Input data sampled from 127 A and 106 B audio files: train_data_A (393, 24, 128) train_data_B (393, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id021_iter181K.wav shape: (18880,)_loss: 5.49705887\n",
      "saved file at ./samples/cycle_A2A_id021_iter181K.wav shape: (18880,)\n",
      "Epoch[182]: Input data sampled from 127 A and 106 B audio files: train_data_A (407, 24, 128) train_data_B (407, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id022_iter182K.wav shape: (19840,)_loss: 5.67446613\n",
      "saved file at ./samples/cycle_A2A_id022_iter182K.wav shape: (19840,)\n",
      "Epoch[183]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id023_iter183K.wav shape: (42240,)_loss: 5.29292727\n",
      "saved file at ./samples/cycle_A2A_id023_iter183K.wav shape: (42240,)\n",
      "Epoch[184]: Input data sampled from 127 A and 106 B audio files: train_data_A (411, 24, 128) train_data_B (411, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id024_iter184K.wav shape: (31680,)_loss: 6.00256920\n",
      "saved file at ./samples/cycle_A2A_id024_iter184K.wav shape: (31680,)\n",
      "Epoch[185]: Input data sampled from 127 A and 106 B audio files: train_data_A (395, 24, 128) train_data_B (395, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id025_iter185K.wav shape: (30720,)_loss: 5.30638599\n",
      "saved file at ./samples/cycle_A2A_id025_iter185K.wav shape: (30720,)\n",
      "Epoch[186]: Input data sampled from 127 A and 106 B audio files: train_data_A (410, 24, 128) train_data_B (410, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id026_iter186K.wav shape: (80320,)_loss: 5.38377571\n",
      "saved file at ./samples/cycle_A2A_id026_iter186K.wav shape: (80320,)\n",
      "Epoch[187]: Input data sampled from 127 A and 106 B audio files: train_data_A (402, 24, 128) train_data_B (402, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id027_iter187K.wav shape: (110400,)loss: 5.66046762\n",
      "saved file at ./samples/cycle_A2A_id027_iter187K.wav shape: (110400,)\n",
      "Epoch[188]: Input data sampled from 127 A and 106 B audio files: train_data_A (399, 24, 128) train_data_B (399, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id028_iter188K.wav shape: (49600,)_loss: 5.24594402\n",
      "saved file at ./samples/cycle_A2A_id028_iter188K.wav shape: (49600,)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch[189]: Input data sampled from 127 A and 106 B audio files: train_data_A (410, 24, 128) train_data_B (410, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id029_iter189K.wav shape: (119040,)loss: 5.05268764\n",
      "saved file at ./samples/cycle_A2A_id029_iter189K.wav shape: (119040,)\n",
      "Epoch[190]: Input data sampled from 127 A and 106 B audio files: train_data_A (402, 24, 128) train_data_B (402, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id030_iter190K.wav shape: (55040,)_loss: 6.32286072\n",
      "saved file at ./samples/cycle_A2A_id030_iter190K.wav shape: (55040,)\n",
      "Epoch[191]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id031_iter191K.wav shape: (98240,)_loss: 5.36337948\n",
      "saved file at ./samples/cycle_A2A_id031_iter191K.wav shape: (98240,)\n",
      "Epoch[192]: Input data sampled from 127 A and 106 B audio files: train_data_A (403, 24, 128) train_data_B (403, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id000_iter192K.wav shape: (77440,)_loss: 5.90060282\n",
      "saved file at ./samples/cycle_A2A_id000_iter192K.wav shape: (77440,)\n",
      "Epoch[193]: Input data sampled from 127 A and 106 B audio files: train_data_A (409, 24, 128) train_data_B (409, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id001_iter193K.wav shape: (31040,)_loss: 5.48698330\n",
      "saved file at ./samples/cycle_A2A_id001_iter193K.wav shape: (31040,)\n",
      "Epoch[194]: Input data sampled from 127 A and 106 B audio files: train_data_A (409, 24, 128) train_data_B (409, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id002_iter194K.wav shape: (105280,)loss: 5.77282190\n",
      "saved file at ./samples/cycle_A2A_id002_iter194K.wav shape: (105280,)\n",
      "Epoch[195]: Input data sampled from 127 A and 106 B audio files: train_data_A (401, 24, 128) train_data_B (401, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id003_iter195K.wav shape: (32320,)_loss: 5.38920879\n",
      "saved file at ./samples/cycle_A2A_id003_iter195K.wav shape: (32320,)\n",
      "Epoch[196]: Input data sampled from 127 A and 106 B audio files: train_data_A (404, 24, 128) train_data_B (404, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id004_iter196K.wav shape: (26880,)_loss: 5.05734253\n",
      "saved file at ./samples/cycle_A2A_id004_iter196K.wav shape: (26880,)\n",
      "Epoch[197]: Input data sampled from 127 A and 106 B audio files: train_data_A (404, 24, 128) train_data_B (404, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id005_iter197K.wav shape: (54400,)_loss: 5.17714739\n",
      "saved file at ./samples/cycle_A2A_id005_iter197K.wav shape: (54400,)\n",
      "Epoch[198]: Input data sampled from 127 A and 106 B audio files: train_data_A (413, 24, 128) train_data_B (413, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id006_iter198K.wav shape: (47360,)_loss: 5.05772018\n",
      "saved file at ./samples/cycle_A2A_id006_iter198K.wav shape: (47360,)\n",
      "Epoch[199]: Input data sampled from 127 A and 106 B audio files: train_data_A (412, 24, 128) train_data_B (412, 24, 128)\n",
      "saved file at ./samples/fake_A2B_id007_iter199K.wav shape: (29120,)_loss: 5.45947027\n",
      "saved file at ./samples/cycle_A2A_id007_iter199K.wav shape: (29120,)\n",
      " [*] Training finished!1000] time: 37870.8889 d_loss: 0.00002141, g_loss: 5.79728508\n",
      " [*] Reading checkpoints...\n",
      "INFO:tensorflow:Restoring parameters from checkpoint/C_hap_sad_lsgan/C.model-200000\n",
      " [*] Success to read C.model-200000\n",
      " [*] Load SUCCESS\n",
      "std_log_src: 0.3504122157244266 std_log_target 0.2549442639021922\n",
      " [*] Testing finished!s B2A: [26/26]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess:\n",
    "    model = CYCLE(sess, folder='S05/', source='hap', target='sad')\n",
    "#     model.checkpoint_dir = 'conversion_c/Checkpoint/S02F'\n",
    "    model.build_model()\n",
    "    model.train()\n",
    "    model.test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "6e07fa7bf3a579c4df0fada55e6180723dc8c6671c88ffae4747359b432d21a6"
  },
  "kernelspec": {
   "display_name": "Python 3.5.5 64-bit ('env': conda)",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}