real_world_machine_learning.nw

% -*- ess-noweb-default-code-mode: python-mode; -*-
\documentclass[nobib]{tufte-handout}

\usepackage[T1]{fontenc}

\usepackage[utf8]{inputenc}

\usepackage[american]{babel}

\usepackage{blindtext}

\usepackage[style=alphabetic,backend=biber]{biblatex}

\usepackage{csquotes}

\addbibresource{real_world_machine_learning.bib}

\usepackage{noweb}

\usepackage{color}
% https://commons.wikimedia.org/wiki/File:Erlang_logo.svg
\definecolor{ErlangRed}{HTML}{A90533}

\usepackage{hyperref}
\hypersetup{
  bookmarks=true,
  pdffitwindow=true,
  pdfstartview={FitH},
  pdftitle={Real-World Machine Learning}
  pdfauthor={Eric Bailey <eric@ericb.me>},
  % pdfsubject={},
  pdfkeywords={machine learning, python},
  colorlinks=true,
  linkcolor=ErlangRed,
  urlcolor=ErlangRed
}

\usepackage{amsmath}
\usepackage{amssymb}

\usepackage[outputdir=src/tex]{minted}

% NOTE: Use Tufte instead of noweb page style.
% \pagestyle{noweb}
% NOTE: Use shift option for wide code.
% \noweboptions{smallcode,shortxref,webnumbering,english}
 \noweboptions{shift,smallcode,shortxref,webnumbering,english,noidentxref}

\title{
  Real-World Machine Learning
  \thanks{\url{https://www.manning.com/books/real-world-machine-learning}}
}

\author{Eric Bailey}

% \date{May 18, 2017}

% \newcommand{\stylehook}{\marginpar{\raggedright\sl style hook}}

\usepackage{todonotes}

\newmintinline[py]{python}{}

\usepackage{tikz}
\usetikzlibrary{cd}

% \newcommand{\fnhref}[2]{%
%   \href{#1}{#2}\footnote{\url{#1}}%
% }

\begin{document}

\maketitle

\begin{abstract}
  \todo[inline]{\blindtext}
\end{abstract}

% \tableofcontents
% \newpage

\section{Project Setup}

<<setup.py>>=
import `os
from distutils.core import `setup

<<Helper function to file contents to a string>>

setup(
    name = 'real_world_machine_learning',
    version = read('VERSION'),
    author = 'Eric Bailey',
    author_email = 'eric@ericb.me',
    description = 'Real-World Machine Learning',

    license = 'MIT',
    url = 'https://github.com/yurrriq/real_world_machine_learning',
    packages = ['real_world_machine_learning'],
)
@

\todo{Describe this briefly and mention the reasoning behind \texttt{VERSION}.}
<<Helper function to file contents to a string>>=
def `read(fname):
    return open(os.path.join(os.path.dirname(__file__), fname)).read()
@

\section{Chapter 2: Real-world data}

<<ch2.py>>=
<<Chapter 2 imports>>

<<Categorical feature example>>

<<Titanic example>>
@

<<Chapter 2 imports>>=
from numpy import (`array, `unique)
@

<<Categorical feature example>>=
<<Categorical data>>

<<Convert a categorical feature to a number>>
@

<<Categorical data>>=
`cat_data = array([
    'male', 'female', 'male', 'male',
    'female', 'male', 'female', 'female'
])
@

<<Convert a categorical feature to a number>>=
def `cat_to_num(data):
    categories = unique(data)
    features = []
    for cat in categories:
        binary = (data == cat)
        features.append(binary.astype("int"))
    return features
@

\subsection{Titanic Example (feature extraction)}

<<Titanic example>>=
<<Titanic data>>

<<Titanic cabin feature extraction>>
@

\todo[inline]{Import from code/data/titanic.csv}
<<Titanic data>>=
`cabin_data = array(["C65", "", "E36", "C54", "B57 B59 B63 B66"])
@

<<Titanic cabin feature extraction>>=
def `_cabin_char(cabins):
    try:
        return len(cabins), cabins[0][0]
    except IndexError:
        return 0, "X"

def `_cabin_num(cabins):
    try:
        return int(cabins[0][1:])
    except:
        return -1

def `cabin_features(data):
    features = []
    for cabin in data:
        cabins = cabin.split(" ")
        n_cabins, cabin_char = _cabin_char(cabins)
        cabin_num = _cabin_num(cabins)
        features.append([cabin_char, cabin_num, n_cabins])
    return features
@

\subsection{Idris Port}

<<Data.ML.Categorical>>=
-- --------------------------------------------------------- [ Categorical.idr ]

module Data.ML.Categorical

import public Data.ML.Util

%access export


catToNum : (Num n, Cast Bool n, Ord a) => List a -> List (List n)
catToNum xs = [ cast . (== cat) <$> xs | cat <- unique xs ]

-- --------------------------------------------------------------------- [ EOF ]
@ %def Data.ML.Categorical
@ %def catToNum

<<Data.ML.Util>>=
-- ---------------------------------------------------------------- [ Util.idr ]

module Data.ML.Util

%access public export


||| Convert a Bool to an Integer, as in C99's <stdbool.h>.
||| @ bool a Bool to convert
boolToInteger : (bool : Bool) -> Integer
boolToInteger False = 0
boolToInteger True  = 1


||| Cast Bools to Integers via `boolToInteger`.
implementation Cast Bool Integer where
  cast = boolToInteger


||| Simplified clone of `numpy.unique`.
|||
||| Return the sorted unique elements of a list.
|||
||| ```
||| unique = sort . nub
||| ```
unique : Ord a => List a -> List a
unique = sort . nub

-- --------------------------------------------------------------------- [ EOF ]
@ %def Data.ML.Util
@ %def boolToInteger
@ %def unique

<<Data.ML.Example>>=
-- ------------------------------------------------------------- [ Example.idr ]

module Data.ML.Example

import public Data.ML.Categorical

%access public export


-- --------------------------------------------- [ Categorical Feature Example ]

namespace Categorical

  exampleData : List String
  exampleData = [ "male",   "female", "male",   "male"
                , "female", "male",   "female", "female"
                ]


  ||| ```idris example
  ||| catToNum Categorical.exampleData
  ||| ```
  example : List (List Integer)
  example = catToNum Categorical.exampleData


-- --------------------------------------------------------- [ Titanic Example ]

namespace Titanic

  exampleData : List String
  exampleData = [ "C65", "", "E36", "C54", "B57 B59 B63 B66" ]


  -- TODO: record CabinFeature where

  ||| ```idris example
  ||| Titanic.example
  ||| ```
  example : List (Char, Integer, Nat)
  example = go . words <$> Titanic.exampleData
    where
      go : List String -> (Char, Integer, Nat)
      go []                                            = ('X', -1, 0)
      go (cabin :: cabins) with (strM cabin)
        go (""            :: cabins) | StrNil          = ('X', -1, 0)
        go (strCons c num :: cabins) | (StrCons c num) =
           ( c
           , cast num
           , S (length cabins)
           )

-- --------------------------------------------------------------------- [ EOF ]
@ %def Data.ML.Example
@ %def Categorical.exampleData
@ %def Categorical.example
@ %def Titanic.exampleData
@ %def Titanic.example

<<ipkg>>=
package real_world_ml

opts = "--total"

modules = Data.ML.Categorical
        , Data.ML.Example
        , Data.ML.Util
@

\section{Chunks}
\nowebchunks

\section{Index}
\nowebindex

\newpage

% \printbibliography

\end{document}