
大きなファイルをダウンロードする際に進行状況を知りたくなります。
この記事では、urllibを使用してファイルをダウンロードする際に進行状況とファイルサイズを表示する方法を紹介します。

## 環境

- Python 3.10

## コード

```python
import urllib.request

def progress_callback(block_num, block_size, total_size):
    """
    ダウンロード進行状況とファイルサイズのコールバック関数

    :param block_num: これまでにダウンロードされたデータブロックの数
    :param block_size: データブロックのサイズ（バイト）
    :param total_size: ダウンロード対象のファイルの合計サイズ（バイト）
    """
    downloaded_size = block_num * block_size  # これまでにダウンロードしたバイト数
    progress = 100.0 * downloaded_size / total_size  # ダウンロード進捗率
    progress = min(100, progress)  # 進捗率が100%を超えないようにする

    # ファイルサイズをMB単位で表示
    downloaded_size_mb = downloaded_size / 1024 / 1024  # MB単位に変換
    total_size_mb = total_size / 1024 / 1024  # MB単位に変換

    print(f"\rダウンロード進捗: {progress:.2f}% [{downloaded_size_mb:.2f}MB/{total_size_mb:.2f}MB]", end=''

url = "ファイルのURL"
local_file = "保存するローカルファイルのパス"

# reporthook にコールバック関数を設定してファイルをダウンロード
urllib.request.urlretrieve(url, local_file, reporthook=progress_callback)
```

`urllib.request.urlretrieve()`の`reporthook`に状況を表示するコールバック関数を渡して表示できます。
この関数の引数に進捗や単位換算の処理を加えて表示しています。

1. :param block_num: これまでにダウンロードされたデータブロックの数
2. :param block_size: データブロックのサイズ（バイト）
3. :param total_size: ダウンロード対象のファイルの合計サイズ（バイト）

さらに、`\r`を使用することで、進行状況が同じ行に上書きされ、コンソールが冗長な情報で溢れることがないようにしています。

### 表示例

```bash
ダウンロード進捗: 3.95% [40.73MB/1032.33MB]
```

### urllib.request.urlretrieve()

