julia_taxi2-2_DFW_testing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using DataFrames\n",
    "using JSON\n",
    "using Iterators\n",
    "#using taxis\n",
    "using HDF5, JLD\n",
    "using Stats\n",
    "using kNN\n",
    "#using sequenceCompare\n",
    "#reload(\"taxis\")\n",
    "\n",
    "nprocs()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Begin\n",
      "loading csv files\n",
      "loading coords\n",
      "getting coords counts\n",
      "deleting unneeded data rows/columns\n",
      "adding start/end point columns\n",
      "deleting training examples with no coords!\n",
      "done!\n"
     ]
    }
   ],
   "source": [
    "println(\"Begin\")\n",
    "\n",
    "println(\"loading csv files\")\n",
    "taxi_df = readtable(\"/home/tony/ML/taxi/taxi2_time/train_100k.csv\")\n",
    "taxi_validation_df = readtable(\"/home/tony/ML/taxi/taxi2_time/test.csv\")\n",
    "\n",
    "println(\"loading coords\")\n",
    "taxi_df[:COORDS] = [float(hcat(JSON.parse(x)...)) for x in  taxi_df[:POLYLINE]]\n",
    "taxi_validation_df[:COORDS] = [float(hcat(JSON.parse(x)...)) for x in taxi_validation_df[:POLYLINE]]\n",
    "\n",
    "println(\"getting coords counts\")\n",
    "taxi_df[:NUM_COORDS] = [length(x)::Int64 for x in taxi_df[:COORDS]]\n",
    "taxi_validation_df[:NUM_COORDS] = [length(x)::Int64 for x in taxi_validation_df[:COORDS]]\n",
    "\n",
    "println(\"deleting unneeded data rows/columns\")\n",
    "delete!(taxi_validation_df, :POLYLINE)\n",
    "delete!(taxi_df, :POLYLINE)\n",
    "\n",
    "println(\"adding start/end point columns\")\n",
    "taxi_df[:START] = [x[:,1] for x in taxi_df[:COORDS]]\n",
    "taxi_validation_df[:START] = [x[:,1] for x in taxi_validation_df[:COORDS]]\n",
    "\n",
    "taxi_df[:END] = [x[:,end] for x in taxi_df[:COORDS]]\n",
    "taxi_validation_df[:END] = [x[:,end] for x in taxi_validation_df[:COORDS]]\n",
    "\n",
    "println(\"deleting training examples with no coords!\")\n",
    "#These examples are not going to be useful!\n",
    "deleterows!(taxi_df, find(taxi_df[:NUM_COORDS] .== 0))\n",
    "\n",
    "println(\"done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finding unique number of coords\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2x4774976 Array{Float64,2}:\n",
       " -8.61864  -8.6185  -8.62033  -8.62215  …  -8.6304  -8.63042  -8.63041\n",
       " 41.1414   41.1414  41.1425   41.1438      41.1579  41.158    41.1579 "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println(\"finding unique number of coords\")\n",
    "all_coords_val = hcat(taxi_validation_df[:COORDS]...)\n",
    "all_coords = hcat(taxi_df[:COORDS]...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating coord dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#small_taxi_df = GetTableOrderedSubset(taxi_df, 10000)\n",
    "#coordsDB = ConstructCoordsDatabase(small_taxi_df, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Creating new features\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "function GetDateInfo(df)\n",
    "    if haskey(df, :DAYOFWEEK)\n",
    "        return df\n",
    "end\n",
    "\n",
    "function GetDistanceData(df)\n",
    "    if haskey(df, :DISTANCE)\n",
    "        return df\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pFindClosestTrainingExampleForTestSet (generic function with 1 method)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# http://en.wikipedia.org/wiki/Dynamic_time_warping\n",
    "function DTWDistance{T}(s::Array{T}, t::Array{T})\n",
    "    n, m = size(s,2), size(t, 2)\n",
    "    DTW = zeros(n+1,m+1)\n",
    "    #println(\"sizeof DTW: \", size(DTW))\n",
    "    DTW[:,1], DTW[1,:] = Inf, Inf\n",
    "    DTW[1,1] = 0\n",
    "\n",
    "    for i=2:n+1\n",
    "        for j=2:m+1\n",
    "            #println(\"i=\", i, \"/\", n, \" j=\", j, \"/\", m, \" size(s)=\", size(s), \" size(t)=\", size(t))\n",
    "            cost = sum((s[:,i-1] - t[:,j-1]).^2)\n",
    "\n",
    "            DTW[i,j] = cost + min(DTW[i-1, j  ], #insertion\n",
    "                                  DTW[i  , j-1], #deletion\n",
    "                                  DTW[i-1, j-1]) #match\n",
    "            #println(\"cost is \", cost, \" i=\", i, \"/\", n, \" j=\", j, \"/\", m, \" DTW=\", DTW[i,j])\n",
    "        end\n",
    "    end\n",
    "\n",
    "    return DTW[n+1,m+1]\n",
    "end\n",
    "\n",
    "# note. there is also a windowed version for better performance!  See the wikipedia article\n",
    "\n",
    "\n",
    "function GetAverageDistanceFromCoordsSequence(coords)\n",
    "    #Outline of the basic algorithm\n",
    "    #for coord_pair c_1..c_n\n",
    "    # estimate <- for i=1:n average(15*(i-1) + average(for c_j in D[c+i] * exp(-|L_j-L_i|) * L_j)\n",
    "    coords = round(Coords[i],round_len)       \n",
    "        \n",
    "        num_coords = size(coords,2)\n",
    "end\n",
    "\n",
    "function GetAverageDistancesByCoordsDict(TripIds, Coords, round_len=5)\n",
    "    distaces = Array{Float64,0}()\n",
    "    num_coords = size(TripIds,1)\n",
    "    for i=1:num_coords\n",
    "        trip_id = TripIds[i]\n",
    "\n",
    "        coords = Coords[i]\n",
    "        if length(coords) == 0\n",
    "            continue\n",
    "        end\n",
    "        \n",
    "        coords = round(Coords[i],round_len)       \n",
    "        \n",
    "        num_coords = size(coords,2)\n",
    "        #println(\"num_coords: \", num_coords)\n",
    "        for j=1:num_coords\n",
    "            coord_pair = (coords[1,j], coords[2,j])\n",
    "            #println(\"coord_pair: \", coord_pair, \", j/num_coords: \", j, \"/\", num_coords, \", thing: \", [SequenceRef(trip_id, j, num_coords-j)])\n",
    "            if !haskey(D, coord_pair)\n",
    "                D[coord_pair] = [SequenceRef(trip_id, j, num_coords-j)]\n",
    "            else\n",
    "                push!(D[coord_pair], SequenceRef(trip_id, j, num_coords-j))\n",
    "            end        \n",
    "        end\n",
    "    end\n",
    "    \n",
    "    return D    \n",
    "end\n",
    "\n",
    "function findClosestTrainingExample(all_train_coords, test_path)\n",
    "    num_paths = length(all_train_coords)\n",
    "    best_dist = 9999.0\n",
    "    best_path = all_train_coords[1]\n",
    "    for k=1:num_paths\n",
    "        train_path = all_train_coords[k]\n",
    "        dist = DTWDistance(train_path, test_path) \n",
    "        #println(\"k=\", k, \" dist=\", dist)\n",
    "        if dist < best_dist\n",
    "            #println(k, \", old best: \", best_dist, \" new best: \", dist)\n",
    "            best_dist = dist\n",
    "            best_path = all_train_coords[k]\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    return best_path\n",
    "end\n",
    "\n",
    "function findClosestTrainingExampleForTestSet(all_train_paths, all_test_paths)\n",
    "    \n",
    "    \n",
    "    num_train_paths = length(all_train_paths)\n",
    "    num_test_paths = length(all_test_paths)\n",
    "    closest_examples = cell(num_test_paths)\n",
    "    for k=1:num_test_paths\n",
    "        if k % 20 == 0\n",
    "            println(k, \"/\", num_test_paths, \" for \", num_train_paths, \" train path examples\") \n",
    "        end\n",
    "        test_path = all_test_paths[k]\n",
    "        closest_training_example = findClosestTrainingExample(all_train_paths, test_path) \n",
    "        closest_examples[k] = closest_training_example\n",
    "    end\n",
    "    \n",
    "    return closest_examples\n",
    "end\n",
    "\n",
    "function pFindClosestTrainingExampleForTestSet(all_train_paths, all_test_paths)\n",
    "    function findClosestTrainingExample(all_train_coords, test_path)\n",
    "        num_paths = length(all_train_coords)\n",
    "        best_dist = 9999.0\n",
    "        best_path = all_train_coords[1]\n",
    "        for k=1:num_paths\n",
    "            train_path = all_train_coords[k]\n",
    "            dist = DTWDistance(train_path, test_path) \n",
    "            #println(\"k=\", k, \" dist=\", dist)\n",
    "            if dist < best_dist\n",
    "                #println(k, \", old best: \", best_dist, \" new best: \", dist)\n",
    "                best_dist = dist\n",
    "                best_path = all_train_coords[k]\n",
    "            end\n",
    "        end\n",
    "\n",
    "        return best_path\n",
    "    end\n",
    "    \n",
    "    getClosestExample = p -> findClosestTrainingExample(all_train_paths, p)\n",
    "    return pmap(getClosestExample, all_test_paths)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20/320 for 20000 train path examples\n",
      "40/320 for 20000 train path examples\n",
      "60/320 for 20000 train path examples\n",
      "80/320 for 20000 train path examples\n",
      "100/320 for 20000 train path examples\n",
      "120/320 for 20000 train path examples\n",
      "140/320 for 20000 train path examples\n",
      "160/320 for 20000 train path examples\n",
      "180/320 for 20000 train path examples\n",
      "200/320 for 20000 train path examples\n",
      "220/320 for 20000 train path examples\n",
      "240/320 for 20000 train path examples\n",
      "260/320 for 20000 train path examples\n",
      "280/320 for 20000 train path examples\n",
      "300/320 for 20000 train path examples\n",
      "320/320 for 20000 train path examples\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "320-element Array{Any,1}:\n",
       " 2x1 Array{Float64,2}:\n",
       " -8.58588\n",
       " 41.1483                                                                                                                                \n",
       " 2x18 Array{Float64,2}:\n",
       " -8.61094  -8.61045  -8.60924  -8.60837  …  -8.60393  -8.60395  -8.60395\n",
       " 41.1457   41.1461   41.1468   41.1477      41.1615   41.1616   41.1616 \n",
       " 2x7 Array{Float64,2}:\n",
       " -8.58016  -8.57873  -8.58034  -8.5828  -8.58244  -8.58103  -8.58287\n",
       " 41.1471   41.1495   41.1523   41.1551  41.1587   41.1628   41.1661          \n",
       " 2x3 Array{Float64,2}:\n",
       " -8.61555  -8.61535  -8.61453\n",
       " 41.1407   41.1409   41.1412                                                                                        \n",
       " 2x3 Array{Float64,2}:\n",
       " -8.61981  -8.61979  -8.61978\n",
       " 41.148    41.1481   41.1481                                                                                        \n",
       " 2x4 Array{Float64,2}:\n",
       " -8.62776  -8.62755  -8.62635  -8.6259\n",
       " 41.1754   41.1748   41.1723   41.1704                                                                     \n",
       " 2x10 Array{Float64,2}:\n",
       " -8.58568  -8.58625  -8.58621  -8.58715  …  -8.58409  -8.58407  -8.58406\n",
       " 41.1487   41.149    41.1483   41.1474      41.149    41.149    41.149  \n",
       " 2x17 Array{Float64,2}:\n",
       " -8.58242  -8.58241  -8.58172  -8.5826  …  -8.57537  -8.57489  -8.57427\n",
       " 41.1806   41.1806   41.1805   41.1809     41.1871   41.1877   41.1879   \n",
       " 2x29 Array{Float64,2}:\n",
       " -8.60653  -8.60674  -8.60735  -8.60762  …  -8.60395  -8.60472  -8.60547\n",
       " 41.1446   41.1447   41.1444   41.1439      41.125    41.1251   41.1257 \n",
       " 2x53 Array{Float64,2}:\n",
       " -8.58573  -8.58572  -8.58574  -8.58568  …  -8.59819  -8.59819  -8.5982\n",
       " 41.1486   41.1487   41.1488   41.1489      41.1896   41.1896   41.1896  \n",
       " 2x14 Array{Float64,2}:\n",
       " -8.59004  -8.58999  -8.58998  -8.58949  …  -8.58681  -8.58699  -8.58702\n",
       " 41.1633   41.1634   41.1634   41.164       41.1677   41.1684   41.1684 \n",
       " 2x11 Array{Float64,2}:\n",
       " -8.58563  -8.58606  -8.58809  -8.59091  …  -8.59361  -8.59361  -8.59362\n",
       " 41.1486   41.149    41.1494   41.1501      41.1492   41.1492   41.1492 \n",
       " 2x1 Array{Float64,2}:\n",
       " -8.58083\n",
       " 41.1593                                                                                                                                \n",
       " ⋮                                                                                                                                                                       \n",
       " 2x25 Array{Float64,2}:\n",
       " -8.61256  -8.61212  -8.61131  -8.61085  …  -8.58941  -8.58817  -8.58796\n",
       " 41.146    41.146    41.146    41.1459      41.1471   41.1472   41.1475 \n",
       " 2x20 Array{Float64,2}:\n",
       " -8.63789  -8.63794  -8.638  -8.63562  …  -8.6359  -8.63583  -8.63581\n",
       " 41.153    41.153    41.153  41.1524      41.1413  41.1415   41.1415       \n",
       " 2x19 Array{Float64,2}:\n",
       " -8.68937  -8.68917  -8.68798  -8.68721  …  -8.67911  -8.67911  -8.67839\n",
       " 41.1681   41.1675   41.1668   41.1654      41.1538   41.1538   41.1526 \n",
       " 2x91 Array{Float64,2}:\n",
       " -8.61211  -8.62125  -8.62244  -8.62245  …  -8.68418  -8.68418  -8.68416\n",
       " 41.148    41.1476   41.1477   41.1478      41.1729   41.1729   41.1729 \n",
       " 2x35 Array{Float64,2}:\n",
       " -8.60965  -8.60973  -8.61116  -8.61157  …  -8.58895  -8.58643  -8.58568\n",
       " 41.1604   41.1604   41.1606   41.1607      41.1494   41.1489   41.1487 \n",
       " 2x93 Array{Float64,2}:\n",
       " -8.65271  -8.65282  -8.65401  -8.65485  …  -8.54163  -8.54167  -8.54136\n",
       " 41.1778   41.1778   41.1772   41.1778      41.1295   41.1283   41.1274 \n",
       " 2x38 Array{Float64,2}:\n",
       " -8.5989  -8.59888  -8.5992  -8.60111  …  -8.60783  -8.61394  -8.61968\n",
       " 41.1484  41.1485   41.1485  41.1488      41.2005   41.2015   41.2035     \n",
       " 2x47 Array{Float64,2}:\n",
       " -8.57002  -8.56904  -8.56734  -8.5671  …  -8.58961  -8.58967  -8.58963\n",
       " 41.166    41.1663   41.1663   41.1663     41.1573   41.1573   41.1573   \n",
       " 2x26 Array{Float64,2}:\n",
       " -8.61384  -8.61383  -8.61434  -8.61579  …  -8.62986  -8.62988  -8.62987\n",
       " 41.1412   41.1412   41.1411   41.1406      41.1526   41.1526   41.1526 \n",
       " 2x9 Array{Float64,2}:\n",
       " -8.64776  -8.6477  -8.64769  -8.64726  …  -8.64551  -8.64351  -8.64278\n",
       " 41.1505   41.1506  41.1507   41.1526      41.1544   41.1544   41.1542    \n",
       " 2x17 Array{Float64,2}:\n",
       " -8.56992  -8.57025  -8.57024  -8.56903  …  -8.56301  -8.56295  -8.56293\n",
       " 41.1597   41.1596   41.159    41.1595      41.1674   41.1674   41.1674 \n",
       " 2x19 Array{Float64,2}:\n",
       " -8.56044  -8.56106  -8.56144  -8.56147  …  -8.57412  -8.57412  -8.5741\n",
       " 41.1902   41.1911   41.1902   41.1896      41.1924   41.1924   41.1924  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@everywhere using taxis\n",
    "#@everywhere using sequenceCompare\n",
    "#@everywhere reload(\"taxis\")\n",
    "#@everywhere reload(\"sequenceCompare\")\n",
    "#reload(\"taxis\")\n",
    "\n",
    "all_train_coords = taxi_df[:COORDS][1:20000]\n",
    "test_guess_paths = findClosestTrainingExampleForTestSet(all_train_coords, taxi_validation_df[:COORDS])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "taxi_validation_df[:GUESS_PATHS] = test_guess_paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#guess_times = [length(x)*15 for x in test_guess_paths]\n",
    "num_test_examples = length(test_guess_paths)\n",
    "\n",
    "guess_times = Array(Int64,num_test_examples)\n",
    "dest_coords = cell(num_test_examples)\n",
    "\n",
    "all_test_paths = taxi_validation_df[:COORDS]\n",
    "for k=1:num_test_examples\n",
    "    test_path = all_test_paths[k]\n",
    "    best_guess_path = test_guess_paths[k]\n",
    "    \n",
    "    test_path_time = length(test_path)*15\n",
    "    best_guess_time = length(best_guess_path)*15\n",
    "    \n",
    "    if length(test_path) > length(best_guess_path)\n",
    "        println(k, \":  guessing \", best_guess_time, \" but existing time is \", test_path_time)\n",
    "        best_guess_time = max(660, test_path_time)\n",
    "    end\n",
    "    guess_times[k] = best_guess_time\n",
    "end\n",
    "\n",
    "submission_validation = guess_times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#Generating Submission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#mean_time = mean(times_validation)\n",
    "#submission_validation = [max(x, mean_time) for x in times_validation]\n",
    "\n",
    "df_submission = DataFrame()\n",
    "df_submission[:TRIP_ID] = taxi_validation_df[:TRIP_ID]\n",
    "df_submission[:TRAVEL_TIME] = submission_validation\n",
    "writetable(\"third_submission_50k.csv\", df_submission)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 388,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "immutable Point2{T}\n",
    "  x::T\n",
    "  y::T\n",
    "end\n",
    "\n",
    "D = [Point2(1.,2.) => 42]\n",
    "haskey(D, Point2(1., 2.))  #False!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "ArgumentError(\"setindex!(::DataFrame, ...) only broadcasts scalars, not arrays\")\nwhile loading In[42], in expression starting on line 2",
     "output_type": "error",
     "traceback": [
      "ArgumentError(\"setindex!(::DataFrame, ...) only broadcasts scalars, not arrays\")\nwhile loading In[42], in expression starting on line 2",
      "",
      " in setindex! at /home/tony/.julia/v0.3/DataFrames/src/dataframe/dataframe.jl:356",
      " in DataFrame at /home/tony/.julia/v0.3/DataFrames/src/dataframe/dataframe.jl:104"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "320-element DataArray{Any,1}:\n",
       " 2x11 Array{Float64,2}:\n",
       " -8.58568  -8.58571  -8.58568  -8.58573  …  -8.587   -8.58658  -8.58488\n",
       " 41.1485   41.1486   41.1489   41.1489      41.1475  41.1472   41.1466    \n",
       " 2x40 Array{Float64,2}:\n",
       " -8.61088  -8.61086  -8.6109  -8.61044  …  -8.60293  -8.60255  -8.60189\n",
       " 41.1456   41.1456   41.1458  41.1462      41.1628   41.1631   41.1636    \n",
       " 2x40 Array{Float64,2}:\n",
       " -8.58574  -8.58573  -8.58572  -8.58629  …  -8.57695  -8.5759  -8.5749\n",
       " 41.1486   41.1488   41.149    41.149       41.1664   41.1672  41.1677     \n",
       " 2x8 Array{Float64,2}:\n",
       " -8.61396  -8.61412  -8.61509  -8.61528  …  -8.61524  -8.61505  -8.61464\n",
       " 41.1412   41.1411   41.1409   41.1408      41.1408   41.1408   41.141    \n",
       " 2x2 Array{Float64,2}:\n",
       " -8.6199  -8.61989\n",
       " 41.148   41.148                                                                                                                \n",
       " 2x137 Array{Float64,2}:\n",
       " -8.63061  -8.63061  -8.63074  -8.63151  …  -8.62639  -8.6264  -8.62641\n",
       " 41.1782   41.1782   41.1782   41.1781      41.172    41.172   41.172    \n",
       " 2x24 Array{Float64,2}:\n",
       " -8.58562  -8.58564  -8.58592  -8.58637  …  -8.58156  -8.58181  -8.58205\n",
       " 41.1489   41.1489   41.1489   41.1489      41.1533   41.1535   41.1538  \n",
       " 2x17 Array{Float64,2}:\n",
       " -8.58292  -8.582   -8.58108  -8.58011  …  -8.57703  -8.57753  -8.57877\n",
       " 41.1811   41.1818  41.183    41.184       41.1861   41.1861   41.1852    \n",
       " 2x43 Array{Float64,2}:\n",
       " -8.60653  -8.60667  -8.6068  -8.60679  …  -8.60548  -8.60549  -8.60549\n",
       " 41.1447   41.1447   41.1447  41.1447      41.1257   41.1258   41.1258    \n",
       " 2x79 Array{Float64,2}:\n",
       " -8.58566  -8.5857  -8.58573  -8.58574  …  -8.59117  -8.58826  -8.58631\n",
       " 41.1486   41.1486  41.1486   41.1486      41.1942   41.1974   41.1993    \n",
       " 2x63 Array{Float64,2}:\n",
       " -8.59123  -8.59123  -8.59122  -8.591   …  -8.58767  -8.5881  -8.58823\n",
       " 41.1627   41.1627   41.1627   41.1626     41.1687   41.1689  41.1689      \n",
       " 2x17 Array{Float64,2}:\n",
       " -8.58569  -8.58576  -8.58571  -8.58576  …  -8.59455  -8.59592  -8.59665\n",
       " 41.1486   41.1487   41.1489   41.149       41.1507   41.1499   41.1494  \n",
       " 2x5 Array{Float64,2}:\n",
       " -8.5801  -8.58023  -8.58152  -8.58252  -8.58433\n",
       " 41.1594  41.1594   41.1593   41.1589   41.1583                                                   \n",
       " ⋮                                                                                                                                                                        \n",
       " 2x21 Array{Float64,2}:\n",
       " -8.61072  -8.61049  -8.6094  -8.6085  …  -8.59074  -8.58956  -8.58816\n",
       " 41.1445   41.1437   41.1432  41.1431     41.1469   41.1471   41.1473      \n",
       " 2x25 Array{Float64,2}:\n",
       " -8.6406  -8.64005  -8.64022  -8.63974  …  -8.63605  -8.63605  -8.63605\n",
       " 41.1549  41.1547   41.1536   41.1533      41.1405   41.1405   41.1406    \n",
       " 2x19 Array{Float64,2}:\n",
       " -8.68929  -8.6893  -8.68873  -8.68765  …  -8.678   -8.67778  -8.67773\n",
       " 41.1682   41.1682  41.1674   41.1663      41.1521  41.1517   41.1515      \n",
       " 2x72 Array{Float64,2}:\n",
       " -8.60636  -8.60636  -8.60711  -8.6073  …  -8.68831  -8.6866  -8.68486\n",
       " 41.1445   41.1446   41.1451   41.1457     41.1728   41.1734  41.1734      \n",
       " 2x45 Array{Float64,2}:\n",
       " -8.61253  -8.61253  -8.61287  -8.61289  …  -8.58566  -8.58584  -8.58584\n",
       " 41.1595   41.1595   41.1595   41.1595      41.1489   41.149    41.149   \n",
       " 2x267 Array{Float64,2}:\n",
       " -8.66747  -8.66735  -8.66717  -8.66798  …  -8.53496  -8.53497  -8.53498\n",
       " 41.2381   41.2383   41.2384   41.2387      41.1433   41.1433   41.1433 \n",
       " 2x47 Array{Float64,2}:\n",
       " -8.60647  -8.60648  -8.60649  -8.60667  …  -8.5917  -8.59579  -8.60045\n",
       " 41.1447   41.1447   41.1447   41.1448      41.1973  41.1973   41.1988    \n",
       " 2x48 Array{Float64,2}:\n",
       " -8.5702  -8.57019  -8.56947  -8.56733  …  -8.59311  -8.59333  -8.59331\n",
       " 41.1595  41.159    41.1591   41.1606      41.1511   41.151    41.1511    \n",
       " 2x94 Array{Float64,2}:\n",
       " -8.61387  -8.61388  -8.61472  -8.61584  …  -8.62978  -8.62977  -8.62979\n",
       " 41.1412   41.1412   41.1411   41.1407      41.1526   41.1526   41.1527  \n",
       " 2x6 Array{Float64,2}:\n",
       " -8.6481  -8.64746  -8.64688  -8.64593  -8.64534  -8.6433\n",
       " 41.1525  41.1524   41.1531   41.1538   41.1544   41.1543                                \n",
       " 2x15 Array{Float64,2}:\n",
       " -8.5717  -8.57058  -8.569   -8.57006  …  -8.5658  -8.56669  -8.56921\n",
       " 41.1561  41.1559   41.1555  41.1561      41.1647  41.1667   41.1676        \n",
       " 2x52 Array{Float64,2}:\n",
       " -8.57456  -8.57225  -8.57049  -8.56883  …  -8.59046  -8.59078  -8.59234\n",
       " 41.1802   41.1799   41.1795   41.1806      41.1978   41.1952   41.1922  "
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "taxi_validation_df[:COORDS]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.3.7",
   "language": "julia",
   "name": "julia 0.3"
  },
  "language_info": {
   "name": "julia",
   "version": "0.3.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}