development/machine_learning_tests.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test function development for the machine_learning.py module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import h5py\n",
    "import numpy as np\n",
    "from ramandecompy import interpolatespectra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "key_list = interpolatespectra.keyfinder('ramandecompy/tests/test_files/test_experiment.hdf5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "hdf5 = h5py.File('ramandecompy/tests/test_files/test_experiment.hdf5', 'r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "h5py._hl.group.Group"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(hdf5['300C'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "h5py._hl.group.Group"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(hdf5['300C/25s'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KeysView(<HDF5 group \"/300C/25s\" (21 members)>)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hdf5['300C/25s'].keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(key_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A float was passed to the function, and was handled well with a TypeError.\n",
      "A .txt was passed to the function, and was handled well with a TypeError.\n",
      "A list was passed to the function, and was handled well with a TypeError.\n",
      "\n",
      "A float was passed to the function, and was handled well with a TypeError.\n",
      "A list not containing tuples was passed to the function,\n",
      "         and was handled well with a TypeError.\n",
      "A float was passed to the function, and was handled well with a TypeError.\n",
      "\n",
      "A float was passed to the function and was handled well with a TypeError\n",
      "A .txt was passed to the function and was handled well with a TypeError\n",
      "An int was passed to the function and was handled well with a TypeError\n",
      "A negative int was passed to the function and was handled well with a TypeError\n",
      "A list was passed to the function and was handled well with a TypeError\n",
      "\n",
      "A float was passed to the function and was handled well with a TypeError\n",
      "A .txt was passed to the function and was handled well with a TypeError\n",
      "\n"
     ]
    },
    {
     "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": [
    "HDF5_FILENAME = 'ramandecompy/tests/test_files/test_calibration.hdf5'\n",
    "TARGET_COMPOUND = 'water'\n",
    "HDF5 = h5py.File(HDF5_FILENAME, 'r')\n",
    "X_DATA = np.asarray(HDF5['{}/wavenumber'.format(TARGET_COMPOUND)])\n",
    "Y_DATA = np.asarray(HDF5['{}/counts'.format(TARGET_COMPOUND)])\n",
    "TUPLE_LIST = list(zip(X_DATA, Y_DATA))\n",
    "\n",
    "\n",
    "def test_interp_and_norm():\n",
    "    \"\"\"\n",
    "    A function that tests that the interpolatespectra.interp_and_norm function is behaving\n",
    "    as expected.\n",
    "    \"\"\"\n",
    "    tuple_list = interpolatespectra.interp_and_norm(HDF5_FILENAME, TARGET_COMPOUND)\n",
    "    assert isinstance(tuple_list, list), '`tuple_list` is not a list'\n",
    "    assert isinstance(tuple_list[0], tuple), 'first element of `tuple_list` is not a tuple'\n",
    "    assert isinstance(tuple_list[0][0], np.int64), 'first element of tuple is not a np.int64'\n",
    "    x_data, y_data = zip(*tuple_list)\n",
    "    assert max(y_data) <= 1, 'spectra was not normalized correctly'\n",
    "    try:\n",
    "        interpolatespectra.interp_and_norm(4.2, TARGET_COMPOUND)\n",
    "    except TypeError:\n",
    "        print('A float was passed to the function, and was handled well with a TypeError.')\n",
    "    try:\n",
    "        interpolatespectra.interp_and_norm('hdf5.txt', TARGET_COMPOUND)\n",
    "    except TypeError:\n",
    "        print('A .txt was passed to the function, and was handled well with a TypeError.')\n",
    "    try:\n",
    "        interpolatespectra.interp_and_norm(HDF5_FILENAME, [TARGET_COMPOUND])\n",
    "    except TypeError:\n",
    "        print('A list was passed to the function, and was handled well with a TypeError.')\n",
    "\n",
    "test_interp_and_norm()\n",
    "print()\n",
    "    \n",
    "def test_apply_scaling():\n",
    "    \"\"\"\n",
    "    A function that tests that the interpolatespectra.apply_scaling function is behaving\n",
    "    as expected.\n",
    "    \"\"\"\n",
    "    # and odd value for j means the compound should be present if i and target_index match\n",
    "    j = 7\n",
    "    i = 3\n",
    "    target_index = 3\n",
    "    scaled_tuple_list = interpolatespectra.apply_scaling(TUPLE_LIST, j, i, target_index)\n",
    "    assert len(scaled_tuple_list) == len(TUPLE_LIST), 'scaled data not the same size as input data'\n",
    "    assert isinstance(scaled_tuple_list, list), '`scaled_tuple_list` is not a list'\n",
    "    assert isinstance(scaled_tuple_list[0], tuple), 'first element of `scaled_tuple_list` is not a tuple'\n",
    "    try:\n",
    "        interpolatespectra.apply_scaling(4.2, j, i, target_index)\n",
    "    except TypeError:\n",
    "        print('A float was passed to the function, and was handled well with a TypeError.')\n",
    "    try:\n",
    "        interpolatespectra.apply_scaling([1, 2, 3, 4], j, i, target_index)\n",
    "    except TypeError:\n",
    "        print(\"\"\"A list not containing tuples was passed to the function,\n",
    "         and was handled well with a TypeError.\"\"\")\n",
    "    try:\n",
    "        interpolatespectra.apply_scaling(TUPLE_LIST, True, i, target_index)\n",
    "    except TypeError:\n",
    "        print('A boolean was passed to the function, and was handled well with a TypeError.')\n",
    "    try:\n",
    "        interpolatespectra.apply_scaling(TUPLE_LIST, j, 3, target_index)\n",
    "    except TypeError:\n",
    "        print('An int was passed to the function, and was handled well with a TypeError.')\n",
    "    try:\n",
    "        interpolatespectra.apply_scaling(TUPLE_LIST, j, i, 4.2)\n",
    "    except TypeError:\n",
    "        print('A float was passed to the function, and was handled well with a TypeError.')\n",
    "        \n",
    "test_apply_scaling()\n",
    "print()\n",
    "\n",
    "\n",
    "def test_generate_spectra_dataset():\n",
    "    \"\"\"\n",
    "    A function that tests that the interpolatespectra.generate_spectra_dataset\n",
    "    function is behaving as expected.\n",
    "    \"\"\"\n",
    "    spectra_count = 20\n",
    "    x_data, y_data, label = interpolatespectra.generate_spectra_dataset(HDF5_FILENAME,\n",
    "                                                                        TARGET_COMPOUND,\n",
    "                                                                        spectra_count)\n",
    "    assert len(x_data) == 20, 'incorrect number of spectra generated (x_data)'\n",
    "    assert len(y_data) == 20, 'incorrect number of spectra generated (y_data)'\n",
    "    assert len(label) == 20, 'incorrect number of spectra generated (label)'\n",
    "    try:\n",
    "        interpolatespectra.generate_spectra_dataset(4.2,\n",
    "                                                    TARGET_COMPOUND,\n",
    "                                                    spectra_count)\n",
    "    except TypeError:\n",
    "        print('A float was passed to the function and was handled well with a TypeError')\n",
    "    try:\n",
    "        interpolatespectra.generate_spectra_dataset('file.txt',\n",
    "                                                    TARGET_COMPOUND,\n",
    "                                                    spectra_count)\n",
    "    except TypeError:\n",
    "        print('A .txt was passed to the function and was handled well with a TypeError')\n",
    "    try:\n",
    "        interpolatespectra.generate_spectra_dataset(HDF5_FILENAME,\n",
    "                                                    7,\n",
    "                                                    spectra_count)\n",
    "    except TypeError:\n",
    "        print('An int was passed to the function and was handled well with a TypeError')\n",
    "    try:\n",
    "        interpolatespectra.generate_spectra_dataset(HDF5_FILENAME,\n",
    "                                                    TARGET_COMPOUND,\n",
    "                                                    -1)\n",
    "    except ValueError:\n",
    "        print('A negative int was passed to the function and was handled well with a TypeError')\n",
    "    try:\n",
    "        interpolatespectra.generate_spectra_dataset(HDF5_FILENAME,\n",
    "                                                    TARGET_COMPOUND,\n",
    "                                                    [1, 2, 3])\n",
    "    except TypeError:\n",
    "        print('A list was passed to the function and was handled well with a TypeError')\n",
    "        \n",
    "test_generate_spectra_dataset()\n",
    "print()\n",
    "\n",
    "def test_keyfinder():\n",
    "    \"\"\"\n",
    "    A function that tests that the interpolatespectra.keyfinder function is behaving\n",
    "    as expected.\n",
    "    \"\"\"\n",
    "    hdf5_filename = 'ramandecompy/tests/test_files/test_experiment.hdf5'\n",
    "    key_list = interpolatespectra.keyfinder(hdf5_filename)\n",
    "    assert isinstance(key_list, list), 'expected output is not a list'\n",
    "    assert isinstance(key_list[0], str), 'first element of list should be a string'\n",
    "    assert len(key_list) == 5, 'number of keys in hdf5 file is incorrect'\n",
    "    try:\n",
    "        interpolatespectra.keyfinder(4.2)\n",
    "    except TypeError:\n",
    "        print('A float was passed to the function and was handled well with a TypeError')\n",
    "    try:\n",
    "        interpolatespectra.keyfinder('hdf5_filename.txt')\n",
    "    except TypeError:\n",
    "        print('A .txt was passed to the function and was handled well with a TypeError')\n",
    "        \n",
    "test_keyfinder()\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A float was passed to the function and was handled well with a TypeError\n",
      "A .txt was passed to the function and was handled well with a TypeError\n",
      "An int was passed to the function and was handled well with a TypeError\n",
      "A negative int was passed to the function and was handled well with a TypeError\n",
      "A list was passed to the function and was handled well with a TypeError\n"
     ]
    },
    {
     "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": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}