CNN SpeechRecognition.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convolutional Neural Network for Speech Recognition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TODO: \n",
    "- Find paramaters resulting in a good accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5.0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import random\n",
    "import math\n",
    "\n",
    "print(tf.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#  path to the data\n",
    "path = 'PATH'\n",
    "\n",
    "# load IEMOCAP numpy files into arrays\n",
    "samples_train_ENG = np.load(path + '/IEMOCAP/IEMOC_feature_train.npy')\n",
    "labels_train_ENG = np.load(path + '/IEMOCAP/IEMOC_labels_train.npy')\n",
    "\n",
    "# load test files into a separate array per class for easier testing\n",
    "samples_test_ENG =  np.load(path + '/IEMOCAP/IEMOC_feature_valid.npy')\n",
    "labels_test_ENG =  np.load(path + '/IEMOCAP/IEMOC_labels_valid.npy')\n",
    "samples_test_ENG0 = np.load(path + '/IEMOCAP/IEMOC_feature_valid_class_0.npy')\n",
    "labels_test_ENG0 = np.load(path + '/IEMOCAP/IEMOC_label_valid_class_0.npy')\n",
    "samples_test_ENG1 = np.load(path + '/IEMOCAP/IEMOC_feature_valid_class_1.npy')\n",
    "labels_test_ENG1 = np.load(path + '/IEMOCAP/IEMOC_label_valid_class_1.npy')\n",
    "samples_test_ENG2 = np.load(path + '/IEMOCAP/IEMOC_feature_valid_class_2.npy')\n",
    "labels_test_ENG2 = np.load(path + '/IEMOCAP/IEMOC_label_valid_class_2.npy')\n",
    "samples_test_ENG3 = np.load(path + '/IEMOCAP/IEMOC_feature_valid_class_3.npy')\n",
    "labels_test_ENG3 = np.load(path + '/IEMOCAP/IEMOC_label_valid_class_3.npy')\n",
    "\n",
    "# load RECOLA numpy files into arrays\n",
    "samples_train_FR = np.load(path + '/RECOLA/RECOL_feature_train.npy')\n",
    "labels_train_FR = np.load(path + '/RECOLA/RECOL_labels_train.npy')\n",
    "\n",
    "# load test files into a separete array per class for easier testing\n",
    "samples_test_FR =  np.load(path + '/RECOLA/RECOL_feature_valid.npy')\n",
    "labels_test_FR =  np.load(path + '/RECOLA/RECOL_labels_valid.npy')\n",
    "samples_test_FR0 = np.load(path + '/RECOLA/RECOL_feature_valid_class_0.npy')\n",
    "labels_test_FR0 = np.load(path + '/RECOLA/RECOL_label_valid_class_0.npy')\n",
    "samples_test_FR1 = np.load(path + '/RECOLA/RECOL_feature_valid_class_1.npy')\n",
    "labels_test_FR1 = np.load(path + '/RECOLA/RECOL_label_valid_class_1.npy')\n",
    "samples_test_FR2 = np.load(path + '/RECOLA/RECOL_feature_valid_class_2.npy')\n",
    "labels_test_FR2 = np.load(path + '/RECOLA/RECOL_label_valid_class_2.npy')\n",
    "samples_test_FR3 = np.load(path + '/RECOLA/RECOL_feature_valid_class_3.npy')\n",
    "labels_test_FR3 = np.load(path + '/RECOLA/RECOL_label_valid_class_3.npy')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 0 0]\n",
      " [1 0 0 0]\n",
      " [1 0 0 0]\n",
      " ...\n",
      " [0 0 0 1]\n",
      " [0 0 0 1]\n",
      " [0 0 0 1]]\n"
     ]
    }
   ],
   "source": [
    "# hyperparameters\n",
    "TRAIN_ITERS = 500000\n",
    "BATCH_SIZE = 50\n",
    "LEARNING_RATE = 0.001\n",
    "DISPLAY_STEP = 10\n",
    "FRENCH_PERCENTILE = 0.5\n",
    "\n",
    "# network parameters\n",
    "n_frames_eng = int(len(samples_train_ENG)/len(labels_train_ENG))\n",
    "n_frames_fr = int(len(samples_train_FR)/len(labels_train_FR))\n",
    "if FRENCH_PERCENTILE == 0:\n",
    "    n_frames = n_frames_eng\n",
    "elif FRENCH_PERCENTILE == 1:\n",
    "    n_frames = n_frames_fr\n",
    "else:\n",
    "    n_frames = int((n_frames_eng + n_frames_fr) / 2)\n",
    "\n",
    "n_features = len(samples_train_ENG[0])\n",
    "\n",
    "n_samples_ENG = len(labels_train_ENG)\n",
    "print(labels_train_ENG)\n",
    "n_samples_FR = len(labels_train_FR)\n",
    "\n",
    "n_convInput = n_frames * n_features\n",
    "n_classes = 4\n",
    "dropout = 0.5\n",
    "\n",
    "# 2 gateways for our data: one for sound samples & one for labels\n",
    "x = tf.placeholder(tf.float32, shape=(None, n_features*n_frames), name=\"Input\")\n",
    "y = tf.placeholder(tf.float32, shape=(None, n_classes), name=\"Prediction\")\n",
    "\n",
    "# gateway for dropout\n",
    "keep_prob =  tf.placeholder(tf.float32, name=\"Dropout\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "positions_ENG = np.arange(n_samples_ENG)\n",
    "positions_FR = np.arange(n_samples_FR)\n",
    "random.shuffle(positions_ENG)\n",
    "random.shuffle(positions_FR)\n",
    "current_position_ENG = 0\n",
    "current_position_FR = 0\n",
    "ENG_proportion = int(round((1-FRENCH_PERCENTILE)*BATCH_SIZE, 0))\n",
    "FR_proportion = int(round(FRENCH_PERCENTILE*BATCH_SIZE, 0))\n",
    "\n",
    "def get_one_hot(labels):\n",
    "    if labels[0] == 1:\n",
    "        return 3\n",
    "    elif labels[1] == 1:\n",
    "        return 2\n",
    "    elif labels[2] == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "def get_train_batch():\n",
    "    batch_samples = []\n",
    "    batch_labels = []\n",
    "    global current_position_ENG\n",
    "    global current_position_FR\n",
    "    current_position_ENG += ENG_proportion\n",
    "    current_position_FR += FR_proportion\n",
    "    #  check if there are enough training samples left for a batch, otherwise shuffle and start from beginning\n",
    "    if current_position_ENG >= n_samples_ENG :\n",
    "        random.shuffle(positions_ENG)\n",
    "        current_position_ENG = ENG_proportion\n",
    "    if current_position_FR >= n_samples_FR :\n",
    "        random.shuffle(positions_FR)\n",
    "        current_position_FR = FR_proportion\n",
    "    # add english samples to the batch\n",
    "    for i in range(current_position_ENG - ENG_proportion, current_position_ENG):\n",
    "        batch_labels.append(labels_train_ENG[positions_ENG[i]])\n",
    "        sample_frames = []\n",
    "        counter = 0\n",
    "        for j in range (positions_ENG[i] * n_frames_eng, positions_ENG[i] * n_frames_eng + n_frames):\n",
    "            counter += 1\n",
    "            if counter <= n_frames_eng:\n",
    "                for k in range (0,n_features):  # add real features to batch\n",
    "                    sample_frames.append(samples_train_ENG[j][k])\n",
    "            else:  # add zeros in order to match a certain frames length\n",
    "                for k in range (0,n_features):\n",
    "                    sample_frames.append(0)\n",
    "        batch_samples.append(sample_frames)\n",
    "    # add french samples to the batch\n",
    "    for i in range(current_position_FR - FR_proportion, current_position_FR):\n",
    "        batch_labels.append(labels_train_FR[positions_FR[i]])\n",
    "        sample_frames = []\n",
    "        counter = 0\n",
    "        for j in range (positions_FR[i] * n_frames_fr, positions_FR[i] * n_frames_fr + n_frames):\n",
    "            counter += 1\n",
    "            if counter <= n_frames_fr:  # add real features to batch\n",
    "                for k in range (0,n_features):\n",
    "                    sample_frames.append(samples_train_FR[j][k])\n",
    "            else:  # add zeros in order to match a certain frames length\n",
    "                for k in range (0,n_features):\n",
    "                    sample_frames.append(0)\n",
    "        batch_samples.append(sample_frames)\n",
    "        \n",
    "    for i in range(len(batch_labels)):\n",
    "        batch_labels[i] = get_one_hot(batch_labels[i])\n",
    "    batch_labels = np.reshape(batch_labels, (50))\n",
    "    print(\"batch labels: \" + str(batch_labels))\n",
    "    return batch_samples, batch_labels\n",
    "\n",
    "\n",
    "def get_test_batch_eng(samples, labels):\n",
    "    batch_samples = []\n",
    "    # add english test samples\n",
    "    for i in range(0, len(labels)):\n",
    "        sample_frames = []\n",
    "        counter = 0\n",
    "        for j in range (i * n_frames_eng, i * n_frames_eng + n_frames):\n",
    "            counter += 1\n",
    "            if counter <= n_frames_eng:\n",
    "                for k in range (0,n_features):\n",
    "                    sample_frames.append(samples[j][k])\n",
    "            else:\n",
    "                for k in range (0,n_features):\n",
    "                    sample_frames.append(0)\n",
    "        batch_samples.append(sample_frames)\n",
    "    return batch_samples\n",
    "\n",
    "\n",
    "def get_test_batch_fr(samples, labels):\n",
    "    batch_samples = []\n",
    "    # add french test samples\n",
    "    for i in range(0, len(labels)):\n",
    "        sample_frames = []\n",
    "        counter = 0\n",
    "        for j in range (i * n_frames_fr, i * n_frames_fr + n_frames):\n",
    "            counter += 1\n",
    "            if counter <= n_frames_fr:\n",
    "                for k in range (0,n_features):\n",
    "                    sample_frames.append(samples[j][k])\n",
    "            else:\n",
    "                for k in range (0,n_features):\n",
    "                    sample_frames.append(0)\n",
    "        batch_samples.append(sample_frames)\n",
    "    return batch_samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv2d(x, W, b, name=\"Convolution\"):  # function for a convolution layer\n",
    "    with tf.name_scope(name):\n",
    "        conv = tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding = 'VALID')\n",
    "        act = tf.nn.leaky_relu(conv + b)\n",
    "        return tf.nn.max_pool(act, ksize = [1, 30, 1, 1], strides = [1, 3, 1, 1], padding = 'SAME')\n",
    "\n",
    "# create model\n",
    "def conv_net(x, weights, biases):\n",
    "    # reshape input data to [ #samples, #frames, # features, 1]\n",
    "    x = tf.reshape(x, shape = [-1, n_frames, n_features, 1])\n",
    "    # convolution layer with maxpooling\n",
    "    act1 = conv2d(x, weights['wc1'], biases['bc1'])\n",
    "    \n",
    "    # reshape to one fully connected layer with inputs as a list\n",
    "    act1 = tf.reshape(act1, [-1, weights['out'].get_shape().as_list()[0]])\n",
    "    # apply dropout\n",
    "    act1 = tf.nn.dropout(act1, keep_prob)\n",
    "    \n",
    "    # output, class prediciton\n",
    "    out = tf.add(tf.matmul(act1, weights['out']), biases['out'])\n",
    "    return out #return the classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create weights\n",
    "weights = {\n",
    "    'wc1': tf.Variable(tf.random_normal([10,n_features,1,50])),\n",
    "    'out': tf.Variable(tf.random_normal([int(math.ceil((n_frames-9)/3) * 50), n_classes]))\n",
    "}\n",
    "\n",
    "# create biases\n",
    "biases = {\n",
    "    'bc1': tf.Variable(tf.random_normal([50])),\n",
    "    'out': tf.Variable(tf.random_normal([n_classes]))\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batch labels: [2 0 2 2 1 0 2 0 0 1 2 0 0 0 0 2 2 0 0 2 0 0 3 0 0 0 0 1 0 1 0 1 0 0 0 1 0\n",
      " 0 0 0 1 1 0 3 3 1 1 0 1 0]\n",
      "pred: Tensor(\"Add:0\", shape=(?, 4), dtype=float32)\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "Rank mismatch: Rank of labels (received 2) should equal rank of logits minus 1 (received 2).",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-ab274b3ec36a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;31m# define optimizer and loss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mcost\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreduce_mean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msparse_softmax_cross_entropy_with_logits\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlogits\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpred\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m \u001b[0moptimizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGradientDescentOptimizer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlearning_rate\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mLEARNING_RATE\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mminimize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcost\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.5/dist-packages/tensorflow/python/ops/nn_ops.py\u001b[0m in \u001b[0;36msparse_softmax_cross_entropy_with_logits\u001b[0;34m(_sentinel, labels, logits, name)\u001b[0m\n\u001b[1;32m   1958\u001b[0m       raise ValueError(\"Rank mismatch: Rank of labels (received %s) should \"\n\u001b[1;32m   1959\u001b[0m                        \u001b[0;34m\"equal rank of logits minus 1 (received %s).\"\u001b[0m \u001b[0;34m%\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1960\u001b[0;31m                        (labels_static_shape.ndims, logits.get_shape().ndims))\n\u001b[0m\u001b[1;32m   1961\u001b[0m     \u001b[0;31m# Check if no reshapes are required.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1962\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mlogits\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_shape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndims\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: Rank mismatch: Rank of labels (received 2) should equal rank of logits minus 1 (received 2)."
     ]
    }
   ],
   "source": [
    "# construct model\n",
    "batch_x, batch_y = get_train_batch()\n",
    "\n",
    "pred = conv_net(x, weights, biases)\n",
    "print(\"pred: \" + str(pred))\n",
    "\n",
    "# define optimizer and loss\n",
    "cost = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits = pred, labels = y))\n",
    "optimizer = tf.train.GradientDescentOptimizer(learning_rate = LEARNING_RATE).minimize(cost)\n",
    "\n",
    "#if(iteration_round == 0):\n",
    "#    optimizer = tf.train.GradientDescentOptimizer(learning_rate = LEARNING_RATE).minimize(cost)\n",
    "#    OUTPUT_PATH = \"GradientDescent2.csv\"\n",
    "#elif (iteration_round == 1)\n",
    "#    optimizer = tf.train.AdagradOptimizer(learning_rate = LEARNING_RATE).minimize(cost)\n",
    "#    OUTPUT_PATH = \"AdaGrad2.csv\"\n",
    "#}\n",
    "#elif (iteration_round == 2) {\n",
    "#    optimizer = tf.train.AdadeltaOptimizer(learning_rate = LEARNING_RATE).minimize(cost)\n",
    "#    OUTPUT_PATH = \"AdaDelta2.csv\"\n",
    "#}\n",
    "#elif (iteration_round == 3) {\n",
    "#    optimizer = tf.train.AdamOptimizer(learning_rate = LEARNING_RATE).minimize(cost)\n",
    "#    OUTPUT_PATH = \"Adam2.csv\"\n",
    "#}\n",
    "#elif (iteration_round == 4) {\n",
    "#    optimizer = tf.train.FtrlOptimizer(learning_rate = LEARNING_RATE).minimize(cost)\n",
    "#    OUTPUT_PATH = \"Ftrl2.csv\"\n",
    "#}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# evaluate model with tf.equal(predictedValue, testData)\n",
    "correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_file = open(\"sgd1.csv\", \"w\")\n",
    "output_file.write(\", Fr_sad, fr_anger, fr_pleasure, fr_joy, fr_micro, en_sad, en_anger, en_pleasure, en_joy, en_micro \\n\")\n",
    "output_file.write(\", \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# launch the graph\n",
    "sess = tf.Session()\n",
    "init = tf.global_variables_initializer()\n",
    "sess.run(init)\n",
    "step = 1\n",
    "# keep training until max iterations\n",
    "while step * BATCH_SIZE < TRAIN_ITERS:\n",
    "    batch_x, batch_y = get_train_batch()\n",
    "    print(str(len(batch_x)) + \", \" + str(len(batch_y)))\n",
    "    # Run optimization (backprop)\n",
    "    sess.run(optimizer, feed_dict={x: batch_x, y: batch_y, keep_prob: dropout})\n",
    "    \n",
    "    if step % DISPLAY_STEP == 0:\n",
    "        # Calculate batch loss and accuracy\n",
    "        loss, acc = sess.run([cost, accuracy], feed_dict={x: batch_x, y: batch_y, keep_prob: 1.})\n",
    "        print(\"Iter \" + str(step*BATCH_SIZE) + \", Minibatch Loss= \" + \"{:.6f}\".format(loss) + \", Training Accuracy= \" + \"{:.5f}\".format(acc))\n",
    "    step += 1\n",
    "print(\"Optimization Finished! Testing Model...\")\n",
    "\n",
    "\n",
    "# Evaluate model with french test data\n",
    "test_x = get_test_batch_fr(samples_test_FR, labels_test_FR)\n",
    "test_y = labels_test_FR\n",
    "accuracy_fr = sess.run(accuracy, feed_dict={x: test_x, y: test_y, keep_prob: 1.})\n",
    "print(\"French Test Accuracy: \" + str(accuracy_fr))\n",
    "\n",
    "test_x = get_test_batch_fr(samples_test_FR0, labels_test_FR0)\n",
    "test_y = labels_test_FR0\n",
    "accuracy_fr0 = sess.run(accuracy, feed_dict={x: test_x, y: test_y, keep_prob: 1.})\n",
    "print(\"French Test Accuracy Class 0: \" + str(accuracy_fr0))\n",
    "\n",
    "test_x = get_test_batch_fr(samples_test_FR1, labels_test_FR1)\n",
    "test_y = labels_test_FR1\n",
    "accuracy_fr1 = sess.run(accuracy, feed_dict={x: test_x, y: test_y, keep_prob: 1.})\n",
    "print(\"French Test Accuracy Class 1: \" + str(accuracy_fr1))\n",
    "\n",
    "test_x = get_test_batch_fr(samples_test_FR2, labels_test_FR2)\n",
    "test_y = labels_test_FR2\n",
    "accuracy_fr2 = sess.run(accuracy, feed_dict={x: test_x, y: test_y, keep_prob: 1.})\n",
    "print(\"French Test Accuracy Class 2: \" + str(accuracy_fr2))\n",
    "\n",
    "test_x = get_test_batch_fr(samples_test_FR3, labels_test_FR3)\n",
    "test_y = labels_test_FR3\n",
    "accuracy_fr3 = sess.run(accuracy, feed_dict={x: test_x, y: test_y, keep_prob: 1.})\n",
    "print(\"French Test Accuracy Class 3: \" + str(accuracy_fr3))\n",
    "output_file.write(str(accuracy_fr0) + \",\")\n",
    "output_file.write(str(accuracy_fr1) + \",\")\n",
    "output_file.write(str(accuracy_fr2) + \",\")\n",
    "output_file.write(str(accuracy_fr3) + \",\")\n",
    "output_file.write(str(accuracy_fr) + \",\")\n",
    "\n",
    "accuracy_fr_avg = (accuracy_fr0 + accuracy_fr1 + accuracy_fr2 + accuracy_fr3)/4\n",
    "print(\"Avg. French Test Accuracy: \" + str(accuracy_fr_avg))\n",
    "\n",
    "# Evaluate model with english test data\n",
    "test_x = get_test_batch_eng(samples_test_ENG, labels_test_ENG)\n",
    "test_y = labels_test_ENG\n",
    "accuracy_eng = sess.run(accuracy, feed_dict={x: test_x, y: test_y, keep_prob: 1.})\n",
    "print(\"English Test Accuracy: \" + str(accuracy_eng))\n",
    "\n",
    "test_x = get_test_batch_eng(samples_test_ENG0, labels_test_ENG0)\n",
    "test_y = labels_test_ENG0\n",
    "accuracy_eng0 = sess.run(accuracy, feed_dict={x: test_x, y: test_y, keep_prob: 1.})\n",
    "print(\"English Test Accuracy Class 0: \" + str(accuracy_eng0))\n",
    "\n",
    "test_x = get_test_batch_eng(samples_test_ENG1, labels_test_ENG1)\n",
    "test_y = labels_test_ENG1\n",
    "accuracy_eng1 = sess.run(accuracy, feed_dict={x: test_x, y: test_y, keep_prob: 1.})\n",
    "print(\"English Test Accuracy Class 1: \" + str(accuracy_eng1))\n",
    "\n",
    "test_x = get_test_batch_eng(samples_test_ENG2, labels_test_ENG2)\n",
    "test_y = labels_test_ENG2\n",
    "accuracy_eng2 = sess.run(accuracy, feed_dict={x: test_x, y: test_y, keep_prob: 1.})\n",
    "print(\"English Test Accuracy Class 2: \" + str(accuracy_eng2))\n",
    "\n",
    "test_x = get_test_batch_eng(samples_test_ENG3, labels_test_ENG3)\n",
    "test_y = labels_test_ENG3\n",
    "accuracy_eng3 = sess.run(accuracy, feed_dict={x: test_x, y: test_y, keep_prob: 1.})\n",
    "print(\"English Test Accuracy Class 3: \" + str(accuracy_eng3))\n",
    "\n",
    "accuracy_eng_avg = (accuracy_eng0 + accuracy_eng1 + accuracy_eng2 + accuracy_eng3)/4\n",
    "print(\"Avg. English Test Accuracy: \" + str(accuracy_eng_avg))\n",
    "\n",
    "output_file.write(str(accuracy_eng0) + \";\")\n",
    "output_file.write(str(accuracy_eng1) + \",\")\n",
    "output_file.write(str(accuracy_eng2) + \",\")\n",
    "output_file.write(str(accuracy_eng3) + \",\")\n",
    "output_file.write(str(accuracy_eng))\n",
    "output_file.close()\n",
    "\n",
    "print(\"closed file\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}