F# + Polyglot Notebooks で機械学習

**F#** というプログラミング言語があります．.NET Framework で動作する関数型言語で，読みやすく保守性の高いコードを素早く書くことができ，C# などの .NET 言語と簡単に相互運用することができる非常に優れた言語です．
そんな F# ですが，.NET のライブラリ群によって<INS>データサイエンス用途の言語</INS>としても活用することができます．
今回は Visual Studio Code の拡張機能である **Polyglot Notebooks** を使って，F# によるデータ分析・機械学習を行う手順を紹介し，その利点について解説します．

## F# について

F# は，OCaML をベースとして開発された，関数型ベースのマルチパラダイム言語です．
言語としては以下のような特徴を備えています：

- インデントを使った構文
- 静的型付け(型推論)
- 関数型言語(ML 系)
- オブジェクト指向
- 代数的データ型，パターンマッチング
- ジェネリクス，パラメトリック多相
- インライン関数
- .NET Framework との相互運用

F# の特徴は，<INS>さまざまなスタイルを状況に応じて使い分けることができる</INS>という点です．
同じ処理を書くのに，手続き型スタイル

```fsharp
let mutable sum = 0

for x in 1..100 do
    if x % 3 = 0 then
        sum <- sum + x * x

printfn "%d" sum
```

と関数型スタイル

```fsharp
let sum =
    [1..100]
    |> List.filter (fun x -> x % 3 = 0)
    |> List.map (fun x -> x * x)
    |> List.sum
    |> printfn "%d"
```

のどちらでも書くことができ，型定義でもオブジェクト指向的なクラス

```fsharp
type Foo(name: string) =
    member this.Name = name
    member this.Bar() = "bar"
```

とレコード

```fsharp
type Foo =
    { Name: string }
    member this.Bar() = "bar"
```

を使い分けることができます．
そのため F# は関数型言語の経験がなければ書けないということは全くなく，慣れたスタイル，または目的に適したスタイルで書いていくことができる言語となっています[^functional_required_eventually]．

[^functional_required_eventually]: とはいえ，後に述べるように，関数型言語のスタイルを使いこなすことで F# の強みを最大限に活かすことができます．

また，C# や VB といった .NET 系の言語と容易に相互運用することができるのも利点です．
これは <INS>C# や VB のライブラリを F# から呼べる</INS>というだけでなく， <INS>C# や VB で使うライブラリを F# で書くことができる</INS>ということも意味しています．
単一のソリューションに C# と F# を混合して使うということも普通に行うことができます[^interop_remark]．
C# と F# のどちらからでも同じように使えることを想定したライブラリも多く存在します．

[^interop_remark]: ただし，C# で使いやすい書き方と F# で使いやすい書き方というのは少し違うので，特に F# で書くときには相手の関数で使いやすいかどうかを考慮する必要はあります．

総じて，F# は**状況に応じてさまざまな選択肢をとることができる言語**であるといえ，非常に柔軟性が高く，実行性能も優れていて使用領域を選びません．
その記述力の高さと汎用性から，言語開発元の Microsoft を中心に<INS>データサイエンス分野での利用が推進</INS>されています．

F# にはコンパイラとインタプリタの2つの実行環境があり，今回はインタプリタ環境である **.NET Interactive** を使用します．

## Polyglot Notebooks について

**Polyglot Notebooks** は Visual Studio Code 上で，<INS>.NET 言語を使用した Jupyter Notebook 形式のノートブックを作成・実行するための拡張機能</INS>です．
C#, F#, PowerShell, JavaScript, SQL, KQL などの言語をサポートしており，これらの言語で書かれたコードセルを混在させ，同じノートブック内で相互に呼び出し，互いの変数を参照することもできます[^polyglot_remark]．

[^polyglot_remark]: 変数の参照については，明示的にこの変数をこっちの言語で使うという宣言が必要です．詳しくは拡張機能の説明を参照してください．

さらなる機能の情報は [Marketplace](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.dotnet-interactive-vscode) を参照してください．
今回は F# のみを使用します．

## Why F\#

手順に入る前に，~~F# でデータ分析とかなんか逆張りっぽくて不安という方のために~~ F# を使うことで得られる具体的な恩恵を述べておきます．

F# の言語としての特徴である「静的型付け」「関数型言語」といった特徴は，一見するとスクリプト言語としての利用には不向きに思えるかもしれませんが，ノートブックによる開発では F# の言語機能のそれぞれが生産性に直結する強みをもっています．

### 静的型付けであること

**静的型付け言語**であることのメリットは，しばしば規模の大きい開発における保守性という視点で認識されがちですが，対話実行環境やノートブックにおける開発でこそ現れる利点として，補完や型ヒントといった**エディタサポート**をより広範に享受でき，<INS>目的の記述を素早く実現することができる</INS>点が挙げられます．

Python のような**動的型付け言語**は，コードを記述している最中に変数や式の型を知ることができず，<INS>ある変数が現在どのようなメソッドを持っているのか，ある関数がどのような型の値を返すか</INS>など，コードを書くために必要な情報をその場で確認することができず，実行してみるか，都度ドキュメントなどを参照するなどの手間が発生します．

```python
model = Foo.Bar().model(param1, param2)
# ここで model が any になってしまった！
# 以下のどれが正解？
model.fit(x, y)
model.train(x, y)
model.learn(x, y)
```

また変数名・メソッド名のタイポなども動的型付け言語を使用する上で気を付けなければならない点となります．

