du16_2-rbm-imonad.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "################i tested rbm from the guy in github, this code has implemented the exact pper from hinton.\n",
    "\n",
    "import glob\n",
    "import tensorflow as tf\n",
    "from tensorflow.python.ops import control_flow_ops\n",
    "from tqdm import tqdm\n",
    "import h5py\n",
    "I=0\n",
    "def _parse_function(example_proto):\n",
    "    features = {\"X\": tf.FixedLenFeature((257), tf.float32),\n",
    "              \"Y\": tf.FixedLenFeature((257), tf.float32)}\n",
    "    parsed_features = tf.parse_single_example(example_proto, features)\n",
    "    return parsed_features[\"X\"], parsed_features[\"Y\"]\n",
    "\n",
    "def rbm_layer(n_visible, n_hidden, num_epochs, num_cases, lr, ws, bs, layer_n, len_data, directories):\n",
    "    \n",
    "    Data_path = directories[0]\n",
    "    tfrecord_folder_parent = directories[1]\n",
    "    tfrecord_folder = directories[2]\n",
    "    \n",
    "    tfrecord_path_x = os.path.normpath(os.path.join(Data_path,tfrecord_folder_parent,tfrecord_folder))\n",
    "    sorted_names_x = natsorted(os.listdir(tfrecord_path_x))\n",
    "    trainfilenames_x = []\n",
    "    for i in sorted_names_x:\n",
    "        trainfilenames_x.append(os.path.normpath(os.path.join(tfrecord_path_x,i)))\n",
    "#     filenames_x = tf.placeholder(tf.string, shape=[None])\n",
    "    dataset_x = tf.data.TFRecordDataset(trainfilenames_x)\n",
    "    dataset_x = dataset_x.map(_parse_function)  # Parse the record into tensors.\n",
    "#     dataset_x = dataset_x.repeat()  # Repeat the input indefinitely.\n",
    "    dataset_x = dataset_x.batch(batch_size)\n",
    "#     iterator_x = dataset_x.make_initializable_iterator()\n",
    "\n",
    "#     x  = tf.placeholder(tf.float32, [None, n_visible], name=\"x\") #The placeholder variable that holds our data\n",
    "    W  = tf.Variable(tf.random_normal([n_visible, n_hidden], 0.01), name=\"W\") #The weight matrix that stores the edge weights\n",
    "#     bh = tf.Variable(tf.zeros([1, n_hidden],  tf.float32, name=\"bh\")) #The bias vector for the hidden layer\n",
    "#     bv = tf.Variable(tf.zeros([1, n_visible],  tf.float32, name=\"bv\")) #The bias vector for the visible layer\n",
    "    bh = tf.ones([1, n_hidden],  tf.float32, name=\"bh\") #The bias vector for the hidden layer\n",
    "    bv = tf.ones([1, n_visible],  tf.float32, name=\"bv\") #The bias vector for the visible layer\n",
    "    \n",
    "    W_adder  = tf.zeros((n_visible,n_hidden),dtype=tf.dtypes.float32)\n",
    "    bh_adder = tf.zeros((1,n_hidden),dtype=tf.dtypes.float32)\n",
    "    bv_adder = tf.zeros((1,n_visible),dtype=tf.dtypes.float32)\n",
    "    \n",
    "    CDpos  = tf.zeros((n_visible,n_hidden),dtype=tf.dtypes.float32)\n",
    "    CDneg = tf.zeros((n_visible,n_hidden),dtype=tf.dtypes.float32)\n",
    "    \n",
    "    data_points = 100000\n",
    "    sig = 0.2\n",
    "#     weight_decay = 0.01\n",
    "#     initialmomentum  = 0.5\n",
    "#     finalmomentum    = 0.9\n",
    "    \n",
    "    weight_decay = 0.01\n",
    "    initialmomentum  = 0\n",
    "    finalmomentum    = 0   \n",
    "    def sample(probs):\n",
    "        #Takes in a vector of probabilities, and returns a random vector of 0s and 1s sampled from the input vector\n",
    "        return tf.floor(probs + tf.random_uniform(tf.shape(probs), 0, 1))\n",
    "\n",
    "\n",
    "    def gibbs_sample(k,data):\n",
    "        #Runs a k-step gibbs chain to sample from the probability distribution of the RBM defined by W, bh, bv\n",
    "        def gibbs_step(count, k, data):\n",
    "            #Runs a single gibbs step. The visible values are initialized to xk\n",
    "            hk = sample(tf.sigmoid(tf.matmul(data, W) + bh+ sig*tf.random.normal((len(x[0]),len(W[0])),mean=0.0,stddev=1))) #Propagate the visible values to sample the hidden values\n",
    "#             xk   = tf.sigmoid(tf.matmul(hk, tf.transpose(W)) + bv)\n",
    "            data = sample(tf.truncated_normal((1,n_visible),tf.matmul(hk, tf.transpose(W)) + bv,1))\n",
    "            return count+1, k, data\n",
    "#         print('2')\n",
    "        ct = tf.constant(0) #counter\n",
    "        #Run gibbs steps for k iterations\n",
    "        [_, _, x_sample]=control_flow_ops.while_loop(lambda count, num_iter, *args: count < num_iter,\n",
    "                                             gibbs_step, [ct, tf.constant(k), data], back_prop = False)\n",
    "#         print('3')\n",
    "        #This is not strictly necessary in this implementation, but if you want to adapt this code to use one of TensorFlow's\n",
    "        #optimizers, you need this in order to stop tensorflow from propagating gradients back through the gibbs step\n",
    "        x_sample = tf.stop_gradient(x_sample) \n",
    "#         print('4')\n",
    "        return x_sample\n",
    "\n",
    "    ### Training Update Code\n",
    "    # Now we implement the contrastive divergence algorithm. First, we get the samples of x and h from the probability distribution\n",
    "    #The sample of x\n",
    "#     print('1')\n",
    "#     x_sample = gibbs_sample(5) \n",
    "#     #The sample of the hidden nodes, starting from the visible state of x\n",
    "#     h = sample(tf.sigmoid(tf.matmul(x, W) + bh)) \n",
    "#     #The sample of the hidden nodes, starting from the visible state of x_sample\n",
    "#     h_sample = sample(tf.sigmoid(tf.matmul(x_sample, W) + bh)) \n",
    "\n",
    "#     #Next, we update the values of W, bh, and bv, based on the difference between the samples that we drew and the original values\n",
    "# #     size_bt = tf.cast(tf.shape(x)[0], tf.float32)\n",
    "#     W_adder  = tf.multiply(lr, tf.subtract(tf.matmul(tf.transpose(x), h), tf.matmul(tf.transpose(x_sample), h_sample)))\n",
    "#     bv_adder = tf.multiply(lr, tf.reduce_sum(tf.subtract(x, x_sample), 0, True))\n",
    "#     bh_adder = tf.multiply(lr, tf.reduce_sum(tf.subtract(h, h_sample), 0, True))\n",
    "#     #When we do sess.run(updt), TensorFlow will run all 3 update steps\n",
    "#     updt = [W.assign_add(W_adder), bv.assign_add(bv_adder), bh.assign_add(bh_adder)]\n",
    "\n",
    "\n",
    "\n",
    "    ### Run the graph!\n",
    "    # Now it's time to start a session and run the graph! \n",
    "\n",
    "    incount=0\n",
    "    for epoch in tqdm(range(num_epochs)):\n",
    "        #Train the RBM on batch_size examples at a time\n",
    "#             for X_batch in da(batch_size, layer_n, ws, bs, len_data, name, data_name):\n",
    "        for x in dataset_x:\n",
    "            incount+=1\n",
    "            if incount%1000==0:\n",
    "                print(incount)\n",
    "#             if layer_n>1:\n",
    "#                 for j in range(layer_n):\n",
    "#                     x_0 = np.matmul(x[0],ws[j])+bs[j]\n",
    "#             else:\n",
    "#                 x_0 = x[0]\n",
    "            x_sample = gibbs_sample(2,x[0]) \n",
    "            #The sample of the hidden nodes, starting from the visible state of x\n",
    "            h = tf.sigmoid(tf.matmul(x[0], W) + bh+ sig*tf.random.normal((len(x[0]),len(W[0])),mean=0.0,stddev=1))\n",
    "            #The sample of the hidden nodes, starting from the visible state of x_sample\n",
    "            h_sample = sample(tf.sigmoid(tf.matmul(x_sample, W) + bh))\n",
    "            if epoch>5:\n",
    "                m=finalmomentum\n",
    "            else:\n",
    "                m=initialmomentum\n",
    "            #Next, we update the values of W, bh, and bv, based on the difference between the samples that we drew and the original values\n",
    "        #     size_bt = tf.cast(tf.shape(x)[0], tf.float32)\n",
    "            CDpos = CDpos + tf.matmul(tf.transpose(x[0]), h)\n",
    "            CDneg = CDneg + tf.matmul(tf.transpose(x_sample), h_sample)/data_points\n",
    "        CDpos = CDpos/data_points  \n",
    "        CDneg = CDneg/data_points  \n",
    "        W_adder  = (m * W_adder) + tf.multiply(lr, tf.subtract(tf.matmul(tf.transpose(x[0]), h), tf.matmul(tf.transpose(x_sample), h_sample)))- W*weight_decay\n",
    "#         bv_adder = (m * bv_adder) + tf.multiply(lr, tf.reduce_sum(tf.subtract(x[0], x_sample), 0, True))\n",
    "#         bh_adder = (m * bh_adder) + tf.multiply(lr, tf.reduce_sum(tf.subtract(h, h_sample), 0, True))\n",
    "            #When we do sess.run(updt), TensorFlow will run all 3 update steps\n",
    "#         updt = [W.assign_add(W_adder), bv.assign_add(bv_adder), bh.assign_add(bh_adder)]\n",
    "        updt = [W.assign_add(W_adder), bv, bh]\n",
    "    return updt\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "imported\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      "  0%|                                                                                           | 0/20 [00:00<?, ?it/s]\n",
      "\n",
      "\n",
      "\n",
      "  5%|████▏                                                                              | 1/20 [00:14<04:40, 14.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      " 10%|████████▎                                                                          | 2/20 [00:28<04:19, 14.43s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      " 15%|████████████▍                                                                      | 3/20 [00:41<03:59, 14.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      " 20%|████████████████▌                                                                  | 4/20 [00:55<03:41, 13.86s/it]\n",
      "\n",
      "\n",
      "\n",
      " 25%|████████████████████▊                                                              | 5/20 [01:08<03:27, 13.85s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      " 30%|████████████████████████▉                                                          | 6/20 [01:22<03:12, 13.76s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      " 35%|█████████████████████████████                                                      | 7/20 [01:36<02:58, 13.71s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      " 40%|█████████████████████████████████▏                                                 | 8/20 [01:49<02:43, 13.65s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      " 45%|█████████████████████████████████████▎                                             | 9/20 [02:03<02:30, 13.66s/it]\n",
      "\n",
      "\n",
      "\n",
      " 50%|█████████████████████████████████████████                                         | 10/20 [02:18<02:20, 14.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      " 55%|█████████████████████████████████████████████                                     | 11/20 [02:32<02:06, 14.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      " 60%|█████████████████████████████████████████████████▏                                | 12/20 [02:46<01:52, 14.00s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      " 65%|█████████████████████████████████████████████████████▎                            | 13/20 [03:00<01:38, 14.04s/it]\n",
      "\n",
      "\n",
      "\n",
      " 70%|█████████████████████████████████████████████████████████▍                        | 14/20 [03:15<01:26, 14.35s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      " 75%|█████████████████████████████████████████████████████████████▌                    | 15/20 [03:29<01:11, 14.24s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      " 80%|█████████████████████████████████████████████████████████████████▌                | 16/20 [03:43<00:56, 14.23s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      " 85%|█████████████████████████████████████████████████████████████████████▋            | 17/20 [03:56<00:42, 14.01s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      " 90%|█████████████████████████████████████████████████████████████████████████▊        | 18/20 [04:11<00:28, 14.30s/it]\n",
      "\n",
      "\n",
      "\n",
      " 95%|█████████████████████████████████████████████████████████████████████████████▉    | 19/20 [04:25<00:14, 14.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████| 20/20 [04:39<00:00, 14.00s/it]"
     ]
    }
   ],
   "source": [
    "# import libraries.\n",
    "import numpy as np\n",
    "from sklearn.utils import shuffle\n",
    "import tensorflow as tf\n",
    "import datetime\n",
    "tf.enable_eager_execution()\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras.wrappers.scikit_learn import KerasRegressor\n",
    "# import keras\n",
    "from tensorflow.keras.layers import BatchNormalization\n",
    "from tensorflow.keras import optimizers\n",
    "from tensorflow.keras import regularizers\n",
    "\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from pystoi.stoi import stoi\n",
    "import h5py\n",
    "######################\n",
    "#import libraries.\n",
    "import matplotlib.pyplot as plt\n",
    "from tabulate import tabulate\n",
    "import time\n",
    "import os\n",
    "import librosa\n",
    "from librosa.core import stft, istft\n",
    "####import sounddevice as sd\n",
    "import time\n",
    "print('imported')\n",
    "# #######################\n",
    "Data_path = 'D:/studies/university/thesis/speech_separation_codes/du16/donesomestuff'\n",
    "# Data_path = os.getcwd()\n",
    "tfrecord_folder_parent = 'tfrecord_files'\n",
    "tfrecord_folder = 'mixed_10h_norm2'\n",
    "tfrecord_val_folder = 'validation_10h'\n",
    "# ckpt_folder = '3'\n",
    "dirs = [Data_path, tfrecord_folder_parent, tfrecord_folder]\n",
    " \n",
    "# len_data = (684108, 257)\n",
    "# len_data = (100000, 257)\n",
    "len_data = (2197278, 257)\n",
    "val_len = (97278,257)\n",
    "w=1\n",
    "#######################\n",
    "#define reconstruct function to reconstruct sound from framed signal.\n",
    "def reconstruct(wave,angle):\n",
    "    recon = np.sqrt(np.power(10, wave))\n",
    "    recon1 = recon*np.cos(angle)+recon*np.sin(angle)*1j\n",
    "    recon = librosa.core.istft((recon1.T), hop_length=200, win_length=500, window='hann')\n",
    "    return recon\n",
    "#######################\n",
    "I=0\n",
    "global batch_size\n",
    "batch_size = 128\n",
    "# epochs_num=50\n",
    "global datalen\n",
    "datalen=len_data[0]\n",
    "\n",
    "h = [512,512]\n",
    "seed = 7\n",
    "rate1 = 0.1\n",
    "rate2 = 0.2\n",
    "# from tensorflow.keras.layers import Activation\n",
    "# # from keras.layers import Activation\n",
    "# np.random.seed(seed)\n",
    "# model = Sequential()\n",
    "# act1 = layers.LeakyReLU(alpha=0.1)\n",
    "# model.add(layers.Dropout(rate1, noise_shape=None, seed=None))\n",
    "# # ,kernel_regularizer=regularizers.l2(0.001)\n",
    "# model.add(Dense(h[0], input_dim = w*len_data[1]))\n",
    "# model.add(BatchNormalization())\n",
    "# model.add(act1)\n",
    "# # model.add(Activation('sigmoid'))\n",
    "# act2=layers.LeakyReLU(alpha=0.1)\n",
    "# model.add(layers.Dropout(rate2, noise_shape=None, seed=None))\n",
    "# model.add(Dense(h[1]))\n",
    "# model.add(act2)\n",
    "# # act3=layers.LeakyReLU(alpha=0.1)\n",
    "# # # model.add(layers.Dropout(rate, noise_shape=None, seed=None))\n",
    "# # model.add(Dense(h[2]))\n",
    "# # model.add(act3)\n",
    "# act=layers.LeakyReLU(alpha=0.01)\n",
    "# model.add(Dense(len_data[1]))\n",
    "#############################################\n",
    "import os\n",
    "from natsort import natsorted\n",
    "\n",
    "# def _parse_function(example_proto):\n",
    "#     print('1')\n",
    "#     features = {\"X\": tf.FixedLenFeature((3*257), tf.float32),\n",
    "#               \"Y\": tf.FixedLenFeature((257), tf.float32)}\n",
    "#     parsed_features = tf.parse_single_example(example_proto, features)\n",
    "#     print(\"i was here\")\n",
    "#     print('2')\n",
    "#     return parsed_features[\"X\"], parsed_features[\"Y\"]\n",
    "\n",
    "# tfrecord_path = os.path.normpath(os.path.join(Data_path,tfrecord_folder_parent,tfrecord_folder))\n",
    "# sorted_names = natsorted(os.listdir(tfrecord_path))\n",
    "# trainfilenames = []\n",
    "# for i in sorted_names:\n",
    "#     trainfilenames.append(os.path.normpath(os.path.join(tfrecord_path,i)))\n",
    "# filenames = tf.placeholder(tf.string, shape=[None])\n",
    "# dataset = tf.data.TFRecordDataset(filenames)\n",
    "# dataset = dataset.map(_parse_function)  # Parse the record into tensors.\n",
    "# dataset = dataset.repeat()  # Repeat the input indefinitely.\n",
    "# dataset = dataset.batch(batch_size)\n",
    "# iterator = dataset.make_initializable_iterator()\n",
    "\n",
    "# # orig_path = os.getcwd()\n",
    "# tfrecord_path_x = os.path.normpath(os.path.join(Data_path,tfrecord_folder_parent,tfrecord_folder))\n",
    "# sorted_names_x = natsorted(os.listdir(tfrecord_path_x))\n",
    "# trainfilenames_x = []\n",
    "# for i in sorted_names_x:\n",
    "#     trainfilenames_x.append(os.path.normpath(os.path.join(tfrecord_path,i)))\n",
    "# filenames_x = tf.placeholder(tf.string, shape=[None])\n",
    "# dataset_x = tf.data.TFRecordDataset(filenames_x)\n",
    "# dataset_x = dataset_x.map(_parse_function)  # Parse the record into tensors.\n",
    "# dataset_x = dataset_x.repeat()  # Repeat the input indefinitely.\n",
    "# dataset_x = dataset_x.batch(batch_size)\n",
    "# iterator_x = dataset_x.make_initializable_iterator()\n",
    "\n",
    "########################\n",
    "visible = w*len_data[1]\n",
    "hidden = h[0]\n",
    "visible1 = h[0]\n",
    "hidden1 = h[1]\n",
    "visible2 = h[1]\n",
    "hidden2 = len_data[1]\n",
    "\n",
    "layer1 = rbm_layer(visible, hidden, 20, batch_size, 0.1, [np.eye(visible)], [np.zeros((1,visible))], 1, len_data[0],dirs)\n",
    "# layer2 = rbm_layer(visible1, hidden1, 50, batch_size, 0.01, [np.eye(visible),layer1[0]], [np.zeros((1,visible)),layer1[2]], 2, len_data[0], dirs)\n",
    "# layer3 = rbm_layer(visible2, hidden2, 50, batch_size, 0.01, [np.eye(visible),layer1[0],layer2[0]], [np.zeros((1,visible)),layer1[2],layer2[2]], 3, len_data[0], dirs)\n",
    "\n",
    "###############################\n",
    "\n",
    "# tfrecord_path_val = os.path.normpath(os.path.join(Data_path,tfrecord_folder_parent,tfrecord_val_folder))\n",
    "# sorted_names_val = natsorted(os.listdir(tfrecord_path_val))\n",
    "# trainfilenames_val = []\n",
    "# for i in sorted_names_val:\n",
    "#     trainfilenames_val.append(os.path.normpath(os.path.join(tfrecord_path_val,i)))\n",
    "# filenames_val = tf.placeholder(tf.string, shape=[None])\n",
    "# dataset_val = tf.data.TFRecordDataset(filenames_val)\n",
    "# dataset_val = dataset_val.map(_parse_function)  # Parse the record into tensors.\n",
    "# dataset_val = dataset_val.repeat()  # Repeat the input indefinitely.\n",
    "# dataset_val = dataset_val.batch(128)\n",
    "# iterator_val = dataset_val.make_initializable_iterator()\n",
    "\n",
    "# epochs_num = 50\n",
    "# steps = len_data[0] // batch_size\n",
    "# val_steps = val_len[0] // batch_size\n",
    "# # You can feed the initializer with the appropriate filenames for the current\n",
    "# # phase of execution, e.g. training vs. validation.\n",
    "# # next_elem = iterator_val.get_next()\n",
    "# # Initialize `iterator` with training data.\n",
    "\n",
    "# if not os.path.exists(os.path.join(Data_path,\"checkpoints\",ckpt_folder)):\n",
    "#     os.makedirs(os.path.join(Data_path,\"checkpoints\",ckpt_folder))\n",
    "\n",
    "# print(datetime.datetime.now())\n",
    "# with tf.Session() as sess:\n",
    "#     sess.run(tf.global_variables_initializer())\n",
    "#     sess.run(iterator.initializer, feed_dict={filenames: trainfilenames})\n",
    "#     sess.run(iterator_val.initializer, feed_dict={filenames_val: trainfilenames_val})\n",
    "#     print(\"initialized\")\n",
    "#     checkpoint_path = os.path.normpath(os.path.join(Data_path,\"checkpoints\",ckpt_folder,\"weights.{epoch:02d}.hdf5\"))\n",
    "#     checkpoint_dir = os.path.dirname(checkpoint_path)\n",
    "\n",
    "#     cp_callback = tf.keras.callbacks.ModelCheckpoint(\n",
    "#         checkpoint_path, verbose=1, save_best_only=True, save_weights_only=True)\n",
    "#         # Save weights, every 5-epochs.\n",
    "# #         period=1)\n",
    "#     early_stop = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=30)\n",
    "#     opt = tf.keras.optimizers.Adamax()\n",
    "# #     opt = tf.train.AdamOptimizer()\n",
    "# #     opt = tf.keras.optimizers.SGD()\n",
    "#     model.compile(loss='mean_squared_error', optimizer=opt)\n",
    "#     history = model.fit( iterator, steps_per_epoch=steps,epochs=epochs_num, callbacks = [cp_callback,early_stop], verbose=1,validation_data=iterator_val,validation_steps=val_steps)\n",
    "# #     model.save(os.path.normpath(os.path.join(Data_path, 'models', \"model_3h_dataset.h5\")))\n",
    "# #     tf.keras.models.save_model(model, os.path.normpath(os.path.join(Data_path, 'models', \"model_3h_dataset.h5\")))\n",
    "# #     model.save_weights(os.path.normpath(os.path.join(Data_path, 'models', \"model_3h_dataset.h5\")))\n",
    "#     model_json = model.to_json()\n",
    "#     with open(os.path.normpath(os.path.join(Data_path, 'models', \"model_3.json\")), \"w\") as json_file:\n",
    "#         json_file.write(model_json)\n",
    "#     # # serialize weights to HDF5\n",
    "#     model.save_weights(os.path.normpath(os.path.join(Data_path, 'models', \"model_3.h5\")))\n",
    "#     print(\"Saved model to disk\")\n",
    "    \n",
    "# print(datetime.datetime.now())\n",
    "# %matplotlib inline\n",
    "# # summarize history for loss\n",
    "# plt.plot(history.history['loss'])\n",
    "# plt.plot(history.history['val_loss'])\n",
    "# plt.title('model loss')\n",
    "# plt.ylabel('loss')\n",
    "# plt.xlabel('epoch')\n",
    "# plt.legend(['train'], loc='upper left')\n",
    "# plt.show()\n",
    "# plt.savefig(os.path.normpath(os.path.join(Data_path,'images',ckpt_folder+'.png')))\n",
    "# # model_json = model.to_json()\n",
    "# # with open(\"model_10h_dataset.json\", \"w\") as json_file:\n",
    "# #     json_file.write(model_json)\n",
    "# # model.save_weights(\"model_10h_dataset.h5\")\n",
    "# # print(\"Saved model to disk\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[nan, nan, nan, ..., nan, nan, nan],\n",
       "       [nan, nan, nan, ..., nan, nan, nan],\n",
       "       [nan, nan, nan, ..., nan, nan, nan],\n",
       "       ...,\n",
       "       [nan, nan, nan, ..., nan, nan, nan],\n",
       "       [nan, nan, nan, ..., nan, nan, nan],\n",
       "       [nan, nan, nan, ..., nan, nan, nan]], dtype=float32)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer1[0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "write_path = 'D:/studies/university/thesis/speech_separation_codes/du16/donesomestuff/10hdata'\n",
    "mixed_folder = os.path.normpath(os.path.join(write_path,'mixed_log_10h_norm2'))\n",
    "h5f = h5py.File(mixed_folder+'.hdf5','r')\n",
    "ftr = h5f['mixed_log_10h_norm2'][0:126]\n",
    "h5f.close()\n",
    "mixed_folder = os.path.normpath(os.path.join(write_path,'mixed_phase_10h_nozeroinsert'))\n",
    "h5f = h5py.File(mixed_folder+'.hdf5','r')\n",
    "ftr_phase = h5f['mixed_phase_10h_nozeroinsert'][0:126]\n",
    "h5f.close()\n",
    "mixed_folder = os.path.normpath(os.path.join(write_path,'mixed_log_10h_nozeroinsert'))\n",
    "h5f = h5py.File(mixed_folder+'.hdf5','r')\n",
    "ftr_raw = h5f['mixed_log_10h_nozeroinsert'][0:126]\n",
    "h5f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "hidden1 = np.matmul(ftr,layer1[0].numpy())+layer1[2]\n",
    "# hidden2 = np.matmul(hidden1,layer2[0])+layer2[2]\n",
    "# hidden3 = np.matmul(hidden2,layer3[0])+layer3[2]\n",
    "hidden1_b = np.matmul(hidden1,layer1[0].numpy().T)+layer1[1]\n",
    "# hidden2_b = np.matmul(hidden3_b,layer2[0].T)+layer2[1]\n",
    "# hidden1_b = np.matmul(hidden2_b,layer1[0].T)+layer1[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: id=13622700, shape=(126, 257), dtype=float32, numpy=\n",
       "array([[ 8.1481102e+01, -3.1999548e+01, -4.2016037e+01, ...,\n",
       "        -8.6838641e+02, -2.9303830e-02,  2.3330821e+02],\n",
       "       [ 7.5040947e+01, -2.1919357e+02, -1.7176888e+02, ...,\n",
       "        -8.3385431e+02, -7.4401268e+01, -3.4883771e+02],\n",
       "       [ 3.6552094e+02,  6.9319237e+01, -1.2640253e+02, ...,\n",
       "        -8.8427722e+02, -8.7484961e+00,  2.6013117e+01],\n",
       "       ...,\n",
       "       [-1.7064370e+03, -2.3507266e+03, -1.3966254e+03, ...,\n",
       "        -1.7608463e+03, -2.4625664e+02, -3.0107550e+02],\n",
       "       [-1.7064370e+03, -2.3507266e+03, -1.3966254e+03, ...,\n",
       "        -1.7608463e+03, -2.4625664e+02, -3.0107550e+02],\n",
       "       [-1.7064370e+03, -2.3507266e+03, -1.3966254e+03, ...,\n",
       "        -1.7608463e+03, -2.4625664e+02, -3.0107550e+02]], dtype=float32)>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hidden1_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.28766647,  0.11526573, -0.7069241 , ..., -0.55612373,\n",
       "        -0.5525803 , -0.50696164],\n",
       "       [ 0.12223668,  0.26682785, -0.4372746 , ..., -0.99636066,\n",
       "        -1.0043348 , -1.5150769 ],\n",
       "       [ 0.8128672 ,  0.6103882 , -0.9415356 , ..., -1.1297925 ,\n",
       "        -0.9657317 , -0.59864193],\n",
       "       ...,\n",
       "       [-4.825073  , -5.533287  , -4.9773455 , ..., -2.2312639 ,\n",
       "        -2.2086217 , -1.930099  ],\n",
       "       [-4.825073  , -5.533287  , -4.9773455 , ..., -2.2312639 ,\n",
       "        -2.2086217 , -1.930099  ],\n",
       "       [-4.825073  , -5.533287  , -4.9773455 , ..., -2.2312639 ,\n",
       "        -2.2086217 , -1.930099  ]], dtype=float32)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ftr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mean = np.loadtxt(os.path.normpath(os.path.join(write_path,'mean_mixed_log.txt')))\n",
    "std = np.loadtxt(os.path.normpath(os.path.join(write_path,'std_mixed_log.txt')))\n",
    "hidden1_b_unnorm = (hidden1_b*std)+mean\n",
    "recon = reconstruct(hidden1_b_unnorm/500, ftr_phase)\n",
    "import sounddevice as sd\n",
    "sd.play(recon,16000)\n",
    "\n",
    "Pxx, freqs, bins, im = plt.specgram(recon, NFFT=512, Fs=16000, noverlap=256)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "recon = reconstruct(hidden1_b, ftr_phase)\n",
    "import sounddevice as sd\n",
    "sd.play(recon,16000)\n",
    "Pxx, freqs, bins, im = plt.specgram(recon, NFFT=512, Fs=16000, noverlap=256)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=tf.constant([1,2,3])\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    label_numpy = a.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(771,)"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import h5py \n",
    "import tensorflow as tf\n",
    "hh = h5py.File('ftr_refrmd_10h.hdf5', 'r')\n",
    "d=hh['ftr_refrmd_10h'][0]\n",
    "len_data=d.shape\n",
    "hh.close()\n",
    "len_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<PrefetchDataset shapes: ((?, 257), (?,)), types: (tf.float32, tf.float32)>"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (myenv)",
   "language": "python",
   "name": "myenv"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}