all_parameters_combinations.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Produce number of tasks with parameters from given ranges.\n",
    "# 2017 (C) Bryzgalov Peter @ CHITEC, Stair Lab\n",
    "\n",
    "import yaml\n",
    "import pprint\n",
    "import numpy as np\n",
    "\n",
    "def yamlLoad(filepath):\n",
    "    with open(filepath,\"r\") as fd:\n",
    "        data = yaml.load(fd)\n",
    "    return data\n",
    "\n",
    "      \n",
    "def yaml2Matrix(filepath):\n",
    "    par_matrix = []\n",
    "    data=yamlLoad(filepath)\n",
    "    if type(data) is dict:\n",
    "        for k in data:\n",
    "            param = data[k]\n",
    "            #print \">> \"+k + \" : \" + str(data[k]) + \" \"+str(type(param))\n",
    "            \n",
    "            if type(param) is list:\n",
    "                llength=len(param)\n",
    "                #print \"List length = \" + str(llength)\n",
    "                #for par in param:\n",
    "                #    print k+\"=\"+str(par)\n",
    "                matrix_line = [k]\n",
    "                matrix_line.extend(param)\n",
    "                par_matrix.append(matrix_line)\n",
    "            \n",
    "            elif type(param) is tuple:\n",
    "                llength=len(param)\n",
    "                #print \"Tuple length = \" + str(llength)\n",
    "                if llength < 2:\n",
    "                    print \"Need range stat and end values: [start, end].\"\n",
    "                    print \"Only one value provided:\" + str(param)\n",
    "                    break\n",
    "                    \n",
    "                matrix_line = [k]\n",
    "                start=param[0]\n",
    "                end  =param[1]                \n",
    "                if llength > 2:\n",
    "                    step = param[2]\n",
    "                else:\n",
    "                    step = 1\n",
    "                #print start, end, step\n",
    "                for val in np.arange(start, end, step):\n",
    "                    #print k+\"=\"+str(val)\n",
    "                    matrix_line.append(val)\n",
    "                    \n",
    "                par_matrix.append(matrix_line)\n",
    "                \n",
    "            elif type(param) is bool:\n",
    "                #print k + \" is \" + str(param)\n",
    "                if param:\n",
    "                    matrix_line=[k,\"\"]\n",
    "                    par_matrix.append(matrix_line)\n",
    "                \n",
    "            elif type(param) is dict:\n",
    "                # Not used in parametrisation\n",
    "                print \"Dictionary type is not used in parameters definition.\"\n",
    "                #for key1 in param:\n",
    "                #    print key1 + \"=\" + str(param[key1])\n",
    "\n",
    "    return par_matrix\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def concat(a,b):\n",
    "    comb = []\n",
    "    if type(a) is list:\n",
    "        comb.extend(a)\n",
    "    else:\n",
    "        comb.append(a)\n",
    "    if type(b) is list:\n",
    "        comb.extend(b)\n",
    "    else:\n",
    "        comb.append(b)\n",
    "    return comb\n",
    "\n",
    "def joinLists(a, b):\n",
    "    if len(a)==0:\n",
    "        return b\n",
    "    elif len(b)==0:\n",
    "        return a\n",
    "    c = []\n",
    "    for i in range (0, len(a)):\n",
    "        for j in range (0, len(b)):\n",
    "            combination=concat(a[i],b[j])\n",
    "            c.append(combination)\n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "filepath = \"bowcnn/paramtest.yml\"\n",
    "para_matrix = yaml2Matrix(filepath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['fasttext', 'mlp3l']\n",
      "[1, 3, 5]\n",
      "===\n",
      "[['fasttext' '1']\n",
      " ['fasttext' '3']\n",
      " ['fasttext' '5']\n",
      " ['mlp3l' '1']\n",
      " ['mlp3l' '3']\n",
      " ['mlp3l' '5']]\n"
     ]
    }
   ],
   "source": [
    "# Create combinations matrix\n",
    "combinations=[]\n",
    "for l in range(0, len(para_matrix)):\n",
    "    line = para_matrix[l][1:]\n",
    "    print line\n",
    "    combinations = joinLists(combinations, line)\n",
    "print \"===\"\n",
    "print np.array(combinations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 0, 'model': 'fasttext', 'maxiter': '1'}\n",
      "{'a': 0, 'model': 'fasttext', 'maxiter': '3'}\n",
      "{'a': 0, 'model': 'fasttext', 'maxiter': '5'}\n",
      "{'a': 0, 'model': 'mlp3l', 'maxiter': '1'}\n",
      "{'a': 0, 'model': 'mlp3l', 'maxiter': '3'}\n",
      "{'a': 0, 'model': 'mlp3l', 'maxiter': '5'}\n"
     ]
    }
   ],
   "source": [
    "# Wrap combinataions into dictionary\n",
    "base_dict = {\n",
    "    \"a\":0\n",
    "}\n",
    "\n",
    "for c in range(0,len(combinations)):\n",
    "    dic=base_dict\n",
    "    for l in range(0, len(para_matrix)):\n",
    "        dic[para_matrix[l][0]]=str(combinations[c][l])\n",
    "    print dic\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/root\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from subprocess import Popen, PIPE, STDOUT\n",
    "# Check current dir\n",
    "pipe = Popen([\"pwd\"], stdout=PIPE, stderr=PIPE, close_fds=True)\n",
    "for line in iter(pipe.stdout.readline, b''):\n",
    "    print line\n",
    "for line in iter(pipe.stderr.readline, b''):\n",
    "    if len(line)>0:\n",
    "        print \"!\"+line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}