一方で静的型付け言語は，コード上の変数にホバーすることで型とそのドキュメントを確認でき，`.` と入力すればメンバの補完を得られたりと，<INS>エディタから離れることなく必要な情報を得ることができます</INS>．
また，<INS>タイポや型の誤りは即座に検知される</INS>ため，しょうもないミスをその場で発見・修正することができます．

```fsharp
let model = Foo.Bar().Model(param1, param2)
// この時点で model の型は確定している．
// ので，エディタは model がどんなメンバを持てるか既に知っていて，
// いつでもプログラマに教えることができる．
let learned = model. // この時点でエディタはメンバ候補を表示する．
let learned = model.F // Fit が候補に出てこない，じゃあ Fit じゃないか...
let learned = model.T // Train が候補に出てきたので，tab を押して確定．
let learned = model.Train(x, y) // ホバーするとドキュメントが表示され，使い方を確認できる．
```

小規模なコードであるからこそ，記述しながら仕様や挙動を把握できるというインタラクタビリティの高さは生産性を高める重要な要素になりえます．

一方，明示的なダウンキャストなど，静的型付け言語特有の煩わしさがあることも事実ですし，言語，フレームワークおよびライブラリに十分に精通している人にとっては，動的型付け言語であっても阻害されることは少なくなると考えられます．
動的型付け言語でのスクリプト開発の IDE・エディタサポートや部分的に型付けを行うツールも充実してきているため，上手く活用すれば動的型付けのデメリットをカバーして開発することも可能でしょう．

### 関数型言語であること

関数型言語は制御構文や変数の更新などを行わずに処理を複合することができるため，手続き型言語と比べて<INS>コードブロックがコンパクトになりやすい</INS>というメリットがあります．
また，「**どのように**計算するか」ではなく「**何を**計算するか」を記述するコードを書けるため，特にノートブックのようなドキュメントを兼ねたコードにおいては，<INS>コメントがなくてもコードの意図を明確にすることができる</INS>点も優れています．
<INS>ワンライナーのコードを書きやすい</INS>という点で REPL での実行にも向いています．

```fsharp
[1..100]                            // 1 から 100 までの整数から
|> List.filter (fun x -> x % 3 = 0) // 3 の倍数を取り出し，
|> List.map (fun x -> x * x)        // 2 乗して，
|> List.sum                         // 合計を求め，
|> printfn "%d"                     // 出力する．

// 以上のコードのコメントがなくても，処理の順番や意図，
// 「何を求めるのか」を明確に読み取れるようになっている．
```

一方，関数型スタイルの記述は下手に短さを追求することで却って読みづらくもなりがちなので，あくまで読みやすさが重要だということを意識しながら書く必要があります．

また，アルゴリズムなどの複雑な手続きの記述は関数型言語の苦手とするところです．
F# では必要に応じて手続き型スタイルを利用したり，場合によってはピンポイントで C# を使うなどの工夫も有効かもしれません[^recommend_monad]．

[^recommend_monad]: モナドを使ってもよいでしょう．F# は Haskell の do 記法に相当するコンピューテーション式という構文を持っていて，関数型言語の枠組みの中でモナディックな文脈をもった手続き型処理を記述することができます．

### 不変性

上記と関連しますが，関数型言語ではデータを**更新**するのではなく，<INS>新しいデータを返して元のデータをそのまま**保持**する</INS>というスタイルがよく用いられます．

ことノートブックの環境では，**値が勝手に変更されない = データが勝手に消えない**というのが思わぬ副作用の影響を防げるメリットになっています．

```python
# このコードセルをもう一度実行してしまうと，model が上書きされてしまう．
model.learn(x, y)
```

```fsharp
// 値を変更するのではなく変更後の値を返却し，元の値は変更しない．
// このコードセルを実行しても model のデータは変化せず，失われない．
let learned = model.Learn(x, y)
```

### 相互運用性

以上に述べたような特徴は，F# でのみ用いられることを想定したライブラリでの話であり，C# で記述されたライブラリでは必ずしも関数型スタイルで使いやすい設計がなされているとは限りません．
しかし，そうであっても，F# は<INS>手続き型スタイルやオブジェクト指向設計も自然にサポートしており</INS>，ライブラリの設計にあわせた使い方ができます．

また，F# での利便性を考慮して設計されたライブラリも存在するため，そういったライブラリならば C# からでも F# からでも同様に便利に使うことができます．

## 準備

以降では F# による機械学習の手順を紹介し，実際に上記のメリットが働いていることを確認していきます．

### 分析データ

今回は，kaggle の **"Titanic: Machine Learning from Disaster"** コンペティションのデータを用いた生存予測(2値分類)を行います．