ref : [python docs urllib.request](https://docs.python.org/3/library/urllib.request.html#module-urllib.request)

```python
(function) def urlretrieve(
    url: str,
    filename: StrOrBytesPath | None = None,
    reporthook: ((int, int, int) -> object) | None = None,
    data: _DataType = None
) -> tuple[str, HTTPMessage]
```

- 引数
  - url: ダウンロードするリソースのURL。
  - filename: ダウンロードしたファイルを保存するローカルファイルのパス。この引数が None または指定されない場合、urlretrieve は一時的な場所にファイルを保存します。
  - reporthook: ダウンロードの進捗状況を報告するためのコールバック関数。この関数が指定されている場合、ダウンロードの進捗情報を取得するために使用されます。関数は3つの引数 (block_num, block_size, total_size) を取ります。
    - block_num: これまでにダウンロードされたデータブロックの数。
    - block_size: 各データブロックのサイズ（バイト単位）。
    - total_size: ダウンロード対象のファイルの合計サイズ（バイト単位）。合計サイズが不明の場合は -1。
  - data: POSTリクエストに送信するデータ。この引数が指定されている場合、リクエストはPOSTとして扱われます。通常、ファイルをダウンロードする際にはこの引数は使用されません。
- 返り値
  - urlretrieve 関数はタプル (filename, headers) を返します。
    - filename: ダウンロードしたファイルが保存されたローカルファイルのパス。
    - headers: リクエストに対するサーバーの応答ヘッダーを表すオブジェクト。このオブジェクトは、HTTPヘッダー情報へのアクセスを提供します。


Python：ファイルダウンロードの進行状況とファイルサイズを表示する方法。urllib

Rustnの**HashMap**を使って同じ要素をカウントして多い順に並べてみます。

## Contents

## HashMapについて

ハッシュマップはキーとそれに紐づいた値の対応関係を保持した構造です。
他の言語ではハッシュテーブルや連想配列などとも呼ばれています。

- [std::collections::HashMap](https://doc.rust-lang.org/std/collections/struct.HashMap.html)
- [キーとそれに紐づいた値をハッシュマップに格納する - The Rust Programming Language 日本語版](https://doc.rust-jp.rs/book-ja/ch08-03-hash-maps.html?highlight=hashmap#%E6%96%B0%E8%A6%8F%E3%83%8F%E3%83%83%E3%82%B7%E3%83%A5%E3%83%9E%E3%83%83%E3%83%97%E3%82%92%E7%94%9F%E6%88%90%E3%81%99%E3%82%8B)

## 重複した要素のカウント

ベクトルにある数字をそれぞれカウントします。

```rust
use std::collections::HashMap;

fn main() {
 let vector = vec![1, 3, 4, 1, 2, 5, 2, 3, 4, 1, 3, 4, 1];
 // 要素ごとのカウント
 let mut hashmap = HashMap::new();
 for x in vector {
 let counter = hashmap.entry(x).or_insert(0);
 *counter += 1;
 }
 println!("{:?}", hashmap);
}
```

```txt:出力
{4: 3, 2: 2, 3: 3, 1: 4, 5: 1}
```

`let mut hashmap = HashMap::new();`でHashMapを初期化します。
後の処理で型が推測できます。

`.entry(x)`でキーを挿入しますが、`.entry(x).or_insert(0)`ではまだ存在しない場合にのみキーを挿入します。
`.or_insert(0)`は可変の値(`<K, V>`のV)の参照を返すため、`*counter += 1`のようにポインターで値を操作できます。

## 値の大きい順にソートする

ハッシュマップをカウントを降順にソートします。

```rust
// 先ほどカウントの続き

// カウント順にソート
let mut vector2: Vec<_> = hashmap.into_iter().collect();
vector2.sort_by(|x, y| y.1.cmp(&x.1));
println!("{:?}", vector2);
```

```txt:出力
[(1, 4), (3, 3), (4, 3), (2, 2), (5, 1)]
```

`hashmap.into_iter().collect();`でハッシュマップをタプルのベクトルに変換してから、タプルの２番目の要素を基準にソートします。
`sort_by()`は安定で最悪計算量が`O(n log n)`です。
ラムダ式みたいに`|x, y| y.1.cmp(&x.1)`とベクトルの要素を比較して整列します。
xとyを交換すると昇順になり、`y.0`と元キーだった要素でも比較ができる。

## ハッシュマップから最小（最大）の数を取り出す

`min_by`と`max_by`で最小と最大の要素をとりだせます。

```rust
// 最小を取得
let min = hashmap.iter()
 .min_by(|a, b| a.1.cmp(&b.1))
 .unwrap();
// (5, 1)


// 最大を取得
let max = hashmap.iter()
 .max_by(|a, b| a.1.cmp(&b.1))
 .unwrap();
// (1, 4)
```

## ハッシュマップを使ったAtCoderの問題

> **問題文**
>
> 高橋君は，$N$ 個のボールを持っています． 最初，$i$ 番目のボールには，整数 $A_i$ が書かれています．
> 高橋君は，いくつかのボールに書かれている整数を書き換えて，$N$ 個のボールに書かれている整数が $K$ 種類以下になるようにしたいです．
> 高橋君は，少なくとも何個のボールの整数を書き換える必要があるでしょうか？
>
> [ABC081 - C Not so Diverse](https://atcoder.jp/contests/abc081/tasks)

入出力や制約はAtCoderのページを見てください。

### 回答

クリックすると開きます。

<details><summary>回答と考え</summary>

この問題はハッシュマップでユニークな要素をそれぞれカウントして、数が小さい順に $K - Unique(Ai)$ 種類分の個数を合計した数が答えになります。

```rust
use std::collections::HashMap;
use std::collections::HashSet;

fn main() {
 proconio::input! {
 n: i32,
 k: i32,
 a: [i32; n]
 }
 // ユニークな数
 let uniq: HashSet<i32> = a.clone().into_iter().collect();
 let len = uniq.len() as i32 - k;
 if len <= 0 {
 println!("0");
 return;
 }
 // 要素ごとのカウント
 let mut map = HashMap::new();
 for x in a {
 let counter = map.entry(x).or_insert(0);
 *counter += 1;
 }
 // カウント順にソート
 let mut v: Vec<_> = map.into_iter().collect();
 v.sort_by(|x, y| x.1.cmp(&y.1));
 v.reverse();
 // println!("{:?}", v);
 let mut answer = 0;

 // 数が小さいものからk以下まで足し算
 for _ in 0..len {
 answer += v.pop().unwrap().1;
 }
 println!("{}", answer);
}
```

ユニークなボールの数は`HashSet`でわかる。

</details>

【Rust】HashMapで配列の同じ要素をカウントして多い順に並べる

Rustの数値型のベクトルをスペースやカンマなどの区切り文字を挟んだ文字列に変換(join)する書き方です。
Rustで競技プログラミングを始めたので必要としました。

`vec![1, 2, 3]`を`1 2 3`と出力させます。
イメージはPythonの`list.join(" ")`。

[playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=09f79ca9485db69ad1b98a822ab4e5da)でコードを実行確認できます。

## Contents

## 構文

```rust
// to_string
Vec<T>.iter().map(|x| x.to_string()).collect().join(" ")

// format!
Vec<T>.iter().map(|x| format!("{}", x)).collect().join(",")
```

この構文でベクトルを区切り文字で結合した文字列へ変換できる。
`format!("{}", x)`は応用が利くため便利。

以下で例と解説をする。

### 整数型

整数型のベクトルの例です。

```rust:rust
// 整数型
let src: Vec<i32> = vec![-3, -2, -1, 0, 1, 2, 3];

// 要素を整数型から文字列型変換
let dst: Vec<String> = src.iter().map(|x| x.to_string()).collect();
// 文字列型vectorを区切り文字で結合
println!("{}", dst.join(" "));
```

```txt:出力
-3 -2 -1 0 1 2 3
```

要素が文字列の`Vec<String>`では区切り文字を指定して結合する`.join(" ")`が利用できます。
そのため、`Vec<i32>`を`.map()`で要素ごとに文字列へ変換して`Vec<String>`にしています。
区切り文字は`.join(",")`などと変更できます。

- `iter().map(|x| x.to_string())`は要素ごとに文字列へ変換する処理です。Rust版のラムダ式ですかね。
 - [std::iter](https://doc.rust-lang.org/std/iter/)
 - [std::iter::Map](https://doc.rust-lang.org/std/iter/struct.Map.html)
- `.collect()`は`Map`を`Vec<T>`に直すことができる。
 - [std::iter.collect](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.collect)
 - `std::iter::Map`は`std::iter`を継承しているっぽい。

### 浮動小数点型

浮動小数点型も同じです。

```rust:rust
// 浮動小数点型
let src: Vec<f32> = vec![-3.3, -2.2, -1.1, 0.0, 1.1, 2.2, 3.3];

let dst: Vec<String> = src.iter().map(|x| x.to_string()).collect();
println!("{}", dst.join(" "));
```

```txt:出力
-3.3 -2.2 -1.1 0 1.1 2.2 3.3
```

`.0`は省略されるようです。

### 論理値型

浮動小数点型は`true`, `false`を出力できます。

```rust
 // 論理値型
 let src: Vec<bool> = vec![true, false];

 let dst: Vec<String> = src.iter().map(|x| x.to_string()).collect();
 println!("{}", dst.join(" "));
```

```txt:出力
true false
```

## format

`format!`で要素を文字列にするときのカスタマイズが容易になります。

- [std::fmt](https://doc.rust-lang.org/std/fmt/)に例がたくさんあります。

### 0埋め, パディング

[std::fmt#sign0](https://doc.rust-lang.org/std/fmt/#sign0)

```rust
// 浮動小数点型 0パディング
let src: Vec<f32> = vec![-3.3, -2.2, -1.1, 0.0, 1.1, 2.2, 3.3];

let dst: Vec<String> = src.iter().map(|x| format!("{:05}", x)).collect();
println!("{}", dst.join(" "));
```

```txt:出力
-03.3 -02.2 -01.1 00000 001.1 002.2 003.3
```

`format!("{:05}", x)`が5桁の0埋めです。

その他のサイン。

```rust
assert_eq!(format!("Hello {:+}!", 5), "Hello +5!");
assert_eq!(format!("{:#x}!", 27), "0x1b!");
assert_eq!(format!("Hello {:05}!", 5), "Hello 00005!");
assert_eq!(format!("Hello {:05}!", -5), "Hello -0005!");
assert_eq!(format!("{:#010x}!", 27), "0x0000001b!");
```

### fillalignment

[std::fmt#fillalignment](https://doc.rust-lang.org/std/fmt/#fillalignment)

```rust
assert_eq!(format!("Hello {:<5}!", "x"), "Hello x !");
assert_eq!(format!("Hello {:-<5}!", "x"), "Hello x----!");
assert_eq!(format!("Hello {:^5}!", "x"), "Hello x !");
assert_eq!(format!("Hello {:>5}!", "x"), "Hello x!");
```

## 文字列型

文字列型の場合は既に要素が文字列であるため、変換が不要です。

```rust
let months = vec!["January", "February", "March", "April", "May", "June", "July",
 "August", "September", "October", "November", "December"];
println!("{}", months.join(", "));
```

```txt:出力
January, February, March, April, May, June, July, August, September, October, November, December
```

## タプルの場合

Rustのタプルは異なる型を納められます。
`map()`はジェネリックだったのと、整数型と浮動小数点型は`to_string()`を持つため混合していても良いかと考えてましたが、エラーが出ました。

```rust
let src = (500, 6.4, 1);
let dst: Vec<String> = src.iter().map(|x| x.to_string()).collect();

println!("{}", dst.join(" "));
```

```txt:出力
error[E0599]: no method named `iter` found for tuple `({integer}, {float}, {integer})` in the current scope
 --> src/main.rs:41:32
 |
41 | let dst: Vec<String> = src.iter().map(|x| x.to_string()).collect();
 | ^^^^ method not found in `({integer}, {float}, {integer})`

error: aborting due to previous error
```

型を混合したものは`iter`で扱えないようです。

## おわり

- [playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=09f79ca9485db69ad1b98a822ab4e5da)

【Rust】数値型のベクトルをスペース区切りの文字列に変換(join)する

printでずらっと出力していた進捗状況をプログレスバーで表示する方法を知ったのでメモします。

## tqdmで進捗を可視化する

- [tqdm - GitHub](https://github.com/tqdm/tqdm)

このモジュールを使うと▼のようなプログレスバーがforの進捗に応じて表示できます。
利用方法は`tqdm`をインポートして、配列などイテレータを`tqdm(iterable)`とするだけでOKです。
```python
!pip install tqdm

from tqdm import tqdm
for i in tqdm(range(616435)):
 # 処理
```
```txt:出力
76%|████████████████████████ | 7568/10000 [00:33<00:10, 229.00it/s]
```

またコマンドとしても利用出来ます。
▼のようにパイプラインで利用する方法もREADMEに載ってます。
```bash
$ seq 9999999 | tqdm --bytes | wc -l
75.2MB [00:00, 217MB/s]
9999999

$ tar -zcf - docs/ | tqdm --bytes --total `du -sb docs/ | cut -f1` \
 > backup.tgz
 32%|██████████▍ | 8.89G/27.9G [00:42<01:31, 223MB/s]
 ```

▼アニメーション
![image](https://raw.githubusercontent.com/tqdm/img/master/tqdm.gif)


## 利用例①

インストール
```python
$ pip install tqdm

# Google Colaboratory
!pip install tqdm
```
配列を`tqdm()`に入れるだけでプログレスバーを表示できる。
```python
from tqdm import tqdm
from time import sleep

text = ""
for char in tqdm(["a", "b", "c", "d"]):
 sleep(0.25)
 text = text + char
```
```bash:出力
100%|██████████| 4/4 [00:01<00:00, 3.97it/s]
```

▼インデックスを使いたい時。
```python
array = ["a", "b", "c", "d"]
for i in tqdm(range(len(array))):
 some_function(array[i])
```

## 利用例②

[こちら](https://www.ogis-ri.co.jp/otc/hiroba/technical/similar-document-search/part9.html)の記事の一部の処理の時間が長くて、いつ終わるか不安だったのでtqdmで進捗を確認できるようにした。
`captions`が文字列のリストになっていて順次文章ベクトルに変換している。

インポートとイテレータを`tqdm()`に入れるだけで使える。コメントした箇所が変更した部分。
```python
import numpy as np
import spacy
import pkg_resources, imp
from tqdm import tqdm # 追加

imp.reload(pkg_resources)

nlp = spacy.load("ja_ginza")

vectors = []
# for caption in captions:
for caption in tqdm(captions): # tqdmを使ってループする
 doc = nlp(caption, disable=['ner']) 
 vectors.append(doc.vector)

del nlp
```
```bash:出力
87%|████████▋ | 538893/616435 [56:20<07:39, 168.71it/s]
```

【Python】tqdmでforの進捗状況を表示する


日本語も対応した学習済み単語ベクトルのFastTextをFacebookが公開しています。
これをColabolatoryで使ってみて以下のような、類似単語の分布を描いてみます。

[Colaboratory](https://colab.research.google.com/notebooks/intro.ipynb?hl=ja#recent=true)を使います。
Google Driveにあげたデータを利用することが簡単になってました。
Colabでいっぱい試して、大きな分析はサーバやローカルで分析するのがよさそうですね。

## 単語ベクトルの学習済みモデルを利用する

fastTextの日本語の学習済み単語ベクトルを利用します。
モデルにはいくつか種類がありますが、今回は[こちら](https://fasttext.cc/docs/en/crawl-vectors.html)にあるWEBクローラーとWikipediaの文書から学習したモデルを利用します。

この中の日本語のファイル`cc.ja.300.vec.gz`(1.2GB)をダウンロードして、Google Driveにアップロードしておきます。
新規のColabolatoryを開いてGoogle Driveをマウントします。

![mnt](/images/posts/280/281/mnt.png)

fastTextのライブラリを利用する手もありますが、ここでは自然言語処理に便利なライブラリの[gensim](https://radimrehurek.com/gensim/)に任せてみます。
マウント出来たらドライブを開いて、先ほどアップロードしたモデルのパスをgensimに渡してロードします。
ロードには10分くらいかかるので気長に待ちましょう。

```python
import gensim

# 学習済モデルのパス
model_path = '/content/drive/MyDrive/Colab Notebooks/fasttextmodel/cc.ja.300.vec.gz'
# ロードに10分くらいかかる
model = gensim.models.KeyedVectors.load_word2vec_format(model_path, binary=False)
```

モデルの形式を確認します。
このモデルは長さ5のn-gramからCBOWで学習しています。
ひとつの単語は300次元のベクトルで表される。
```python
# 登録している単語の数
print(len(model.vocab.keys())) # 2000000

# ひとつの単語ベクトルの次元
model['猫'].shape # (300,)
```

Colaboratoryではコードブロックの最後の行のオブジェクトはprintみたいに結果を出力できます。

## 単語ベクトルを試す

単語ベクトルが扱えるようになったので色々と遊んでみる。
読み込んだ単語ベクトルで出来ることはこちらで紹介されています。

[What can I do with word vectors?](https://radimrehurek.com/gensim/models/keyedvectors.html#why-use-keyedvectors-instead-of-a-full-model)

補足ですが、fastTextから読み込んだのは、**full model**ではなく**KeyedVectors**です。主な違いはKeyedVectorsはこれ以上トレーニングできない代わりに、トレーニングに必要な内部データ構造を排除して軽量にしています。
また、fastTextはfull modelとしてロードできないそうです。

[Why use KeyedVectors instead of a full model?](https://radimrehurek.com/gensim/models/keyedvectors.html#why-use-keyedvectors-instead-of-a-full-model)

### 類似する単語を挙げる

指定した単語に類似した単語を挙げてみます。
類似した単語と単語のユークリッド距離が出ます。

```python
from pprint import pprint

pprint(model.most_similar('猫', topn=10))
```
```txt:出力
[('ネコ', 0.8059155941009521),
 ('ねこ', 0.7272598147392273),
 ('子猫', 0.720253586769104),
 ('仔猫', 0.7062687873840332),
 ('ニャンコ', 0.7058036923408508),
 ('野良猫', 0.7030349969863892),
 ('犬', 0.6505385041236877),
 ('ミケ', 0.6356303691864014),
 ('野良ねこ', 0.6340526342391968),
 ('飼猫', 0.6265145540237427)]
```

### 単語の類似度を出す

```python
print(model.similarity('猫', '犬'))
print(model.similarity('猫', '人'))
```
```txt:出力
0.65053856
0.23371725
```
`猫`は`人`より`犬`に近いようですね。

### 王様 - 男 + 女 = ?

```python
# 単語ベクトルの演算
new_vec = model['王様'] - model['男'] + model['女']

# 計算したベクトルに類似した単語
pprint(model.similar_by_vector(new_vec))
```
```txt:出力
[('王様', 0.8916897773742676),
 ('女王', 0.527921199798584),
 ('ラジオキッズ', 0.5255386829376221),
 ('王さま', 0.5226017236709595),
 ('王妃', 0.5000214576721191),
 ('裸', 0.487439900636673),
 ('タプチム', 0.4832267761230469),
 ('アンナ・レオノーウェンズ', 0.4807651937007904),
 ('ゲムケン', 0.48058977723121643),
 ('お姫様', 0.4792743921279907)]
```

よくある単語の関係を計算するやつを試してみます。
単語はベクトルですので計算ができます。
トップが`王様`で、次いで予測していた`女王`が出てきました。

この結果のような`タプチム`や`ゲムケン`など聞きなれない言葉や、中国語も混じっていたりします。
利用しているfastTextのモデルはWikipediaとWEBクローラーで集めたの文書で学習しています。
精度が悪いものは、おそらく、その単語の学習データ少なかったのでしょう。

単語はベクトルの計算は以下のようにも書けます。
こちらの結果は言葉の感覚的にあってました。

```python
model.most_similar(positive=['姪', '男性'], negative=['女性'])
```
```txt:出力
[('甥', 0.8209505081176758),
 ('叔父', 0.6412274837493896),
 ('叔母', 0.6293267011642456),
 ('従姉', 0.6224151849746704),
 ('弟', 0.6069883108139038),
 ('従兄', 0.595562756061554),
 ('従姉妹', 0.594235360622406),
 ('伯父', 0.5939351916313171),
 ('義妹', 0.5894800424575806),
 ('従兄弟', 0.5876302719116211)]
```

### 単語の類似度を出す

```python
print(model.similarity('猫', '犬'))
print(model.similarity('猫', '人'))
```
```txt:出力
0.65053856
0.23371725
```
## 単語の類似度の分布をグラフにする

ここから趣向を変えて、単語の類似度をグラフに表してみます。

いくつかの単語にそれぞれ類似した単語をクラスターとして、どんな分布になっているか散布図にプロットしていみる。

```python
import numpy as np

# 入力した単語に類似した単語とベクトルを返す
def similars(words, model):
    vectors = []
    cluster = []
    label = []
    for i in range(len(words)):
        word = words[i]
        similar = model.similar_by_word(word, topn=10)
        for x in similar:
            cluster.append(i)
            label.append(word)
            vectors.append(model[x[0]])
    return vectors, cluster, label

words = ['猫', '銃', '鉄', '病原菌']
vectors, cluster, label = similars(words, model)

# ベクトルの次元を確認
print(np.array(words).shape)
print(np.array(cluster).shape)
print(np.array(vectors).shape)

# 類似した単語の確認
for word in words:
    similar = model.similar_by_word(word, topn=10)
    print(word, [x[0] for x in similar])
```
`鉄`の単語だけバグってますね。中国語でしょうか？
```txt:出力
(4,)
(40,)
(40, 300)
猫 ['ネコ', 'ねこ', '子猫', '仔猫', 'ニャンコ', '野良猫', '犬', 'ミケ', '野良ねこ', '飼猫']
銃 ['拳銃', '銃器', '短銃', '小銃', 'ダルヌ', '猟銃', 'アサルトライフル', '散弾', 'レムリカ', '蟲砕']
鉄 ['拐仙', '蕉館', '勒諸', 'ワン・アンダードッグ', '拐山', 'ブリキンガー', '珪輝', '拐李', 'ぱいぷ', '鋼鉄']
病原菌 ['病原', '細菌', 'ウイルス', 'ばい菌', 'エボラウィルス', '伝染病', '感染', '菌', 'ウィルス', 'ゾンビウィルス']
```

グラフに日本語描画する際には▼をインストールしておくと勝手に日本語に対応してくれる。これがないと`□□□□□`と豆腐になる。ありがたい！
```python
!pip install japanize-matplotlib
```

▼ベクトルは300次元のままだと表すことができないため、主成分分析（PCA）で２次元まで次元を減らします。
あとは、クラスター毎に色を付けて散布図にプロットしています。

```python
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
import japanize_matplotlib 

def draw_scatter_plot(vectors, words, cluster):

    colors = ["b", "g", "r", "c", "m", "y", "k"]

    # Scikit-learnのPCAでn_componentsの数値で次元数を決める
    pca = PCA(n_components=2)
    coords = pca.fit_transform(vectors)

    # matplotlibによる可視化
    fig, ax = plt.subplots()
    x = [v[0] for v in coords]
    y = [v[1] for v in coords]

    for i in range(len(words)):
        xx = []
        yy = []
        for c, a, b in zip(cluster, x, y):
            if i == c:
                xx.append(a)
                yy.append(b)
        ax.scatter(xx, yy, c=colors[i % 7], label=words[i])
    ax.legend(loc='upper right')
    plt.show()

draw_scatter_plot(vectors, words, cluster)
```
出力  
![graph](/images/posts/280/281/graph.png)

視覚的にわかりやすいグラフになりました。
`鉄`と`銃`のクラスターよりも、`鉄`と`猫`のクラスターのほうが近く固まっていたのは、鉄の単語がうまく学習できていなかったからかと思います。

単語を変えて遊べるので試してみてください。

## 参考: 

- [Python: gensim で学習済み単語ベクトル表現を扱ってみる](https://blog.amedama.jp/entry/gensim-fasttext-pre-trained-word-vectors)

学習済みの日本語単語ベクトルをColabolatoryで試してみる

Unity ML-Agentsで新しく学習環境を作る


UnityもML-Agentsもわからなかったので参考書を買いました。

![mlagents-book](/images/posts/270/273/mlagents-book.jpg)

[Unityではじめる機械学習・強化学習 Unity ML-Agents実践ゲームプログラミング](https://amzn.to/365Q94z)


## この本の良い点

- 日本語の情報が少ないML-Agentsについてまとめてある
- ハイパーパラメータの典型的な範囲と説明がある！！
- Unityのパラメータの画像が豊富にありわかりやすい

### 日本語の情報が少ないML-Agentsについてまとめてある

ML-Agentsについてググって出る日本語の情報は多くない。
あってもサンプルを動かすところまでがほとんどで、UnityもML-Agentsもわからないのでナンモワカラン状態だった。

[公式のドキュメント](https://github.com/Unity-Technologies/ml-agents/blob/release_12_docs/docs/Readme.md)はかなり詳しいが、英語を読むにも手がかりが欲しい。

書籍でML-Agentsを体系的に学んだことで、公式のドキュメントも読んでなんとなくわかるくらいまでになりました。

### ハイパーパラメータの典型的な範囲と説明がある！！

個人的に一番おすすめのポイントはこれ！
これだけで今後も長く見返すことが決まったぐらいありがたい。

ハイパーパラメータはニューラルネットワークの層の数や報酬にかかる係数など、推論や予測の枠組みの中で決定されないパラメータで人が任意に決める数値です。
このパラメータは学習する速度や精度に大きく影響していて、的外れなパラメータだと学習できないこともあります。
そのため、あらかじめ良さげなパラメータで学習を始めて徐々に調整していく必要があります。
この調整がチューニングです。
また、ML-AgentsではPPOやSACといった強化学習のモデルを利用しますが、モデルによってもハイパーパラメータが異なります。

はい。
このハイパーパラメータが何を意味するのか？
そして、どの範囲で調整したら良いか？大きくしたら学習にどんな影響があるのか？が初心者にとってさっぱりで悩んだら嵌ります。
それゆえ、ハイパーパラメータの典型的な範囲と説明があるのはありがたいなと思いました。

著者の布留川英一さんは「[AlphaZero 深層学習・強化学習・探索 人工知能プログラミング実践入門](https://amzn.to/363EWl4)」なども書いていらっしゃるので信頼感があります。




## 前提

- Unityに初めて触った。
- DeepLeaningは[ゼロから作るDeep Learning](https://amzn.to/3qJFYuw)のシリーズといくつかの本で学んだ。
- 10年くらい前に研究でSVMを使ってた。
- C#とPythonは業務で利用した

【技術書】Unityではじめる機械学習・強化学習 Unity ML-Agents実践ゲームプログラミング

Unity ML-Agentsのインストールから学習まで


青空文庫のデータを使った分かち書きと頻出単語の算出をしてみました。

以下の流れで、テキストを取得するところから頻出単語を求めるところまでのコードになっています。

1. 青空文庫からテキストのzipをダウンロードしてzipを展開する。
2. ファイルを読み込む。
3. テキストを前処理する。
4. janomeで分かち書きをして頻出単語を求める。

将来的に小説から言語モデルを作りたいのでわりとしっかりと作りました（大言）。

## 環境

- Python 3.9

[リポジトリ](https://github.com/suzu6/nlp_samples)ではDockerでPython環境を作ってます。
その構成も参考になればどうぞ。

## [Janome](https://mocobeta.github.io/janome/)

分かち書きには形態素解析で有名な[Mecab](https://taku910.github.io/mecab/)ではなくJanomeを利用しました。

Mecabと比べると、Janomeはインストールが簡単で精度が同等ですが、速度はMecabのほうが10倍程度早いです。
MeCabの辞書と言語モデルと同等のものをPythonで実装しているため、そのような特徴を持ちます。

`pip install janome`でインストールできます。

[janome - github](https://github.com/mocobeta/janome)

## コード

関数ごとに区切って紹介します。

全体のコードは[こちら](https://github.com/suzu6/nlp_samples/blob/master/opt/dogura_magura.py)。

### 1. 青空文庫からテキストのzipをダウンロードしてzipを展開する。

```python
import glob
import os.path
import requests
import zipfile
from typing import Union


def downloadFile(url: str, target_dir='./') -> Union[str, bool]:
    """URL を指定してカレントディレクトリにファイルをダウンロードする
    """
    filename = target_dir + url.split('/')[-1]
    if os.path.exists(filename):
        # サイトに負荷をかけないため
        print(filename, 'is downloaded already.')
        return filename
    r = requests.get(url, stream=True)
    with open(filename, 'wb') as f:
        for chunk in r.iter_content(chunk_size=1024):
            if chunk:
                f.write(chunk)
                f.flush()
        print('{} is downloaded.'.format(filename))
        return filename

    # ファイルが開けなかった場合は False を返す
    return False


def unzip(filename: str, target_dir='./') -> list:
    """ファイル名を指定して zip ファイルを展開する
    """
    if not zipfile.is_zipfile(filename):
        print(filename, 'is not zipfile.')
        return -1
    zfile = zipfile.ZipFile(filename)
    zfile.extractall(target_dir)
    zfile.close()

    # 展開したテキストのリストを取得する
    dst_filenames = glob.glob(target_dir + '*.txt')
    print(dst_filenames)
    return dst_filenames

def if __name__ == "__main__":
    # ドグラ・マグラのリンク先
    URL = 'https://www.aozora.gr.jp/cards/000096/files/2093_ruby_28087.zip'
    tmp_dir = 'tmp/'

    zip_file = downloadFile(URL, tmp_dir)
    filenames = unzip(zip_file, tmp_dir)
    ...
```

テンプディレクトリにzipと解凍したファイルを展開しています。
zipが既にローカルにある場合は、サイトに負荷をかけないよう手元のファイルを使うようにしました。

unzip()の返り値はリストになってます。

青空文庫のテキスト版アクセスランキングで8位にあって思わずドグラ・マグラを選でます。
読み進めるのがツラい小説ですね。
１ヵ月かけて読んで結局よくわからなかったので、この機にパソコンに何度も読ませたろうかと。。。

### 2. ファイルを読み込む。

```python
def readSjis(path: str) -> str:
    """ShiftJISのテキストを読み込む
    """
    with open(path, mode="r", encoding='shift_jis') as f:
        text = f.read()
    return text


def if __name__ == "__main__":
    ...

    filenames = unzip(zip_file, tmp_dir)
    # 展開した１つのファイル名を渡す
    text = readSjis(filenames[0])
    
    ...
```

いくつかの小説をあたってみましたが、青空文庫のテキストファイルは**ShiftJIS**のようです。
`encoding='shift_jis'`で読み込めます。

### 3. テキストを前処理する。

テキストの冒頭にはタイトル、著者に加えてテキストの記号についての記述があります。

```txt
ドグラ・マグラ
夢野久作

-------------------------------------------------------
【テキスト中に現れる記号について】

《》：ルビ
（例）蜜蜂《みつばち》

｜：ルビの付く文字列の始まりを特定する記号
（例）大の字｜型《なり》に

［＃］：入力者注　主に外字の説明や、傍点の位置の指定
　　　（数字は、JIS X 0213の面区点番号またはUnicode、底本のページと行数）
（例）※［＃ローマ数字1、1-13-21］

　［＃…］：返り点
　（例）五｜月《がつ》於《おいて》［＃二］

／＼：二倍の踊り字（「く」を縦に長くしたような形の繰り返し記号）
（例）やう／＼にして語り出づるやう
＊濁点付きの二倍の踊り字は「／″＼」
-------------------------------------------------------

［＃ページの左右中央］


［＃ここから５字下げ］
　巻頭歌


胎児よ

何故躍る

母親の心がわかって

おそろしいのか
```

テキストビューアーのためのものですが、今回は不要なためルビや注釈を除去していきます。

```python
import re

def preproccessing(text):
    """テキストの前処理をする
    """
    lines = text.split('\n')
    print('処理前 文字数:', len(text), ', 行数:', len(lines))
    # 作品情報
    title = lines[0].strip()
    author = lines[1].strip()
    print(title, author)

    # ルビ、注釈などの除去
    text = re.split(r'\-{5,}', text)[2]
    text = re.split(r'底本：', text)[0]
    text = re.sub(r'《.+?》', '', text)
    text = re.sub(r'［＃.+?］', '', text)
    # 全角スペース
    text = re.sub(r'\u3000', '', text)
    # 複数の改行
    text = re.sub(r'\n+', '\n', text)
    text = text.strip()

    lines = text.split('\n')
    print('処理後 文字数:', len(text), ', 行数:', len(lines))
    return text


def if __name__ == "__main__":
    ...

    text = readSjis(filenames[0])
    text = preproccessing(text)

    ...


"""    
処理前 文字数: 468996 , 行数: 3417
ドグラ・マグラ 夢野久作
処理後 文字数: 425638 , 行数: 2959
"""
```

### 4. janomeで分かち書きをして頻出単語を求める。

```python

from janome.tokenizer import Tokenizer
import collections

def wakati(text: str):
    """テキストを分かち書きにして頻出単語を求める
    """
    t = Tokenizer()
    # 単語頻度
    c = collections.Counter(t.tokenize(text, wakati=True))
    print(c.most_common()[:15])

    # 特定の品詞のみ
    c = collections.Counter(token.base_form for token in t.tokenize(text)
                            if token.part_of_speech.startswith('名詞,固有名詞'))
    print(c.most_common()[:15])


def if __name__ == "__main__":
    ...

    wakati(text)

"""
# 単語頻度　降順
('の', 16011)
('、', 15485)
('…', 10802)
('に', 10112)
('て', 8831)
('。', 7791)
('を', 7770)
('た', 6648)
('が', 5530)
('と', 5522)
('は', 5029)
('で', 4168)
('し', 3307)
('\n', 2958)
('も', 2542)

# 特定の品詞（名詞,固有名詞）のみ
('呉', 481)
('若林', 346)
('一郎', 340)
('正木', 250)
('青', 86)
('秀', 86)
('斎藤', 68)
('福岡', 58)
('モヨ', 53)
('卓子', 42)
('九大', 35)
('大正', 34)
('姪の浜', 34)
('行衛', 33)
('九州', 32)
"""
```


`t.tokenize(text)`で分かち書きしたものの単語とその情報が取り扱えるようになります。

品詞で絞りたい場合は`token.part_of_speech.startswith('名詞,固有名詞')`とするとよい。
品詞はMecabの[品詞IDの定義](https://taku910.github.io/mecab/posid.html)に一覧がある。

頻出単語は`collections.Counter`でカウントして、`c.most_common()`降順に並び替えている。

## 参考

- [Janomeを使ってPythonで形態素解析](https://qiita.com/charon/items/661d9a25b2233a9f8da4)
- [【Python】MeCabを使って青空文庫を簡単に分かち書きする方法](https://sleepless-se.net/2018/08/28/mecat-wakatigaki/)
  - [Mecab](https://taku910.github.io/mecab/)と[Google Colaboratory](https://colab.research.google.com/notebooks/welcome.ipynb?hl=ja)を使われている。
- [青空文庫からPythonで本文を取得したい](https://newtechnologylifestyle.net/711-2/)

【Python】青空文庫の小説を分かち書きして頻出単語を取得する

## はじめに

[言語処理100本ノック 2015](http://www.cl.ecei.tohoku.ac.jp/nlp100/)

Pythonを勉強するため、[東京工業大学の岡崎教授](http://www.chokkan.org/)が出題されている[言語処理100本ノック 2015](http://www.cl.ecei.tohoku.ac.jp/nlp100/)を解いていきます。

## 環境
転職してちょうど１年空いてしまった。
やる気が出たので続きをしていきます。

この先、環境がばらつくかもしれませんがご了承ください。

- Python 3.7 (← Python3.6）
- OS : Ubuntu 18 (← Linux Mint)

## 問題

３章からWikiを解析する問題になっています。

> Wikipediaの記事を以下のフォーマットで書き出したファイル[jawiki-country.json.gz](http://www.cl.ecei.tohoku.ac.jp/nlp100/data/jawiki-country.json.gz)がある．
>
> - 1行に1記事の情報がJSON形式で格納される 
> - 各行には記事名が"title"キーに，記事本文が"text"キーの辞書オブジェクトに格納され，そのオブジェクトがJSON形式で書き出される 
> - ファイル全体はgzipで圧縮される 
> 以下の処理を行うプログラムを作成せよ． 

> **27. 内部リンクの除去** 
> 26の処理に加えて，テンプレートの値からMediaWikiの内部リンクマークアップを除去し，テキストに変換せよ（参考: [マークアップ早見表](http://ja.wikipedia.org/wiki/Help:%E6%97%A9%E8%A6%8B%E8%A1%A8)）．

## Point

- ファイルの読み込み、イギリスの記事抽出は[20](https://www.suzu6.net/posts/44)と同じ。
- テンプレートを記述している箇所の抽出は[25](https://www.suzu6.net/posts/104-100knock-25/)と同じ。
- 強調マークアップの除去は[26](https://www.suzu6.net/posts/115-100knock-26/)と同じ。
- 内部リンクの除去を行う。

内部リンクのマークアップは以下の通り。

| 入力内容 | 表示結果 |
| -------------------------- | -------- |
| `[[記事名]]` | 記事名 |
| `[[記事名|表示文字]]` | 表示文字 |
| `[[記事名#節名|表示文字]]` | 表示文字 |

入力内容から表示結果の文字列に変換することを、内部リンクの除去とします。
`[[]]`で囲まれた箇所を`|`が無ければそのまま、`|`があれば右側の文字列を残すようにします。

例えば、前回の出力の中では以下の箇所が該当します。

```sh
# [[記事名]]
[[イングランド王国]] -> イングランド

# [[記事名|表示文字]]
[[スターリング・ポンド|UKポンド]] -> UKポンド
```

## 解答：Python

```py
# coding: utf-8

import gzip
import json
import re


def read_wiki(fname, tiltle):
 with gzip.open(fname, 'rt', encoding="utf-8") as data_file:
 for line in data_file:
 data_json = json.loads(line)
 if data_json['title'] == 'イギリス':
 return data_json['text']


def get_basic_information(string):
 m1 = re.search(r'{{基礎情報 国.*?', string)
 # print(m1.end())
 m2 = re.search(r'(.*)\n}}\n', string[m1.end():])
 return string[m1.end():m2.end()+1]


def remove_emphasis(string):
 # 強調を除去
 # m = re.match(r"(.*)('{2,5})(.*?)(\2)(.*)", string) 何故か{2,5}で'がひとつ残る
 m = re.match(r"(.*)('{3,5})(.*?)(\2)(.*)", string)
 if m is None:
 return string
 dst = m.group(1) + m.group(3) + m.group(5)
 # print(dst)
 return dst


def remove_inner_link(string):
 # 内部リンクを除去
 dst = re.sub(r"\[\[(?:[^:\]]+?\|)?([^:]+?)\]\]", r"\1", string)
 return dst


def main():
 fname = 'jawiki-country.json.gz'
 text = read_wiki(fname, 'イギリス')
 # print(len(text))
 text = get_basic_information(text).split('\n')

 basic_info = {}
 for line in text:
 m = re.match(r'\|(.+)( = )(.*)', line)
 if m is None:
 continue
 val = remove_emphasis(m.group(3).strip())
 val = remove_inner_link(val)
 basic_info[m.group(1).strip()] = val

 # JSONで表示を整形
 print(json.dumps(basic_info, sort_keys=True, indent=4, ensure_ascii=False))


if __name__ == '__main__':
 main()
```

### 解説

カッコ内に`|`がある場合に右側だけ取り出す方法が判らず、[こちら](http://gushwell.ldblog.jp/archives/52514281.html)の方法をお借りしました。

また、今まで`re.match`を利用していましたが一行に内部リンクが複数ある場合に対応できなかったため、[re.sub](https://docs.python.org/ja/3/library/re.html#re.sub)にしました。

`re.sub(pattern, repl, string, count=0, flags=0)`

`re.sub`はstring中に出現する最も左の重複しない pattern を置換 repl で置換することで得られる文字列を返します。
countが0のときマッチする箇所を全て置換します。

```python
>> print(remove_inner_link(
 '[[グレートブリテン及びアイルランド連合王国]]建国 （[[連合法 (1800年)|1800年連合法]]）'))
グレートブリテン及びアイルランド連合王国建国 （1800年連合法）

>> print(remove_inner_link('[[エリザベス2世]]'))
エリザベス2世
```

### 出力


```json
{
 "GDP/人": "36,727<ref name=\"imf-statistics-gdp\" />",
 "GDP値": "2兆3162億<ref name=\"imf-statistics-gdp\" />",
 "GDP値MER": "2兆4337億<ref name=\"imf-statistics-gdp\" />",
 "GDP値元": "1兆5478億<ref name=\"imf-statistics-gdp\">[http://www.imf.org/external/pubs/ft/weo/2012/02/weodata/weorept.aspx?pr.x=70&pr.y=13&sy=2010&ey=2012&scsm=1&ssd=1&sort=country&ds=.&br=1&c=112&s=NGDP%2CNGDPD%2CPPPGDP%2CPPPPC&grp=0&a= IMF>Data and Statistics>World Economic Outlook Databases>By Countrise>United Kingdom]</ref>",
 "GDP統計年": "2012",
 "GDP統計年MER": "2012",
 "GDP統計年元": "2012",
 "GDP順位": "6",
 "GDP順位MER": "5",
 "ISO 3166-1": "GB / GBR",
 "ccTLD": ".uk / .gb<ref>使用は.ukに比べ圧倒的少数。</ref>",
 "人口値": "63,181,775<ref>[http://esa.un.org/unpd/wpp/Excel-Data/population.htm United Nations Department of Economic and Social Affairs>Population Division>Data>Population>Total Population]</ref>",
 "人口大きさ": "1 E7",
 "人口密度値": "246",
 "人口統計年": "2011",
 "人口順位": "22",
 "位置画像": "Location_UK_EU_Europe_001.svg",
 "元首等氏名": "エリザベス2世",
 "元首等肩書": "女王",
 "公式国名": "{{lang|en|United Kingdom of Great Britain and Northern Ireland}}<ref>英語以外での正式国名: ",
 "公用語": "英語（事実上）",
 "国旗画像": "Flag of the United Kingdom.svg",
 "国歌": "神よ女王陛下を守り給え",
 "国章リンク": "（国章）",
 "国章画像": "[[ファイル:Royal Coat of Arms of the United Kingdom.svg|85px|イギリスの国章]]",
 "国際電話番号": "44",
 "夏時間": "+1",
 "建国形態": "建国",
 "日本語国名": "グレートブリテン及び北アイルランド連合王国",
 "時間帯": "±0",
 "最大都市": "ロンドン",
 "標語": "{{lang|fr|Dieu et mon droit}} （フランス語:神と私の権利）",
 "水面積率": "1.3%",
 "略名": "イギリス",
 "確立年月日1": "927年／843年",
 "確立年月日2": "1707年",
 "確立年月日3": "1801年",
 "確立年月日4": "1927年",
 "確立形態1": "イングランド王国／スコットランド王国 （両国とも1707年連合法まで）",
 "確立形態2": "グレートブリテン王国建国 （1707年連合法）",
 "確立形態3": "グレートブリテン及びアイルランド連合王国建国 （1800年連合法）",
 "確立形態4": "現在の国号「グレートブリテン及び北アイルランド連合王国」に変更",
 "通貨": "UKポンド (&pound;)",
 "通貨コード": "GBP",
 "面積値": "244,820",
 "面積大きさ": "1 E11",
 "面積順位": "76",
 "首相等氏名": "デーヴィッド・キャメロン",
 "首相等肩書": "首相",
 "首都": "ロンドン"
}
```

## 次の記事

[Python3で言語処理100本ノックまとめ](https://www.suzu6.net/posts/29)

前の問題：[26. 強調マークアップの除去](https://www.suzu6.net/posts/115-100knock-26/)

前の問題：[28](#)

27. 内部リンクの除去

Atcoderのマラソン型コンテスト[北大・日立新概念コンピューティングコンテスト2018](https://atcoder.jp/contests/hokudai-hitachi2018)に６日目になってやっと参加しました。
現時点(2019-02-19 12:00)でコードを提出した人が100人に満たないようです。

参加の閾値を下がるかと思うので、最低限の点数が取れるPythonのコードをさらします。
品質に関しては灰色コーダーなので察してください。
ご自由にどうぞ。

## ソースコード

[北大・日立新概念コンピューティングコンテスト2018で正の点数が取りたい](https://qiita.com/nekomimimi/items/6c0a05bc60bcb5f3e975)を参考にさせていただきました。

```python


def _output(S, L, c, v):
 print(S, L)
 for i in range(L):
 print(len(v[i]), c[i], *v[i])


def _input():
 N, K = list(map(int, input().split()))
 v = [[] for i in range(K)]
 c = [0 for i in range(K)]
 for i in range(K):
 tmp = list(map(int, input().split()))
 c[i] = tmp[1]
 v[i] = tmp[2:]

 return N, K, c, v


def calc(N, K, c, v):
 v_res = []
 c_res = []

 total_c = 0

 for i in range(K):
 if len(v[i]) > 0 and len(v[i]) <= 2:
 v_res.append(v[i])
 c_res.append(c[i])
 else:
 total_c += max(0, c[i])
 v_res.append([])
 c_res.append(max(1, total_c))
 return N, len(v_res), c_res, v_res

def main():
 N, K, c, v = _input()
 S, L, c, v = calc(N, K, c, v)
 _output(S, L, c, v)


if __name__ == "__main__":
 main()
```

`_input()`と`_output()`で入出力をしている。
`calc()`のところで$g(X,W)$を作成しています。

参考によると次数が$0<d \le 2$はそのままにして、それ以外は$f(X) \le g(X,W)$となるように正の係数と定数の合計を定数として出力しています。

スコアはA,B,Cの合計で4.5E08ぐらいは取れました。

## これから

$2<d$の次数をどうにかしてスコアを伸ばしていきたい。
あと１週間あるのでゆっくり考えていきます。

Pythonで点数をとりたい。北大・日立新概念コンピューティングコンテスト2018

ソースコード

これから