Exp6.ipynb

{
 "metadata": {
  "name": "Exp6"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Mountain Car\n",
      "from stuff import *\n",
      "from pylab import *\n",
      "from random import *\n",
      "import pickle\n",
      "import numpy\n",
      "from rl import *\n",
      "import sys\n",
      "\n",
      "NB_SAMPLES=100\n",
      "#NB_SAMPLES=int(sys.argv[1])\n",
      "RAND_STRING=str(int(rand()*10000000000))\n",
      "\n",
      "\n",
      "ACTION_SPACE=[-1,0,1]\n",
      "\n",
      "\n",
      "\n",
      "def mountain_car_next_state(state,action):\n",
      "    position,speed=state\n",
      "    next_speed = squeeze(speed+action*0.001+cos(3*position)*(-0.0025))\n",
      "    next_position = squeeze(position+next_speed)\n",
      "    if not -0.07 <= next_speed <= 0.07:\n",
      "        next_speed = sign(next_speed)*0.07\n",
      "    if not -1.2 <= next_position <= 0.6:\n",
      "        next_speed=0.\n",
      "        next_position = -1.2 if next_position < -1.2 else 0.6\n",
      "    return array([next_position,next_speed])\n",
      "\n",
      "def mountain_car_uniform_state():\n",
      "    return array([numpy.random.uniform(low=-1.2,high=0.6),numpy.random.uniform(low=-0.07,high=0.07)])\n",
      "\n",
      "mountain_car_mu_position, mountain_car_mu_speed = meshgrid(linspace(-1.2,0.6,7),linspace(-0.07,0.07,7))\n",
      "\n",
      "mountain_car_sigma_position = 2*pow((0.6+1.2)/10.,2)\n",
      "mountain_car_sigma_speed = 2*pow((0.07+0.07)/10.,2)\n",
      "\n",
      "def mountain_car_single_psi(state):\n",
      "    position,speed=state\n",
      "    psi=[]\n",
      "    for mu in zip_stack(mountain_car_mu_position, mountain_car_mu_speed).reshape(7*7,2):\n",
      "        psi.append(exp( -pow(position-mu[0],2)/mountain_car_sigma_position \n",
      "                        -pow(speed-mu[1],2)/mountain_car_sigma_speed))\n",
      "    psi.append(1.)\n",
      "    return array(psi).reshape((7*7+1,1))\n",
      "\n",
      "mountain_car_psi= non_scalar_vectorize(mountain_car_single_psi,(2,),(50,1))\n",
      "\n",
      "def mountain_car_single_phi(sa):\n",
      "    state=sa[:2]\n",
      "    index_action = int(sa[-1])+1\n",
      "    answer=zeros(((7*7+1)*3,1))\n",
      "    answer[index_action*(7*7+1):index_action*(7*7+1)+7*7+1] = mountain_car_psi(state)\n",
      "    return answer\n",
      "\n",
      "mountain_car_phi= non_scalar_vectorize(mountain_car_single_phi,(3,),(150,1))\n",
      "\n",
      "def mountain_car_reward(sas):\n",
      "    position=sas[0]\n",
      "    return 1 if position > 0.5 else 0\n",
      "\n",
      "def mountain_car_episode_length(initial_position,initial_speed,policy):\n",
      "    answer = 0\n",
      "    reward = 0.\n",
      "    state = array([initial_position,initial_speed])\n",
      "    while answer < 300 and reward == 0. :\n",
      "        action = policy(state)\n",
      "        next_state = mountain_car_next_state(state,action)\n",
      "        reward = mountain_car_reward(hstack([state, action, next_state]))\n",
      "        state=next_state\n",
      "        answer+=1\n",
      "    return answer\n",
      "\n",
      "def mountain_car_episode_vlength(policy):\n",
      "    return vectorize(lambda p,s:mountain_car_episode_length(p,s,policy))\n",
      "\n",
      "\n",
      "def mountain_car_training_data(freward=mountain_car_reward,traj_length=5,nb_traj=1000):\n",
      "    traj = []\n",
      "    random_policy = lambda s:choice(ACTION_SPACE)\n",
      "    for i in range(0,nb_traj):\n",
      "        state = mountain_car_uniform_state()\n",
      "        reward=0\n",
      "        t=0\n",
      "        while t < traj_length and reward == 0:\n",
      "            t+=1\n",
      "            action = random_policy(state)\n",
      "            next_state = mountain_car_next_state(state, action)\n",
      "            reward = freward(hstack([state, action, next_state]))\n",
      "            traj.append(hstack([state, action, next_state, reward]))\n",
      "            state=next_state\n",
      "    return array(traj)\n",
      "\n",
      "def mountain_car_manual_policy(state):\n",
      "    position,speed = state\n",
      "    return -1. if speed <=0 else 1.\n",
      "\n",
      "def mountain_car_interesting_state():\n",
      "    position = numpy.random.uniform(low=-1.2,high=-0.9)\n",
      "    speed = numpy.random.uniform(low=-0.07,high=0)\n",
      "    return array([position,speed])\n",
      "\n",
      "def mountain_car_IRL_traj():\n",
      "    traj = []\n",
      "    state = mountain_car_interesting_state()\n",
      "    reward = 0\n",
      "    while reward == 0:\n",
      "        action = mountain_car_manual_policy(state)\n",
      "        next_state = mountain_car_next_state(state, action)\n",
      "        next_action = mountain_car_manual_policy(next_state)\n",
      "        reward = mountain_car_reward(hstack([state, action, next_state]))\n",
      "        traj.append(hstack([state, action, next_state, next_action, reward]))\n",
      "        state=next_state\n",
      "    return array(traj)\n",
      "\n",
      "def mountain_car_IRL_data(nbsamples):\n",
      "    data = mountain_car_IRL_traj()\n",
      "    while len(data) < nbsamples:\n",
      "        data = vstack([data,mountain_car_IRL_traj()])\n",
      "    return data[:nbsamples]\n",
      "\n",
      "def mountain_car_testing_state():\n",
      "    position = numpy.random.uniform(low=-1.2,high=0.5)\n",
      "    speed = numpy.random.uniform(low=-0.07,high=0.07)\n",
      "    return array([position,speed])\n",
      "\n",
      "def mountain_car_mean_performance(policy):\n",
      "    return mean([mountain_car_episode_length(state[0],state[1],policy) for state in [mountain_car_testing_state() for i in range(0,10)]])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import glob\n",
      "import pickle\n",
      "\n",
      "X=[10, 30, 100, 300, 700, 1000]\n",
      "#X=[10, 100, 300]\n",
      "Y_mean_CSI=[]\n",
      "Y_deviation_CSI=[]\n",
      "Y_min_CSI=[]\n",
      "Y_max_CSI=[]\n",
      "Y_mean_Class=[]\n",
      "Y_deviation_Class=[]\n",
      "Y_min_Class=[]\n",
      "Y_max_Class=[]\n",
      "Y_mean_SCIRL=[]\n",
      "Y_deviation_SCIRL=[]\n",
      "Y_min_SCIRL=[]\n",
      "Y_max_SCIRL=[]\n",
      "Y_mean_SCIRLMC=[]\n",
      "Y_deviation_SCIRLMC=[]\n",
      "Y_min_SCIRLMC=[]\n",
      "Y_max_SCIRLMC=[]\n",
      "Y_mean_Expert=[]\n",
      "Y_deviation_Expert=[]\n",
      "Y_min_Expert=[]\n",
      "Y_max_Expert=[]\n",
      "Y_mean_RE=[]\n",
      "Y_deviation_RE=[]\n",
      "Y_min_RE=[]\n",
      "Y_max_RE=[]\n",
      "\n",
      "all_data_CSI=[]\n",
      "all_data_Classif=[]\n",
      "all_data_Expert=[]\n",
      "all_data_SCIRL=[]\n",
      "all_data_SCIRLMC=[]\n",
      "all_data_RE=[]\n",
      "\n",
      "for x in X:\n",
      "    CSI_files = glob.glob(\"data/CSI_omega_\"+str(x)+\"_*.mat\")[:3]\n",
      "    Classif_files = glob.glob(\"data/Classif_\"+str(x)+\"_*.obj\")[:3]\n",
      "    #Expert_files = glob.glob(\"data/Expert_omega_\"+str(x)+\"_*.mat\")#[:3]\n",
      "    SCIRL_files = glob.glob(\"data/SCIRL_omega_\"+str(x)+\"_*.mat\")[:3]\n",
      "    SCIRLMC_files = glob.glob(\"data/SCIRLMC_omega_\"+str(x)+\"_*.mat\")[:3]\n",
      "    RE_files = glob.glob(\"data/RE_omega_\"+str(x)+\"_*.mat\")[:3]\n",
      "    #print CSI_files\n",
      "    #print Classif_files\n",
      "    #print Expert_files\n",
      "    #print SCIRL_files\n",
      "\n",
      "    data_CSI=[]\n",
      "    data_Classif=[]\n",
      "    data_Expert=[]\n",
      "    data_SCIRL=[]\n",
      "    data_SCIRLMC=[]\n",
      "    data_RE=[]\n",
      "\n",
      "    for CSI_file,Classif_file,SCIRL_file,SCIRLMC_file,RE_file in zip(CSI_files,Classif_files,SCIRL_files,SCIRLMC_files,RE_files):\n",
      "        omega_CSI=genfromtxt(CSI_file)\n",
      "        policy_CSI=greedy_policy(omega_CSI, mountain_car_phi, ACTION_SPACE)\n",
      "        perf_CSI = mountain_car_mean_performance(policy_CSI)\n",
      "        data_CSI.append(perf_CSI) \n",
      "        \n",
      "        with open(Classif_file, 'rb') as input:\n",
      "            clf = pickle.load(input)\n",
      "        clf_predict= lambda state : clf.predict(squeeze(state))\n",
      "        vpredict = non_scalar_vectorize( clf_predict, (2,), (1,1) )\n",
      "        pi_c = lambda state: vpredict(state).reshape(state.shape[:-1]+(1,))\n",
      "        perf_Classif = mountain_car_mean_performance(pi_c)\n",
      "        data_Classif.append(perf_Classif) \n",
      "        \n",
      "        #omega=genfromtxt(Expert_file)\n",
      "        #policy=greedy_policy(omega, mountain_car_phi, ACTION_SPACE)\n",
      "        perf_Expert = mountain_car_mean_performance(mountain_car_manual_policy)\n",
      "        data_Expert.append(perf_Expert)\n",
      "        \n",
      "        omega_SCIRL=genfromtxt(SCIRL_file)\n",
      "        policy_SCIRL=greedy_policy(omega_SCIRL, mountain_car_phi, ACTION_SPACE)\n",
      "        perf_SCIRL = mountain_car_mean_performance(policy_SCIRL)\n",
      "        data_SCIRL.append(perf_SCIRL)\n",
      "        \n",
      "        omega_SCIRLMC=genfromtxt(SCIRLMC_file)\n",
      "        policy_SCIRLMC=greedy_policy(omega_SCIRLMC, mountain_car_phi, ACTION_SPACE)\n",
      "        perf_SCIRLMC = mountain_car_mean_performance(policy_SCIRLMC)\n",
      "        data_SCIRLMC.append(perf_SCIRLMC)\n",
      "        \n",
      "        omega_RE=genfromtxt(RE_file)\n",
      "        policy_RE=greedy_policy(omega_RE, mountain_car_phi, ACTION_SPACE)\n",
      "        perf_RE = mountain_car_mean_performance(policy_RE)\n",
      "        data_RE.append(perf_RE)\n",
      "        \n",
      "        \n",
      "        print \"\\tNb_samples :\\t\"+str(x)\n",
      "        print \"\\tLength CSI :\\t\"+str(perf_CSI)\n",
      "        print \"\\tLength Class :\\t\"+str(perf_Classif)\n",
      "        print \"\\tLength SCIRL :\\t\"+str(perf_SCIRL)\n",
      "        print \"\\tLength SCIRLMC :\\t\"+str(perf_SCIRLMC)\n",
      "        print \"\\tLength RE :\\t\"+str(perf_RE)\n",
      "        print \"\\tLength exp :\\t\"+str(perf_Expert)\n",
      "    print \"Nb_samples :\\t\"+str(x)\n",
      "    print \"Mean length CSI :\\t\"+str(mean(data_CSI))\n",
      "    print \"Mean length Class :\\t\"+str(mean(data_Classif))\n",
      "    print \"Mean length Expert :\\t\"+str(mean(data_Expert))\n",
      "    print \"Mean length SCIRL :\\t\"+str(mean(data_SCIRL))\n",
      "    print \"Mean length RE :\\t\"+str(perf_RE)\n",
      "    print \"Mean length SCIRLMC :\\t\"+str(mean(data_SCIRLMC))\n",
      "    \n",
      "    all_data_CSI.append(data_CSI)\n",
      "    all_data_Classif.append(data_Classif)\n",
      "    all_data_Expert.append(data_Expert)\n",
      "    all_data_SCIRL.append(data_SCIRL)\n",
      "    all_data_SCIRLMC.append(data_SCIRLMC)\n",
      "    all_data_RE.append(data_RE)\n",
      "    \n",
      "    Y_mean_CSI.append(mean(data_CSI))\n",
      "    Y_deviation_CSI.append(sqrt(var(data_CSI)))\n",
      "    Y_min_CSI.append(min(data_CSI))\n",
      "    Y_max_CSI.append(max(data_CSI))\n",
      "    Y_mean_Class.append(mean(data_Classif))\n",
      "    Y_deviation_Class.append(sqrt(var(data_Classif)))\n",
      "    Y_min_Class.append(min(data_Classif))\n",
      "    Y_max_Class.append(max(data_Classif))\n",
      "    Y_mean_SCIRL.append(mean(data_SCIRL))\n",
      "    Y_deviation_SCIRL.append(sqrt(var(data_SCIRL)))\n",
      "    Y_min_SCIRL.append(min(data_SCIRL))\n",
      "    Y_max_SCIRL.append(max(data_SCIRL))\n",
      "    Y_mean_SCIRLMC.append(mean(data_SCIRLMC))\n",
      "    Y_deviation_SCIRLMC.append(sqrt(var(data_SCIRLMC)))\n",
      "    Y_min_SCIRLMC.append(min(data_SCIRLMC))\n",
      "    Y_max_SCIRLMC.append(max(data_SCIRLMC))\n",
      "    Y_mean_RE.append(mean(data_RE))\n",
      "    Y_deviation_RE.append(sqrt(var(data_RE)))\n",
      "    Y_min_RE.append(min(data_RE))\n",
      "    Y_max_RE.append(max(data_RE))\n",
      "    Y_mean_Expert.append(mean(data_Expert))\n",
      "    Y_deviation_Expert.append(sqrt(var(data_Expert)))\n",
      "    Y_min_Expert.append(min(data_Expert))\n",
      "    Y_max_Expert.append(max(data_Expert))\n",
      "\n",
      "Y_mean_CSI=array(Y_mean_CSI)\n",
      "Y_deviation_CSI=array(Y_deviation_CSI)\n",
      "Y_min_CSI=array(Y_min_CSI)\n",
      "Y_max_CSI=array(Y_max_CSI)\n",
      "Y_mean_Class=array(Y_mean_Class)\n",
      "Y_deviation_Class=array(Y_deviation_Class)\n",
      "Y_min_Class=array(Y_min_Class)\n",
      "Y_max_Class=array(Y_max_Class)\n",
      "Y_mean_SCIRL=array(Y_mean_SCIRL)\n",
      "Y_deviation_SCIRL=array(Y_deviation_SCIRL)\n",
      "Y_min_SCIRL=array(Y_min_SCIRL)\n",
      "Y_max_SCIRL=array(Y_max_SCIRL)\n",
      "Y_deviation_SCIRLMC=array(Y_deviation_SCIRLMC)\n",
      "Y_min_SCIRLMC=array(Y_min_SCIRLMC)\n",
      "Y_max_SCIRLMC=array(Y_max_SCIRLMC)\n",
      "Y_mean_Expert=array(Y_mean_Expert)\n",
      "Y_deviation_Expert=array(Y_deviation_Expert)\n",
      "Y_min_Expert=array(Y_min_Expert)\n",
      "Y_max_Expert=array(Y_max_Expert)\n",
      "Y_mean_RE=array(Y_mean_RE)\n",
      "Y_deviation_RE=array(Y_deviation_RE)\n",
      "Y_min_RE=array(Y_min_RE)\n",
      "Y_max_RE=array(Y_max_RE)\n",
      "    \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\tNb_samples :\t10\n",
        "\tLength CSI :\t241.5\n",
        "\tLength Class :\t300.0\n",
        "\tLength SCIRL :\t270.3\n",
        "\tLength SCIRLMC :\t270.2\n",
        "\tLength SCIRLMC :\t137.3\n",
        "\tLength exp :\t45.5\n",
        "\tNb_samples :\t10"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t214.8\n",
        "\tLength Class :\t100.7\n",
        "\tLength SCIRL :\t300.0\n",
        "\tLength SCIRLMC :\t270.4\n",
        "\tLength SCIRLMC :\t116.2\n",
        "\tLength exp :\t43.1\n",
        "\tNb_samples :\t10"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t245.6\n",
        "\tLength Class :\t73.6\n",
        "\tLength SCIRL :\t272.3\n",
        "\tLength SCIRLMC :\t300.0\n",
        "\tLength SCIRLMC :\t211.8\n",
        "\tLength exp :\t54.3\n",
        "Nb_samples :\t10\n",
        "Mean length CSI :\t233.966666667\n",
        "Mean length Class :\t158.1\n",
        "Mean length Expert :\t47.6333333333\n",
        "Mean length SCIRL :\t280.866666667\n",
        "\tLength SCIRLMC :\t211.8\n",
        "Mean length SCIRLMC :\t280.2\n",
        "\tNb_samples :\t30"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t114.8\n",
        "\tLength Class :\t144.4\n",
        "\tLength SCIRL :\t60.1\n",
        "\tLength SCIRLMC :\t48.8\n",
        "\tLength SCIRLMC :\t122.8\n",
        "\tLength exp :\t50.4\n",
        "\tNb_samples :\t30"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t51.3\n",
        "\tLength Class :\t118.9\n",
        "\tLength SCIRL :\t75.4\n",
        "\tLength SCIRLMC :\t69.2\n",
        "\tLength SCIRLMC :\t179.0\n",
        "\tLength exp :\t51.0\n",
        "\tNb_samples :\t30"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t58.9\n",
        "\tLength Class :\t147.0\n",
        "\tLength SCIRL :\t241.7\n",
        "\tLength SCIRLMC :\t77.3\n",
        "\tLength SCIRLMC :\t139.6\n",
        "\tLength exp :\t41.2\n",
        "Nb_samples :\t30\n",
        "Mean length CSI :\t75.0\n",
        "Mean length Class :\t136.766666667\n",
        "Mean length Expert :\t47.5333333333\n",
        "Mean length SCIRL :\t125.733333333\n",
        "\tLength SCIRLMC :\t139.6\n",
        "Mean length SCIRLMC :\t65.1\n",
        "\tNb_samples :\t100"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t95.3\n",
        "\tLength Class :\t37.0\n",
        "\tLength SCIRL :\t55.3\n",
        "\tLength SCIRLMC :\t74.7\n",
        "\tLength SCIRLMC :\t95.8\n",
        "\tLength exp :\t39.9\n",
        "\tNb_samples :\t100"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t75.4\n",
        "\tLength Class :\t215.6\n",
        "\tLength SCIRL :\t80.2\n",
        "\tLength SCIRLMC :\t37.0\n",
        "\tLength SCIRLMC :\t118.3\n",
        "\tLength exp :\t48.2\n",
        "\tNb_samples :\t100"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t43.7\n",
        "\tLength Class :\t57.9\n",
        "\tLength SCIRL :\t59.0\n",
        "\tLength SCIRLMC :\t63.9\n",
        "\tLength SCIRLMC :\t95.4\n",
        "\tLength exp :\t66.2\n",
        "Nb_samples :\t100\n",
        "Mean length CSI :\t71.4666666667\n",
        "Mean length Class :\t103.5\n",
        "Mean length Expert :\t51.4333333333\n",
        "Mean length SCIRL :\t64.8333333333\n",
        "\tLength SCIRLMC :\t95.4\n",
        "Mean length SCIRLMC :\t58.5333333333\n",
        "\tNb_samples :\t300"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t65.7\n",
        "\tLength Class :\t128.2\n",
        "\tLength SCIRL :\t39.2\n",
        "\tLength SCIRLMC :\t89.2\n",
        "\tLength SCIRLMC :\t175.3\n",
        "\tLength exp :\t45.8\n",
        "\tNb_samples :\t300"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t87.7\n",
        "\tLength Class :\t119.2\n",
        "\tLength SCIRL :\t50.9\n",
        "\tLength SCIRLMC :\t42.6\n",
        "\tLength SCIRLMC :\t65.4\n",
        "\tLength exp :\t54.8\n",
        "\tNb_samples :\t300"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t42.8\n",
        "\tLength Class :\t102.3\n",
        "\tLength SCIRL :\t83.1\n",
        "\tLength SCIRLMC :\t49.5\n",
        "\tLength SCIRLMC :\t177.5\n",
        "\tLength exp :\t64.0\n",
        "Nb_samples :\t300\n",
        "Mean length CSI :\t65.4\n",
        "Mean length Class :\t116.566666667\n",
        "Mean length Expert :\t54.8666666667\n",
        "Mean length SCIRL :\t57.7333333333\n",
        "\tLength SCIRLMC :\t177.5\n",
        "Mean length SCIRLMC :\t60.4333333333\n",
        "\tNb_samples :\t700"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t75.6\n",
        "\tLength Class :\t120.7\n",
        "\tLength SCIRL :\t47.5\n",
        "\tLength SCIRLMC :\t60.0\n",
        "\tLength SCIRLMC :\t89.4\n",
        "\tLength exp :\t60.9\n",
        "\tNb_samples :\t700"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t55.5\n",
        "\tLength Class :\t177.3\n",
        "\tLength SCIRL :\t68.8\n",
        "\tLength SCIRLMC :\t62.9\n",
        "\tLength SCIRLMC :\t152.6\n",
        "\tLength exp :\t57.7\n",
        "\tNb_samples :\t700"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t64.2\n",
        "\tLength Class :\t80.0\n",
        "\tLength SCIRL :\t55.7\n",
        "\tLength SCIRLMC :\t65.0\n",
        "\tLength SCIRLMC :\t147.7\n",
        "\tLength exp :\t44.3\n",
        "Nb_samples :\t700\n",
        "Mean length CSI :\t65.1\n",
        "Mean length Class :\t126.0\n",
        "Mean length Expert :\t54.3\n",
        "Mean length SCIRL :\t57.3333333333\n",
        "\tLength SCIRLMC :\t147.7\n",
        "Mean length SCIRLMC :\t62.6333333333\n",
        "\tNb_samples :\t1000"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t42.2\n",
        "\tLength Class :\t172.9\n",
        "\tLength SCIRL :\t66.6\n",
        "\tLength SCIRLMC :\t68.3\n",
        "\tLength SCIRLMC :\t116.4\n",
        "\tLength exp :\t60.5\n",
        "\tNb_samples :\t1000"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t71.7\n",
        "\tLength Class :\t163.2\n",
        "\tLength SCIRL :\t75.9\n",
        "\tLength SCIRLMC :\t59.7\n",
        "\tLength SCIRLMC :\t150.6\n",
        "\tLength exp :\t37.2\n",
        "\tNb_samples :\t1000"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\tLength CSI :\t49.5\n",
        "\tLength Class :\t89.6\n",
        "\tLength SCIRL :\t70.1\n",
        "\tLength SCIRLMC :\t66.5\n",
        "\tLength SCIRLMC :\t102.7\n",
        "\tLength exp :\t46.9\n",
        "Nb_samples :\t1000\n",
        "Mean length CSI :\t54.4666666667\n",
        "Mean length Class :\t141.9\n",
        "Mean length Expert :\t48.2\n",
        "Mean length SCIRL :\t70.8666666667\n",
        "\tLength SCIRLMC :\t102.7\n",
        "Mean length SCIRLMC :\t64.8333333333\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#With N the number of runs and |X| the number of abcissas, we save the performance of the various algos in |X|xN matrices\n",
      "Xstr = \"_\".join(map(str,X))\n",
      "savetxt(\"data/CSI_X_\"+Xstr+\".mat\", array(all_data_CSI))\n",
      "savetxt(\"data/SCIRL_X_\"+Xstr+\".mat\", array(all_data_SCIRL))\n",
      "savetxt(\"data/SCIRLMC_X_\"+Xstr+\".mat\", array(all_data_SCIRLMC))\n",
      "savetxt(\"data/RE_X_\"+Xstr+\".mat\", array(all_data_RE))\n",
      "savetxt(\"data/Classif_X_\"+Xstr+\".mat\", array(all_data_Classif))\n",
      "savetxt(\"data/Expert_X_\"+Xstr+\".mat\", array(all_data_Expert))\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 13
    }
   ],
   "metadata": {}
  }
 ]
}