[コンペティションページ](https://www.kaggle.com/c/titanic)からトレーニングデータ(train.csv)とテストデータ(test.csv)をダウンロードします．

### 環境の準備

Visual Studio Code, .NET 7 SDK がインストールされている必要があります．

Visual Studio Code に Polyglot Notebooks 拡張機能をインストールします．

<!-- 
:::note
私の環境では最新バージョンの Polyglot Notebooks では F# のシンタクスハイライトが効かない不具合がありました．
バージョンを 10.3553070 以前に落としたところハイライトが効くようになったため，同様の問題が生じた場合はバージョンを落としてみてください．
::: -->

### プロジェクトの作成

以下で作成するプロジェクトのソースコードは以下のリポジトリにあります．

<https://github.com/arakur/FSharpMLExample>

適当なフォルダで Visual Studio Code を起動します．
F# script の開発では `.fsproj` のようなプロジェクトファイルを作成する必要はありません．
今回は以下のようなファイル構成にします．

```text
./
├── data/
│   ├── titanic/
│   │   ├── test.csv
│   │   ├── train.csv
│
├── src/
│
├── submission/
│   ├── titanic/
```

ここで，`train.csv`, `test.csv` は先ほどダウンロードしたデータです．
`src` フォルダにスクリプトを配置し，`submission/titanic` フォルダに kaggle に提出するためのファイルを出力します．

`src/` フォルダ内に `main.ipynb` ファイルを作成します．
`main.ipynb` をエディタで開いたら，右上の `Select Kernel` をクリックし `.NET Interactive` を選択します．
その後，コードセルの右下の言語名(たとえば `csharp - C# Script Code`)が表示されている部分をクリックし，`fsharp - F# Script` を選択します．

以下の状態になっていれば OK です．

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3554117/96bb06b0-9f1a-a987-3c31-13f3468b3b21.png)

ノートブック自体の使い方は通常の Jupyter Notebook と変わりません．

## 分析

### データの読み込み

#### F# のデータフレームライブラリ

Python の Pandas に相当する F# 向けのデータフレームライブラリとして Deedle があります．
これは C# と F# のどちらからでもネイティブに使うことができるよう設計されたライブラリで，F# から使う場合には関数型スタイルに適したインターフェースで使用することができます．

ノートブックの先頭のコードセルに以下のように記述・実行して，インタプリタ環境に Deedle を読み込みます．

```fsharp
#r "nuget: Deedle"
```

F# script で nuget の外部ライブラリを読み込む際には `#r` キーワードを用います．

:::note
`#r` で nuget のパッケージソースが見つからず読み込めない場合には，`#r` の前に

```fsharp
#i "nuget: https://api.nuget.org/v3/index.json"
```

と記述すれば読み込めるようになります．
:::

データフレームの型 `Deedle.Frame` の `ReadCsv` メンバを用いてトレーニングデータとテストデータを読み込みます．

```fsharp
open Deedle

let train =
    Frame.ReadCsv(__SOURCE_DIRECTORY__ + "/../data/titanic/train.csv") // トレーニングデータを読み込み，
    |> Frame.indexRowsInt "PassengerId" // PassengerId を行名に設定する．

let test =
    Frame.ReadCsv(__SOURCE_DIRECTORY__ + "/../data/titanic/test.csv") // テストデータを読み込み，
    |> Frame.indexRowsInt "PassengerId" // PassengerId を行名に設定する．
```

(`__SOURCE_DIRECTORY__` は現在のスクリプトファイルのディレクトリを表す変数)

このセルの `train` をホバーすると，`train` の型 `Frame<int, string>` を確認することができます．
`Frame<int, string>` は，行名が `int` 型，列名が `string` 型であるようなデータフレームの型を表します．
実際に値を表示させてみましょう．

```fsharp
train.Print()
```

```text
       Survived Pclass Name                                                Sex    Age       SibSp Parch Ticket           Fare    Cabin Embarked 
1   -> False    3      Braund, Mr. Owen Harris                             male   22        1     0     A/5 21171        7.25          S        
2   -> True     1      Cumings, Mrs. John Bradley (Florence Briggs Thayer) female 38        1     0     PC 17599         71.2833 C85   C        
3   -> True     3      Heikkinen, Miss. Laina                              female 26        0     0     STON/O2. 3101282 7.925         S        
4   -> True     1      Futrelle, Mrs. Jacques Heath (Lily May Peel)        female 35        1     0     113803           53.1    C123  S        
5   -> False    3      Allen, Mr. William Henry                            male   35        0     0     373450           8.05          S        
6   -> False    3      Moran, Mr. James                                    male   <missing> 0     0     330877           8.4583        Q        
7   -> False    1      McCarthy, Mr. Timothy J                             male   54        0     0     17463            51.8625 E46   S        
8   -> False    3      Palsson, Master. Gosta Leonard                      male   2         3     1     349909           21.075        S        
9   -> True     3      Johnson, Mrs. Oscar W (Elisabeth Vilhelmina Berg)   female 27        0     2     347742           11.1333       S        
10  -> True     2      Nasser, Mrs. Nicholas (Adele Achem)                 female 14        1     0     237736           30.0708       C        
11  -> True     3      Sandstrom, Miss. Marguerite Rut                     female 4         1     1     PP 9549          16.7    G6    S        
12  -> True     1      Bonnell, Miss. Elizabeth                            female 58        0     0     113783           26.55   C103  S        
13  -> False    3      Saundercock, Mr. William Henry                      male   20        0     0     A/5. 2151        8.05          S        
14  -> False    3      Andersson, Mr. Anders Johan                         male   39        1     5     347082           31.275        S        
15  -> False    3      Vestrom, Miss. Hulda Amanda Adolfina                female 14        0     0     350406           7.8542        S        
:      ...      ...    ...                                                 ...    ...       ...   ...   ...              ...     ...   ...      
877 -> False    3      Gustafsson, Mr. Alfred Ossian                       male   20        0     0     7534             9.8458        S        
878 -> False    3      Petroff, Mr. Nedelio                                male   19        0     0     349212           7.8958        S        
879 -> False    3      Laleff, Mr. Kristo                                  male   <missing> 0     0     349217           7.8958        S        
880 -> True     1      Potter, Mrs. Thomas Jr (Lily Alexenia Wilson)       female 56        0     1     11767            83.1583 C50   C        
881 -> True     2      Shelley, Mrs. William (Imanita Parrish Hall)        female 25        0     1     230433           26            S        
882 -> False    3      Markun, Mr. Johann                                  male   33        0     0     349257           7.8958        S        
883 -> False    3      Dahlberg, Miss. Gerda Ulrika                        female 22        0     0     7552             10.5167       S        
884 -> False    2      Banfield, Mr. Frederick James                       male   28        0     0     C.A./SOTON 34068 10.5          S        
885 -> False    3      Sutehall, Mr. Henry Jr                              male   25        0     0     SOTON/OQ 392076  7.05          S        
886 -> False    3      Rice, Mrs. William (Margaret Norton)                female 39        0     5     382652           29.125        Q        
887 -> False    2      Montvila, Rev. Juozas                               male   27        0     0     211536           13            S        
888 -> True     1      Graham, Miss. Margaret Edith                        female 19        0     0     112053           30      B42   S        
889 -> False    3      Johnston, Miss. Catherine Helen "Carrie"            female <missing> 1     2     W./C. 6607       23.45         S        
890 -> True     1      Behr, Mr. Karl Howell                               male   26        0     0     111369           30      C148  C        
891 -> False    3      Dooley, Mr. Patrick                                 male   32        0     0     370376           7.75          Q        
```

#### 行，列の取得・追加・削除など

データフレームの行または列を取得するには以下のように記述します：

```fsharp
// 取得方法1. ObjectSeries として取得する．
// Columns メンバを使用．
// ObjectSeries の各要素は obj 型(Python の any 相当)．
// 値を取り出した後にダウンキャスト :?> で型を指定する．
let survived: ObjectSeries<int> = train.Columns.["Survived"]
let survived': ObjectSeries<int> = train.Columns?Survived
let survived1: obj = survived.Get 1
let survived1': bool = survived1 :?> bool

// 取得方法2. Series として取得する．
// GetColumn メンバを使用．
// 要素の型が全て同じと分かっている場合に，あらかじめ型を指定して列を取得できる．
// この場合 Series<int, float> という型の指定は必須．
let age: Series<int, float> = train.GetColumn "Age"
let age': Series<int, float> = train |> Frame.getCol "Age"
let age1: float = age.Get 1
```

```fsharp
// 行を取得する場合も同じ．
let first: ObjectSeries<string> = train.Rows.[1]
let first': Series<string, obj> = train.GetRow 1
```

`train.GetColumn` というメンバ関数と `Frame.getCol` という静的メンバ関数は同じ機能をもちます．
基本的にメンバ関数の方は C# 向けの設計で，静的メンバ関数の方は F# 向けの設計になっています．

列の追加や削除も，それぞれ `train.AddColumn` と `Frame.addCol`，`train.DropColumn` と `Frame.dropCol` というペアが用意されています．
ただし，`train.AddColumn` や `train.DropColumn` はデータフレームを変更する方式，`Frame.addCol` や `Frame.dropCol` は新しいデータフレームを返す方式であることに注意してください．

```fsharp
// 新しいデータフレームを返す方式．
let isFemale =
    train
    |> Frame.getCol "Sex"
    |> Series.mapValues (fun v -> v = "Female")

let isFemaleAdded = train |> Frame.addCol "IsFemale" isFemale

let cabinDropped = isFemaleAdded |> Frame.dropCol "Cabin"

// まとめて書くとこうなる．
train
|> Frame.addCol "IsFemale" (
        train
        |> Frame.getCol "Sex"
        |> Series.mapValues (fun v -> v = "Female")
    )
|> Frame.dropCol "Cabin"
```

```fsharp
// train を直接更新する方式．
// 以下のコードは train を変更するので注意！
let isFemale = train.GetColumn "Sex" |> Series.mapValues (fun v -> v = "Female")
train.AddColumn("IsFemale", isFemale)

let cabinDropped = train
train.DropColumn "Cabin"
```

### 可視化

データの可視化には [Plotly.NET](https://plotly.net/) ライブラリを用います．
`Plotly.NET.Interactive` を読み込むことで，ノートブック上にグラフを表示することができます．

```fsharp
#r "nuget: Plotly.NET.Interactive"
```

```fsharp
open Plotly.NET

let x: float seq = train.GetColumn "Age" |> Series.values

Chart.Histogram(X = x)
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3554117/8efec074-37bb-323e-f850-b5524bf5278c.png)

### データクレンジング・データの前処理

機械学習の前処理として，データの欠損値の補完とカテゴリカルデータの数値化を行います．
今回は簡単のため，`Name` などの前処理の難しい列は削除し，また特徴量エンジニアリングは行いません．

:::note
データ上は `Embarked` や `Cabin` なども欠損値を含みますが，文字列型の列については<INS>欠損値は空文字列として取り込まれている</INS>ので，これらは欠損値として扱わないことにします．
:::

まずは欠損値がどの列にどれくらいあるのかを確認するために関数を定義します．

```fsharp
let printCleansingInfo (frame: Frame<'R, 'C>) =
    let missingValueCounts =
        frame.Columns
        |> Series.observations
        |> Seq.map (
            fun (key, col) ->
                let length = col.ValuesAll |> Seq.length // 欠損値も含めた列の長さ．
                let valueCount = col.ValueCount // 欠損値を除いた列の長さ．
                let missingCount = length - valueCount // 欠損値の数．
                key, missingCount
        )
        |> Seq.filter (fun (key, missingCount) -> missingCount > 0)
    
    missingValueCounts
    |> Seq.iter (fun (key, count) -> printfn "Column %A has %d missing values" key count)

    if missingValueCounts |> Seq.isEmpty then
        printfn "No missing values"
```

ここで，`ObjectSeries<int>` の `Values` メンバは**欠損値を除いた**要素の列を返すものです．
**欠損値を含めた**全要素を取得するには `ValuesAll` メンバを用います．

```fsharp
train.Columns?Age.Values // : float seq
train.Columns?Age.ValuesAll // : float option seq; 欠損値は None
```

これを用いて，トレーニングデータとテストデータの欠損値の数を確認します．

```fsharp
printfn "Train data:"
printCleansingInfo train

printfn "Test data:"
printCleansingInfo test
```

```text
Train data:
Column "Age" has 177 missing values
Test data:
Column "Age" has 86 missing values
Column "Fare" has 1 missing values
```

`Age` と `Fare` に欠損値があることが分かりました．

欠損値の補完とカテゴリカルデータの変換を行う関数 `preprocess` を定義します．
次のコードセルを作成しましょう：

```fsharp
let preprocess (frame: Frame<int, string>) =
    frame

let train' = train |> preprocess
let test' = test |> preprocess

train'.Print()
test'.Print()
```

いま，`preprocess` は `frame` を受け取りそのまま返す関数です．
ここから `preprocess` の中身を追記して実行を繰り返し，`train'` と `test'` が所望の形式になるようにしていきます．

まず，`Name`, `Ticket`, `Cabin` を削除します．

```diff_f_sharp
    let preprocess (frame: Frame<int, string>) =
        frame
+       // Name, Ticket, Cabin は削除する．
+       |> Frame.dropCol "Name"
+       |> Frame.dropCol "Ticket"
+       |> Frame.dropCol "Cabin"
```

次に `Sex` を変換します．
`Sex` は `"male"` か `"female"` の値をとるカテゴリカルデータですので，`"male"` ならば `0`，`female` ならば `1` に置き換えましょう．

```diff_f_sharp
    let preprocess (frame: Frame<int, string>) =
        frame
        // Name, Ticket, Cabin は削除する．
        |> Frame.dropCol "Name"
        |> Frame.dropCol "Ticket"
        |> Frame.dropCol "Cabin"
+       // Sex は `male` ならば `0.0`，`female` ならば `1.0` に置き換える．
+       |> Frame.replaceCol "Sex" (frame.GetColumn "Sex" |> Series.mapValues (fun s -> if s = "male" then 0 else 1))
```

続いて，`Embarked` を変換します．
`Embarked` は `"S"`, `"C"`, `"Q"` の3通りの値と，空文字列 `""` をとりうるカテゴリカルデータです．
これは one-hot エンコーディングで数値に変換しましょう．

```diff_f_sharp
    let preprocess (frame: Frame<int, string>) =
        frame
        // Name, Ticket, Cabin は削除する．
        |> Frame.dropCol "Name"
        |> Frame.dropCol "Ticket"
        |> Frame.dropCol "Cabin"
        // Sex は `male` ならば `0.0`，`female` ならば `1.0` に置き換える．
        |> Frame.replaceCol "Sex" (frame.GetColumn "Sex" |> Series.mapValues (fun s -> if s = "male" then 0 else 1))
+       // Embarked は one-hot エンコーディングを行う．
+       |> Frame.dropCol "Embarked"
+       |> Frame.addCol "Embarked_S" (frame.GetColumn "Embarked" |> Series.mapValues (fun s -> if s = "S" then 1.0 else 0.0))
+       |> Frame.addCol "Embarked_Q" (frame.GetColumn "Embarked" |> Series.mapValues (fun s -> if s = "Q" then 1.0 else 0.0))
+       |> Frame.addCol "Embarked_C" (frame.GetColumn "Embarked" |> Series.mapValues (fun s -> if s = "C" then 1.0 else 0.0))
```

この処理は煩雑なので，`oneHotEncode` 関数を定義して分離します．

```diff_f_sharp
+   // one-hot エンコーディング．
+   let oneHotEncode (colName: string) (categories: string list) (frame: Frame<'R, string>) =
+       // 元の列を取得する．
+       let originalCol = frame.GetColumn colName
+
+       // カテゴリを表す列を追加する．
+       let addCategoryCol (category: string) (frame: Frame<'R, string>) =
+           let col =
+               originalCol
+               |> Series.mapValues (fun v -> if v = category then 1.0 else 0.0)
+           
+           frame
+           |> Frame.addCol (colName + "_" + category) col
+
+       frame
+       // 元の列を削除し，
+       |> Frame.dropCol colName
+       // categories の各要素 に対して，addCategoryCol を適用する．
+       |> Seq.foldBack addCategoryCol categories
+
    let preprocess (frame: Frame<int, string>) =
        frame
        // Name, Ticket, Cabin は削除する．
        |> Frame.dropCol "Name"
        |> Frame.dropCol "Ticket"
        |> Frame.dropCol "Cabin"
        // Sex は `male` ならば `0.0`，`female` ならば `1.0` に置き換える．
        |> Frame.replaceCol "Sex" (frame.GetColumn "Sex" |> Series.mapValues (fun s -> if s = "male" then 0 else 1))
        // Embarked は one-hot エンコーディングを行う．
-       |> Frame.dropCol "Embarked"
-       |> Frame.addCol "Embarked_S" (frame.GetColumn "Embarked" |> Series.mapValues (fun s -> if s = "S" then 1.0 else 0.0))
-       |> Frame.addCol "Embarked_Q" (frame.GetColumn "Embarked" |> Series.mapValues (fun s -> if s = "Q" then 1.0 else 0.0))
-       |> Frame.addCol "Embarked_C" (frame.GetColumn "Embarked" |> Series.mapValues (fun s -> if s = "C" then 1.0 else 0.0))
+       |> oneHotEncode "Embarked" [ "S"; "Q"; "C" ]
```

そして，`Age` と `Fare` の欠損値を補完します．
`Fare` は欠損値が `test` 内に一つだけですので，単に平均値で補完してしまいます．

```diff_f_sharp
    let preprocess (frame: Frame<int, string>) =
        frame
        // Name, Ticket, Cabin は削除する．
        |> Frame.dropCol "Name"
        |> Frame.dropCol "Ticket"
        |> Frame.dropCol "Cabin"
        // Sex は `male` ならば `0.0`，`female` ならば `1.0` に置き換える．
        |> Frame.replaceCol "Sex" (frame.GetColumn "Sex" |> Series.mapValues (fun s -> if s = "male" then 0 else 1))
        // Embarked は one-hot エンコーディングを行う．
        |> oneHotEncode "Embarked" [ "S"; "Q"; "C" ]
+       // Fare は欠損値を平均値で置き換える．
+       |> Frame.replaceCol "Fare" (
+           frame.GetColumn "Fare"
+           |> Series.fillMissingWith (frame?Fare |> Stats.mean)
+       )
```

`Age` は欠損値を平均値で置き換えた上で，欠損値にラベルを付けて対処します．

```diff_f_sharp
    let preprocess (frame: Frame<int, string>) =
        frame
        // Name, Ticket, Cabin は削除する．
        |> Frame.dropCol "Name"
        |> Frame.dropCol "Ticket"
        |> Frame.dropCol "Cabin"
        // Sex は `male` ならば `0.0`，`female` ならば `1.0` に置き換える．
        |> Frame.replaceCol "Sex" (frame.GetColumn "Sex" |> Series.mapValues (fun s -> if s = "male" then 0 else 1))
        // Embarked は one-hot エンコーディングを行う．
        |> oneHotEncode "Embarked" [ "S"; "Q"; "C" ]
        // Fare は欠損値を平均値で置き換える．
        |> Frame.replaceCol "Fare" (
            frame.GetColumn "Fare"
            |> Series.fillMissingWith (frame?Fare |> Stats.mean)
        )
+       // Age は欠損値を平均値で置き換え，そのうえで欠損値であるか示す列を追加する．
+       |> Frame.replaceCol "Age" (
+           frame.GetColumn "Age"
+           |> Series.fillMissingWith (frame?Age |> Stats.mean)
+       )
+       |> Frame.addCol "Age_missing" (
+           frame.GetColumn "Age"
+           |> Series.mapValues (fun _ -> 0)
+           |> Series.fillMissingWith 1
+       )
```

最後に，`train'` の `Survived` 列を数値に変換して，前処理は完了です．

```diff_f_sharp
-   let train' = train |> preprocess
+   let train' =
+       train
+       |> Frame.replaceCol "Survived" (train?Survived |> Series.mapValues float)
+       |> preprocess
```

最終的な前処理のコードは以下の通りです：

```fsharp
// one-hot エンコーディング．
let oneHotEncode (colName: string) (categories: string list) (frame: Frame<'R, string>) =
    // 元の列を取得する．
    let originalCol = frame.GetColumn colName

    // カテゴリを表す列を追加する．
    let addCategoryCol (category: string) (frame: Frame<'R, string>) =
        let col =
            originalCol
            |> Series.mapValues (fun v -> if v = category then 1.0 else 0.0)
        
        frame
        |> Frame.addCol (colName + "_" + category) col

    frame
    // 元の列を削除し，
    |> Frame.dropCol colName
    // categories の各要素 に対して，addCategoryCol を適用する．
    |> Seq.foldBack addCategoryCol categories

let preprocess (frame: Frame<int, string>) =
    frame
    // Name, Ticket, Cabin は削除する．
    |> Frame.dropCol "Name"
    |> Frame.dropCol "Ticket"
    |> Frame.dropCol "Cabin"
    // Sex は `male` ならば `0.0`，`female` ならば `1.0` に置き換える．
    |> Frame.replaceCol "Sex" (frame.GetColumn "Sex" |> Series.mapValues (fun s -> if s = "male" then 0 else 1))
    // Embarked は one-hot エンコーディングを行う．
    |> oneHotEncode "Embarked" [ "S"; "Q"; "C" ]
    // Fare は欠損値を平均値で置き換える．
    |> Frame.replaceCol "Fare" (
        frame.GetColumn "Fare"
        |> Series.fillMissingWith (frame?Fare |> Stats.mean)
    )
    // Age は欠損値を平均値で置き換え，そのうえで欠損値であるか示す列を追加する．
    |> Frame.replaceCol "Age" (
        frame.GetColumn "Age"
        |> Series.fillMissingWith (frame?Age |> Stats.mean)
    )
    |> Frame.addCol "Age_missing" (
        frame.GetColumn "Age"
        |> Series.mapValues (fun _ -> 0)
        |> Series.fillMissingWith 1
    )

let train' =
    train
    |> Frame.replaceCol "Survived" (train?Survived |> Series.mapValues float)
    |> preprocess
let test' = test |> preprocess

train'.Print()
test'.Print()
```

```text
       Pclass SibSp Parch Survived Sex Embarked_C Embarked_Q Embarked_S Fare    Age               Age_missing 
1   -> 3      1     0     0        0   0          0          1          7.25    22                0           
2   -> 1      1     0     1        1   1          0          0          71.2833 38                0           
3   -> 3      0     0     1        1   0          0          1          7.925   26                0           
4   -> 1      1     0     1        1   0          0          1          53.1    35                0           
5   -> 3      0     0     0        0   0          0          1          8.05    35                0           
6   -> 3      0     0     0        0   0          1          0          8.4583  29.69911764705882 1           
7   -> 1      0     0     0        0   0          0          1          51.8625 54                0           
8   -> 3      3     1     0        0   0          0          1          21.075  2                 0           
9   -> 3      0     2     1        1   0          0          1          11.1333 27                0           
10  -> 2      1     0     1        1   1          0          0          30.0708 14                0           
11  -> 3      1     1     1        1   0          0          1          16.7    4                 0           
12  -> 1      0     0     1        1   0          0          1          26.55   58                0           
13  -> 3      0     0     0        0   0          0          1          8.05    20                0           
14  -> 3      1     5     0        0   0          0          1          31.275  39                0           
15  -> 3      0     0     0        1   0          0          1          7.8542  14                0           
:      ...    ...   ...   ...      ... ...        ...        ...        ...     ...               ...         
877 -> 3      0     0     0        0   0          0          1          9.8458  20                0           
878 -> 3      0     0     0        0   0          0          1          7.8958  19                0           
879 -> 3      0     0     0        0   0          0          1          7.8958  29.69911764705882 1           
880 -> 1      0     1     1        1   1          0          0          83.1583 56                0           
881 -> 2      0     1     1        1   0          0          1          26      25                0           
882 -> 3      0     0     0        0   0          0          1          7.8958  33                0           
883 -> 3      0     0     0        1   0          0          1          10.5167 22                0           
884 -> 2      0     0     0        0   0          0          1          10.5    28                0           
885 -> 3      0     0     0        0   0          0          1          7.05    25                0           
886 -> 3      0     5     0        1   0          1          0          29.125  39                0           
887 -> 2      0     0     0        0   0          0          1          13      27                0           
888 -> 1      0     0     1        1   0          0          1          30      19                0           
889 -> 3      1     2     0        1   0          0          1          23.45   29.69911764705882 1           
890 -> 1      0     0     1        0   1          0          0          30      26                0           
891 -> 3      0     0     0        0   0          1          0          7.75    32                0           

        Pclass SibSp Parch Sex Embarked_C Embarked_Q Embarked_S Fare    Age                Age_missing 
892  -> 3      0     0     0   0          1          0          7.8292  34.5               0           
893  -> 3      1     0     1   0          0          1          7       47                 0           
894  -> 2      0     0     0   0          1          0          9.6875  62                 0           
895  -> 3      0     0     0   0          0          1          8.6625  27                 0           
896  -> 3      1     1     1   0          0          1          12.2875 22                 0           
897  -> 3      0     0     0   0          0          1          9.225   14                 0           
898  -> 3      0     0     1   0          1          0          7.6292  30                 0           
899  -> 2      1     1     0   0          0          1          29      26                 0           
900  -> 3      0     0     1   1          0          0          7.2292  18                 0           
901  -> 3      2     0     0   0          0          1          24.15   21                 0           
902  -> 3      0     0     0   0          0          1          7.8958  30.272590361445783 1           
903  -> 1      0     0     0   0          0          1          26      46                 0           
904  -> 1      1     0     1   0          0          1          82.2667 23                 0           
905  -> 2      1     0     0   0          0          1          26      63                 0           
906  -> 1      1     0     1   0          0          1          61.175  47                 0           
:       ...    ...   ...   ... ...        ...        ...        ...     ...                ...         
1295 -> 1      0     0     0   0          0          1          47.1    17                 0           
1296 -> 1      1     0     0   1          0          0          27.7208 43                 0           
1297 -> 2      0     0     0   1          0          0          13.8625 20                 0           
1298 -> 2      1     0     0   0          0          1          10.5    23                 0           
1299 -> 1      1     1     0   1          0          0          211.5   50                 0           
1300 -> 3      0     0     1   0          1          0          7.7208  30.272590361445783 1           
1301 -> 3      1     1     1   0          0          1          13.775  3                  0           
1302 -> 3      0     0     1   0          1          0          7.75    30.272590361445783 1           
1303 -> 1      1     0     1   0          1          0          90      37                 0           
1304 -> 3      0     0     1   0          0          1          7.775   28                 0           
1305 -> 3      0     0     0   0          0          1          8.05    30.272590361445783 1           
1306 -> 1      0     0     1   1          0          0          108.9   39                 0           
1307 -> 3      0     0     0   0          0          1          7.25    38.5               0           
1308 -> 3      0     0     0   0          0          1          8.05    30.272590361445783 1           
1309 -> 3      1     1     0   1          0          0          22.3583 30.272590361445783 1           

```

改めて欠損値の確認もしておきます．

```fsharp
printfn "Train data:"
printCleansingInfo train'
printfn "Test data:"
printCleansingInfo test'
```

```text
Train data:
No missing values
Test data:
No missing values
```

欠損値を全て補完できました．

### データの学習

続いてデータの学習を行います．
今回は以下の 2 つのモデルを使います：

- 多変量ロジスティック回帰，
- ランダムフォレスト．

.NET で利用できる機械学習フレームワークにはいくつか選択肢がありますが，今回は [Accord.NET](http://accord-framework.net/) を使います．
こちらは C# で書かれたライブラリです．

```fsharp
#r "nuget: Accord.MachineLearning"
#r "nuget: Accord.Statistics"
```

まずデータフレームから予測変数と目的変数の配列を取り出します．

```fsharp
let inputs: float array array =
    train'
    |> Frame.dropCol "Survived"
    |> Frame.toJaggedArray

let survived: int array =
    train'
    |> Frame.getCol "Survived"
    |> Series.values
    |> Seq.toArray
```

次に，ロジスティック回帰とランダムフォレストのモデルを作成し，学習を行います．

```fsharp
open Accord
open Accord.Statistics.Analysis
open Accord.MachineLearning.DecisionTrees.Learning

// Multinomial logistic regression.
let MLR = MultinomialLogisticRegressionAnalysis().Learn(inputs, survived)

// Random forest.
let RF = C45Learning().Learn(inputs, survived)

// 入力から生存者を予測する関数を取得する．
let MLRDecide: float array -> int = MLR.Decide
let RFDecide: float array -> int = RF.Decide
```

これで `MLRDecide`，`RFDecide` という予測関数が得られました．
これを使ってテストデータの生存者を予測し，提出用の CSV ファイルを作成します．

```fsharp
// テストデータの予測結果を計算する．
let predictions (decide: float array -> int) =
    test'
    |> Frame.rows
    |> Series.observations
    |> Seq.map (fun (id, row) ->
        id,
        row.Values
        |> Seq.map Convert.ToDouble
        |> Seq.toArray
        |> decide
    )
    |> Seq.map (fun (id, pred) -> {|
        PassengerId = id
        Survived = pred
    |})
```

```fsharp
// 予測結果を出力する．
let export (fileName: string) (predictions: {| PassengerId: int; Survived: int |} seq) =
    let header = "PassengerId,Survived\n"
    let body =
        predictions
        |> Seq.map (fun p -> sprintf "%d,%d" p.PassengerId p.Survived)
        |> String.concat "\n"
    
    let out = header + body
    File.WriteAllText (__SOURCE_DIRECTORY__ + "/../submission/titanic/" + fileName + ".csv", out)
```

```fsharp
[
    "MLR", MLRDecide
    "RF", RFDecide
]
|> Seq.iter (fun (name, decide) ->
    printfn "Decider: %s" name

    let predictions = predictions decide

    predictions
    |> Seq.take 10
    |> Seq.iter (fun p -> printfn "PassengerId: %d, Survived: %d" p.PassengerId p.Survived)

    printfn "..."
    
    predictions |> export (name + "-submission")
)
```

予測結果の CSV ファイルが `submission/titanic` ディレクトリに出力されます．

```csv:MLR-submission.csv
PassengerId,Survived
892,0
893,0
894,0
895,0
896,1
...
```

```csv:RF-submission.csv
PassengerId,Survived
892,0
893,0
894,0
895,0
896,1
...
```

これを Kaggle に提出します．

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3554117/0760bd08-6694-3751-fea0-53f41bcd26f8.png)

多変量ロジスティック回帰のスコアが 0.76794，ランダムフォレストのスコアが 0.77511 という結果になりました．

## まとめ

データフレーム，可視化，学習といったデータサイエンスの基本的な処理を F# で行う手順を紹介しました．
.NET のライブラリやフレームワークを使うことができるのはもちろん，RProvider や Python.NET などのライブラリを介して R や Python のパッケージ群にもアクセスできるため，比較的マイナーな選択肢であるにもかかわらず利用可能なコード資産は十分に多いといえます．

ぜひデータサイエンスの第二言語として F# を試してみてください．

作成したプロジェクトは以下のリポジトリに置いてあります．

https://github.com/arakur/FSharpMLExample

## 補遺: F# の構文について

以上のコードを読む上で，関数型言語特有の記法や流儀に慣れていないと意味がとりづらいと感じるであろう部分について説明しておきます．

### 関数の引数

F# (やその他の関数型言語)では，一引数関数の引数は括弧を省略して単に並べて書くことができます．

```fsharp
f(x) // OK

f x // OK
```

ただし，二引数以上の関数の引数は括弧を省略することはできません．

```fsharp
g(x, y) // OK

g x, y // NG
```

そのため，F# 向けの関数には，複数の引数をタプルでいっぺんに受け取るのではなく，一引数ずつ順番に受け取るように定義されていることが多いです．

```fsharp
g' x y z // = ((g' x) y) z と読む．
```

このように定義することで，引数を途中までしか与えないという書き方が可能になります(部分適用)．

```fsharp
let h = g' x // 先に x のみ与え，
h y z // 後から y と z を与える．
```

なお，関数や引数が式になる場合は括弧を省略できません．

```fsharp
f x + y // = (f x) + y
f(x + y)
```

### パイプライン演算子

`f(g(h x))` のように複数の関数を順番に適用する式は，パイプライン演算子によって関数を繋げることで書くことができます．

```fsharp
f(g(h x))

x |> h |> g |> f

x
|> h
|> g
|> f
```

パイプライン演算子を用いることで，「`h` を適用」→「`g` を適用」→「`f` を適用」という処理の順序がより明確になります．
また括弧を省くことができるため，インデントも少なくなり読みやすくなります．

パイプライン演算子はしばしば部分適用と組み合わせられます．

```fsharp
f x (g y z (h w))

w
|> h
|> g y z
|> f x
```

そのため，F# ではパイプラインで順々に受け渡していくことが想定される引数は最後に配置されることが多いです．