Aidemy Premium Planを受講して（振り返り）

###はじめに

Aidemy Premium Planを受講してできるようになったことを紹介したいと思います。
プログラミングに関心を持ち始めた方の参考になればと思い、ブログを書きました。
全くの初心者がどのくらいできるようになるのかの参考になれば嬉しいです。

ただ、実際のコードを書いたことがない方には、自分の書いたコードの詳細を理解するのは
難しいと思うので、始めようと思っている方はこういうこともできるのかという
なんとなくのイメージをついていただければ幸いです。

###自己紹介
自動車部品メーカーのエンジニアをしてます。
（新入社員から今の会社に勤めており入社8年目になります。）
業務では必要なかったのですが、将来的にプログラミングは必須のスキルになると考え、
Python言語での機械学習の勉強を始めました。

###プログラミングの学習経歴
2021年4月〜 ProgateでプログラミングのWeb開発を学び修了書を受領
2021年5月〜Aidemy Premium Planでデータ分析6ヶ月コースを受講しました。

###学習内容(Aidemy)
・Python入門
・Numpy基礎
・Pandas基礎
・Matplotlib基礎
・データクレンジング
・スクレイピング
・機械学習概論
・機械学習におけるデータ前処理
・教師あり学習（回帰・分類）
・教師なし学習
・自然言語処理基礎
・感情分析/株価予測
・時系列データ解析
・ディープラーニング基礎
・タイタニック(kaggleのコンペ)

###学習の振り返り
上記Aidemyの講座は2ヶ月くらいで完了させました。実際にAidemyで学んだコードをKaggleのデータを使って計算させたりすることでよりイメージをつけることができました。3ヶ月目からは、Kaggleの初心者コンペやSignateのテーブルコンペに参加して実際にデータ分析スキルを実践的に向上させることができるようになりました。まだまだ、未熟ですが、Aidemyの講座で自走できるレベルにはなれたと思います。

###Aidemy後の学習内容
経済産業省主催のAIQUEST2021に参加できましたのでこちらを学んでいきたいと思います。
こちらは機械学習の基礎を学ぶのではなく、実際にAIを企業に実装することを実践で学んで行くという講座になっております。既存製品✖️AI✖️ビジネスの視点が製造業で働く私には重要であると考えているので、ビジネス視点からのAIというところも学びたいと思い応募し、参加できました。

https://aiquest.meti.go.jp/2021/

他の方は、機械学習を用いたアートとかもされていて非常に面白そうだなと思ったので、今後こういうこともやってみたいなと思います。（最初はやってみようと思ったのですが、前処理が非常に大変で、前処理のスキルを学ぶよりは機械学習のスキルに焦点を絞って学びたいなというところでデータが揃っているKaggleのコンペに参加することをしていました。）

9月からは、AI QUEST2021で、動体検知を用いた、図面の加工形状の分類をやっています。少しずつですが画像認識についての学習も進んでいます。

また、実業務においては、下記書籍のベイズ最適化を用いた実験計画法を実装して開発業務を効率化することができました。プログラミングが扱えることになったことで、自分のできることの領域が非常に広がったと思います。本当に学んで正解だったと実感しています。

https://www.amazon.co.jp/Python%E3%81%A7%E5%AD%A6%E3%81%B6%E5%AE%9F%E9%A8%93%E8%A8%88%E7%94%BB%E6%B3%95%E5%85%A5%E9%96%80-%E3%83%99%E3%82%A4%E3%82%BA%E6%9C%80%E9%81%A9%E5%8C%96%E3%81%AB%E3%82%88%E3%82%8B%E3%83%87%E3%83%BC%E3%82%BF%E8%A7%A3%E6%9E%90-KS%E6%83%85%E5%A0%B1%E7%A7%91%E5%AD%A6%E5%B0%82%E9%96%80%E6%9B%B8-%E9%87%91%E5%AD%90-%E5%BC%98%E6%98%8C/dp/4065235308/ref=tmm_pap_swatch_0?_encoding=UTF8&qid=&sr=

###Aidemy Premium Planの講座について感想
Aidemy Premium Planは、Pythonでの機械学習のチュートリアルとして、
プログラミングをやったことがない人が初めてやるには非常に良い講座でした。
ただ、自分的には、Aidemy Premium Planは3ヶ月で十分だったかなと思います。
ゲームでもそうですがチュートリアルやってると、色々自分でやってみたいことが出てきて、
そのタイミングが自分的には3ヶ月目頃でした。
自分はコロナ下で暇があったので良かったですが、
プライベートの時間が取りにくい方は6ヶ月はあった方が良いと思います。

###環境
Kaggle Kernelsで実施しました。
Python 3.7.10


##できるようになったこと

プログラミングが全くわからないというところから、
Aidemyの講座を受講して、自走できるレベルになれたのではと思ってます。
今回は、データ分析スキルの向上のためにKaggleの初心者コンペの
「Predict Future Sales」に挑戦しましたので、その内容を紹介させてください。
(Aidemyを受講してから4ヶ月目の取り組みになります。）
あくまで、初心者が勉強してどのくらいできるようになったのかという紹介になりますので、
より良い精度を求めたいのであれば、Kaggle内のコミュニティを確認してください。

https://www.kaggle.com/c/competitive-data-science-predict-future-sales

![スクリーンショット 2021-09-01 13.06.18.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1536936/eca0fe04-76ad-6afe-0613-5ef8f048989c.png)


Kaggleとは、世界中の機械学習・データサイエンスに携わっている人が集まるコミュニティです。その中のコンペに参加し、与えられたデータから機械学習で予測モデルを作って、その精度を競い合うことで、自身のデータ分析スキルを向上させることができます。

Predict Future Salesのコンペは、Kaggleで皆が最初に挑戦するタイタニック号の生存者予測の次のレベルのテーブルコンペになります。

###結論
最初に結論書いておきます。後は、詳細になりますので、よければ見てください。
・順位は12000位中5100位くらいでまずまずでした。
・タイタニック号と違って、与えられたトレインデータを使えば良いのではなく、自分でトレインデータを作り直す必要があるのでよりデータを理解するスキルが上がったと思います。
・時系列データを扱うためデータをリークさせないで特徴量を作るスキルが上がったと思います。
・KaggleのKernelで実施したので、メモリ対策に苦労しました。この辺りも勉強になりました。

Kaggleのコンペにはこれからも参加してAIスキルを向上させたいと思います。

###詳細
まず最初にKaggleのkernelを開く前にやるべきこととして　OverviewとRulesの確認しました。

####Overview
1C Companyというロシアの会社の与えられたある期間の毎日の売り上げデータに対して、
与えられたデータから翌月の販売数を予測するコンペとなります。
（各店舗の各商品の販売数をそれぞれ予測します。）

####Evaluation
評価は、予測値と答えの誤差をRMSE(root mean squared error)で計算し、
その値が小さい方が精度が良いというコンペになります。
このRMSEは、予測値と答えの小さなズレが複数個あるより、１つの大きなずれに対して罰則が大きくなる評価になります。
また、このコンペでの注意点ですが、True target values are clipped into [0,20] rangeとさらっとかかれており、予測値は0〜20の値になります。これを忘れて計算すると当然ですが全く精度が出なくなります。
このあたりが、最初にコンペのOverviewとRuleを読めという理由の１つですね。
（最初、これを無視して計算してしまい、全然精度出ませんでした:frowning2:）

####進め方
・Simple EDA
・外れ値の処理
・Shop_idとShop_listの処理
・item_idとitem_catagoryの処理
・トレインデータの再構築と１つのテーブルデータへ統合
・簡単な特徴量作成
・ラグ特徴量の作成とTargetエンコーディング
・少し発展した特徴量の作成
・トレインデータ・テストデータ・バリデーションデータの作成
・モデルの作成
・結果に対する考察


では、データの読み込みから進めていきます。

```Python
import pandas as pd
import numpy as np
import gc
%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import seaborn as sns

# データの読み込み
item = pd.read_csv('/kaggle/input/competitive-data-science-predict-future-sales/items.csv')
sample_submission = pd.read_csv('/kaggle/input/competitive-data-science-predict-future-sales/sample_submission.csv')
item_categories = pd.read_csv('/kaggle/input/competitive-data-science-predict-future-sales/item_categories.csv')
train_df = pd.read_csv('/kaggle/input/competitive-data-science-predict-future-sales/sales_train.csv')
shop_list = pd.read_csv('/kaggle/input/competitive-data-science-predict-future-sales/shops.csv')
test_df = pd.read_csv('/kaggle/input/competitive-data-science-predict-future-sales/test.csv')
```

####Simple EDA

データを確認してみます。

```python
train_df.head()
```

OUTPUT:

```python
	date	date_block_num	shop_id	item_id	item_price	item_cnt_day
0	02.01.2013	0	59	22154	999.00	1.0
1	03.01.2013	0	25	2552	899.00	1.0
2	05.01.2013	0	25	2552	899.00	-1.0
3	06.01.2013	0	25	2554	1709.05	1.0
4	15.01.2013	0	25	2555	1099.00	1.0
```
各店の各アイテムの日々の販売数データになっています。
続いて、テストデータを見てみます。

```python
test_df.head()
```

OUTPUT:

```python
	ID	shop_id	item_id
0	0	5	5037
1	1	5	5320
2	2	5	5233
3	3	5	5232
4	4	5	5268
```

テストデータは（トレインデータの）翌月の各店の各アイテムに対する月間販売数を予測しないといけないです。

さらにデータを見てみます。

```python
fig, ax= plt.subplots(figsize=(18,4))
train_df['shop_id'].value_counts().plot(kind='bar', alpha=0.7, color=mcolors.TABLEAU_COLORS)
plt.title('Shop ID Values in Train Data')
fig, ax= plt.subplots(figsize=(18,4))
test_df['shop_id'].value_counts().plot(kind='bar', alpha=0.7, color=mcolors.TABLEAU_COLORS)
plt.title('Shop ID Values in Test Data')
```
Output:

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1536936/61784b5f-3599-1e20-a3ee-a2adb4062709.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1536936/27ea1962-6576-2197-5857-4568b5c2d766.png)
トレインデータのショップごとのアイテムのカウント数とテストデータのショップごとのアイテムのカウント数の分布が全く異なります。
ここからわかることは、テストデータは、販売があったアイテム数をカウントしているので
売れる店と売れない店でデータに隔たりがありますが、テストデータは、各店で
均一に振り分けられたアイテム数を予測をすることになっています。
なので、答えの大半が0になりそうです。


　
続いて、データを日々の販売数から、月ごとの販売数にしてデータを見てみました。
トレインデータは、0-33ヶ月で、テストデータは34ヶ月目のデータになります。

```python
sns.set()
fig, ax= plt.subplots(figsize=(18,4))
a = train_df.groupby('date_block_num').shop_id.count()
b = test_df
b['date_block_num'] = 34
c = b.groupby('date_block_num').shop_id.count()
d =  pd.concat([a,c])
d.plot(kind='bar', alpha=0.7)
plt.title('Shop ID Values in Train Data & Test Data by date_block_num')
sns.set()
fig, ax= plt.subplots(figsize=(18,4))
train_df[train_df.date_block_num == 33]['shop_id'].value_counts().sort_index().plot(kind='bar', alpha=0.7, color=mcolors.TABLEAU_COLORS)
plt.title('Shop ID Values in Train Data on the month before the target month')
sns.set()
fig, ax= plt.subplots(figsize=(18,4))
test_df['shop_id'].value_counts(sort=False).plot(kind='bar', alpha=0.7, color=mcolors.TABLEAU_COLORS)
plt.title('Shop ID Values in Train Data on the target month')
```
Output:
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1536936/ff704069-86a5-d585-dafc-cf988cf1bf35.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1536936/b89b8ccb-ec1e-b52e-4001-31469001a6f4.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1536936/fd9f1667-ff0a-4b5c-453c-39ec0e514a54.png)

一番上が、月ごとのshop_idごとのアイテム数のデータになります。真ん中は、テストデータの33ヶ月目のshop_idごとのアイテム数で、一番下は、トレインデータのshop_idごとのアイテム数になります。
明らかにテストデータ（34ヶ月目）のアイテム数が多いことがわかります。


今度は、トレインデータで月毎のトータルの販売数の推移と、テストデータの対象に絞った場合の月毎のトータル販売数の推移を見てみました。

```python
a = train_df.groupby(['shop_id', 'item_id', 'date_block_num'])['item_cnt_day'].sum().rename('item_cnt_month').reset_index()
b = a.groupby('date_block_num').item_cnt_month.sum().reset_index()
plt.figure(figsize=(18,4))
plt.xticks(np.arange(0, 34, step=1))
sns.lineplot(data=b, x='date_block_num', y='item_cnt_month')
plt.title('Trainsition of item_cnt_month in Train Data')

Leak_test_df = pd.DataFrame()
for i in range(34):
    c = test_df[['shop_id','item_id']]
    c['date_block_num'] = i
    Leak_test_df = pd.concat([Leak_test_df, c])

Leak_test_df = pd.merge(Leak_test_df, a, on=['shop_id', 'item_id', 'date_block_num'], how='left')
Leak_test_df['item_cnt_month'] = Leak_test_df['item_cnt_month'].clip(0,20)
d = Leak_test_df.groupby('date_block_num').item_cnt_month.sum().reset_index()
plt.figure(figsize=(18,4))
plt.xticks(np.arange(0, 34, step=1))
sns.lineplot(data=d, x='date_block_num', y='item_cnt_month')
plt.title('Trainsition of item_cnt_month in Test Data')
```
Output:
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1536936/fe68398a-dd4b-c566-fa97-758db24163eb.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1536936/68fc1fa9-c196-bb17-92eb-f64a34bfae39.png)

トレインデータで対象となる各月のトータル販売数の推移は、徐々に下がっているのですが、
テストデータの対象に絞った場合、各月のトータル販売数の推移は、徐々に上がっていることがわかります。
date_block_num = 11, 23は12月になるので、販売数が伸びています。
テストデータは、date_block_num = ３４の11月ですが、少なくともdate_block_num = ３3よりは大きい値になりそうです。
（DataLeakageのテクニックは今回使用しませんでしたが、テストデータの予測値の合計がdate_block_num = ３3より小さいのであれば、今回RMSEで評価されるため補正で✖️1.1などしてみれば精度上がりそうな気がします。）

続いて、トレインデータとテストデータの各アイテムのヒストグラムを確認し、差がないかを確認しました。

```python
plt.figure(figsize=(18,4))
sns.histplot(x=train_df.item_id)
plt.title('Histogram of item_id in Train Data')
plt.figure(figsize=(18,4))
a = train_df[train_df.date_block_num == 33]
plt.title('Histograms of item_id in Train Data of 33 & Test Data of 34')
sns.histplot(x=a.item_id, stat="density")
sns.histplot(x=test_df.item_id, stat="density", color='green', alpha=0.1)
```
Output:
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1536936/125ed36d-0cfb-72bc-dcaf-b57ead7e3cfa.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1536936/887e2200-9af3-ede8-4b87-9c81b9298cfa.png)

下が、直前のdata_block_num=33の際のヒストグラムとテストデータdata_block_num=34の重ね合わせのヒストグラムになりますが、大きなズレはなさそうです。

####外れ値の処置

```python
plt.figure(figsize=(18,4))
sns.boxplot(x=train_df.item_cnt_day)
plt.figure(figsize=(18,4))
sns.boxplot(x=train_df.item_price)
```
Output:
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1536936/2b566fac-a4f4-6e57-cbe8-81482cf995aa.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1536936/6f7e7c25-b636-61d4-3ebe-bbc43d2fc145.png)

```python
train_df = train_df[train_df.item_price <=100000]
train_df = train_df[train_df.item_cnt_day < 1000]
```
外れ値を削除しました。後でアイテムリストから確認しましたが、販売数の外れ値は、ビニール袋の数で、価格の外れ値は、数十人にソフトウェアを導入した額が１つに計上されていた気がします。

Shops Dataの処理

```python
a = train_df['shop_id'].nunique()
b = test_df['shop_id'].nunique()
print('Shops in Train data: ', a)
print('Shops in Test data: ', b)
```
Output:

```python
Shops in Train data:  60
Shops in Test data:  42
```

ショップ名を見ていきます。

```python
shop_list.T
```
Output:
 
```python
shop_name	shop_id
0	!Якутск Орджоникидзе, 56 фран	0
1	!Якутск ТЦ "Центральный" фран	1
2	Адыгея ТЦ "Мега"	2
3	Балашиха ТРК "Октябрь-Киномир"	3
4	Волжский ТЦ "Волга Молл"	4
5	Вологда ТРЦ "Мармелад"	5
6	Воронеж (Плехановская, 13)	6
7	Воронеж ТРЦ "Максимир"	7
8	Воронеж ТРЦ Сити-Парк "Град"	8
9	Выездная Торговля	9
10	Жуковский ул. Чкалова 39м?	10
11	Жуковский ул. Чкалова 39м²	11
12	Интернет-магазин ЧС	12
13	Казань ТЦ "Бехетле"	13
14	Казань ТЦ "ПаркХаус" II	14
15	Калуга ТРЦ "XXI век"	15
16	Коломна ТЦ "Рио"	16
17	Красноярск ТЦ "Взлетка Плаза"	17
18	Красноярск ТЦ "Июнь"	18
19	Курск ТЦ "Пушкинский"	19
20	Москва "Распродажа"	20
21	Москва МТРЦ "Афи Молл"	21
22	Москва Магазин С21	22
23	Москва ТК "Буденовский" (пав.А2)	23
24	Москва ТК "Буденовский" (пав.К7)	24
25	Москва ТРК "Атриум"	25
26	Москва ТЦ "Ареал" (Беляево)	26
27	Москва ТЦ "МЕГА Белая Дача II"	27
28	Москва ТЦ "МЕГА Теплый Стан" II	28
29	Москва ТЦ "Новый век" (Новокосино)	29
30	Москва ТЦ "Перловский"	30
31	Москва ТЦ "Семеновский"	31
32	Москва ТЦ "Серебряный Дом"	32
33	Мытищи ТРК "XL-3"	33
34	Н.Новгород ТРЦ "РИО"	34
35	Н.Новгород ТРЦ "Фантастика"	35
36	Новосибирск ТРЦ "Галерея Новосибирск"	36
37	Новосибирск ТЦ "Мега"	37
38	Омск ТЦ "Мега"	38
39	РостовНаДону ТРК "Мегацентр Горизонт"	39
40	РостовНаДону ТРК "Мегацентр Горизонт" Островной	40
41	РостовНаДону ТЦ "Мега"	41
42	СПб ТК "Невский Центр"	42
43	СПб ТК "Сенная"	43
44	Самара ТЦ "Мелодия"	44
45	Самара ТЦ "ПаркХаус"	45
46	Сергиев Посад ТЦ "7Я"	46
47	Сургут ТРЦ "Сити Молл"	47
48	Томск ТРЦ "Изумрудный Город"	48
49	Тюмень ТРЦ "Кристалл"	49
50	Тюмень ТЦ "Гудвин"	50
51	Тюмень ТЦ "Зеленый Берег"	51
52	Уфа ТК "Центральный"	52
53	Уфа ТЦ "Семья" 2	53
54	Химки ТЦ "Мега"	54
55	Цифровой склад 1С-Онлайн	55
56	Чехов ТРЦ "Карнавал"	56
57	Якутск Орджоникидзе, 56	57
58	Якутск ТЦ "Центральный"	58
59	Ярославль ТЦ "Альтаир"

```
まず、最初の単語「Адыгея」は都市名を表記していました。
よくみるとショップ名の誤表記で分かれている番号があるので、統一します。

```python
train_df.loc[train_df['shop_id'] == 0, 'shop_id'] = 57
test_df.loc[test_df['shop_id'] == 0, 'shop_id'] = 57
train_df.loc[train_df['shop_id'] == 1, 'shop_id'] = 58
test_df.loc[test_df['shop_id'] == 1, 'shop_id'] = 58
train_df.loc[train_df['shop_id'] == 10, 'shop_id'] = 11
test_df.loc[test_df['shop_id'] == 10, 'shop_id'] = 11
train_df.loc[train_df['shop_id'] == 40, 'shop_id'] = 39
test_df.loc[test_df['shop_id'] == 40, 'shop_id'] = 39
```

ショップ名から都市を割り出し、各都市の座標と州を設定しました。

```python
from sklearn.preprocessing import LabelEncoder
# extract and encode cities
shop_list['city'] = shop_list['shop_name'].apply(lambda x: x.split()[0].lower())
shop_list.loc[shop_list.city == '!якутск', 'city'] = 'якутск'
shop_list['city_id'] = LabelEncoder().fit_transform(shop_list['city'])
# add coordinates of cities
coords = dict()
coords['якутск'] = (62.028098, 129.732555, 4)
coords['адыгея'] = (44.609764, 40.100516, 3)
coords['балашиха'] = (55.8094500, 37.9580600, 1)
coords['волжский'] = (53.4305800, 50.1190000, 3)
coords['вологда'] = (59.2239000, 39.8839800, 2)
coords['воронеж'] = (51.6720400, 39.1843000, 3)
coords['выездная'] = (0, 0, 0)
coords['жуковский'] = (55.5952800, 38.1202800, 1)
coords['интернет-магазин'] = (0, 0, 0)
coords['казань'] = (55.7887400, 49.1221400, 4)
coords['калуга'] = (54.5293000, 36.2754200, 4)
coords['коломна'] = (55.0794400, 38.7783300, 4)
coords['красноярск'] = (56.0183900, 92.8671700, 4)
coords['курск'] = (51.7373300, 36.1873500, 3)
coords['москва'] = (55.7522200, 37.6155600, 1)
coords['мытищи'] = (55.9116300, 37.7307600, 1)
coords['н.новгород'] = (56.3286700, 44.0020500, 4)
coords['новосибирск'] = (55.0415000, 82.9346000, 4)
coords['омск'] = (54.9924400, 73.3685900, 4)
coords['ростовнадону'] = (47.2313500, 39.7232800, 3)
coords['спб'] = (59.9386300, 30.3141300, 2)
coords['самара'] = (53.2000700, 50.1500000, 4)
coords['сергиев'] = (56.3000000, 38.1333300, 4)
coords['сургут'] = (61.2500000, 73.4166700, 4)
coords['томск'] = (56.4977100, 84.9743700, 4)
coords['тюмень'] = (57.1522200, 65.5272200, 4)
coords['уфа'] = (54.7430600, 55.9677900, 4)
coords['химки'] = (55.8970400, 37.4296900, 1)
coords['цифровой'] = (0, 0, 0)
coords['чехов'] = (55.1477000, 37.4772800, 4)
coords['ярославль'] = (57.6298700, 39.8736800, 2) 

shop_list['city_coord_1'] = shop_list['city'].apply(lambda x: coords[x][0])
shop_list['city_coord_2'] = shop_list['city'].apply(lambda x: coords[x][1])
shop_list['country_part'] = shop_list['city'].apply(lambda x: coords[x][2])

shop_list = shop_list[['shop_id', 'city_id', 'city_coord_1', 'city_coord_2', 'country_part']]
```
####item_idとitem_catagoryの処理
続いて、商品（item)を処理していきます。

```python
item.head()
```
Output:

```python
	item_name	item_id	item_category_id
0	! ВО ВЛАСТИ НАВАЖДЕНИЯ (ПЛАСТ.) D	0	40
1	!ABBYY FineReader 12 Professional Edition Full...	1	76
2	***В ЛУЧАХ СЛАВЫ (UNV) D	2	40
3	***ГОЛУБАЯ ВОЛНА (Univ) D	3	40
4	***КОРОБКА (СТЕКЛО) D	4	
```

```python
item.info()
```
Output:

```python
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 22170 entries, 0 to 22169
Data columns (total 3 columns):
 #   Column            Non-Null Count  Dtype 
---  ------            --------------  ----- 
 0   item_name         22170 non-null  object
 1   item_id           22170 non-null  int64 
 2   item_category_id  22170 non-null  int64 
dtypes: int64(2), object(1)
memory usage: 519.7+ KB
```
商品名に関しては、共通項を検討することが難しそうでしたので、今回は排除しました。

```python
item = item.drop('item_name', axis=1)
```
続いて商品カテゴリー処理します。

```python
item_categories.head()
```

商品カテゴリーに関しては、共通点が多く見られました。
例えば、「Аксессуары」はアクセサリーで、付属品を示しています。

```python
	item_category_name	item_category_id
0	PC - Гарнитуры/Наушники	0
1	Аксессуары - PS2	1
2	Аксессуары - PS3	2
3	Аксессуары - PS4	3
4	Аксессуары - PSP	4
```
そこで、共通点に関するところでグルーピングしていきました。

```python
item_categories['item_major_category_id'] = item_categories['item_category_name'].str.split(' ').map(lambda x: x[0])
```

```python
from sklearn import preprocessing
le = preprocessing.LabelEncoder()
item_categories['item_major_category_id'] = le.fit_transform(item_categories['item_major_category_id'])
item_categories['item_sub_category_id'] = item_categories['item_category_name'].str.split('-').map(lambda x: x[1] if len(x) > 1 else x[0] )
item_categories['item_sub_category_id'] = le.fit_transform(item_categories['item_sub_category_id'])
item_categories = item_categories.drop('item_category_name', axis=1)
```

####トレインデータの再構築と１つのテーブルデータへ統合

まず、今あるトレインデータを加工せずに機械学習させ、提出しましたが、精度は低かったです。
これは、今回のトレインデータは販売されたものだけがカウントされているので、
販売されなかった際の0のデータがトレインデータに入っていないことが原因だと推測しました。
（テストデータも多くが0の値になりそうですし、）
そこで、トレインデータの再構築を行いました。


```python
# Pattern 1
new_train_df_ver3 = pd.DataFrame()
for i in range(35):
    c = test_df[['shop_id','item_id']]
    c['date_block_num'] = i
    new_train_df_ver3 = pd.concat([Leak_test_df, c])
del new_train_df_ver3
gc.collect()
```
パターン１では、テストデータの対象のshop_idとitem_idの組み合わせに注目して
トレインデータを再構築しました。
精度はある程度上がりましたが、そこまで良い結果は得られませんでした。

```python
# Pattern 2
from itertools import product
index_cols_ver2 = ['shop_id', 'item_id']
a = []
cur_shops = train_df['shop_id'].unique()
cur_items = train_df['item_id'].unique()
a.append(np.array(list(product(*[cur_shops, cur_items])),dtype='int32'))
a = pd.DataFrame(np.vstack(a), columns = index_cols_ver2,dtype=np.int32)
new_train_df_ver2 = pd.DataFrame()
for block_num in range(34):
    a['date_block_num'] = block_num
    new_train_df_ver2 = pd.concat([new_train_df_ver2, a])
new_train_df_ver2['shop_id'] = new_train_df_ver2['shop_id'].astype('int8')
new_train_df_ver2['date_block_num'] = new_train_df_ver2['date_block_num'].astype('int8')
new_train_df_ver2.info()
del new_train_df_ver2
gc.collect()
```
パターン2では、トレインデータにある全てのshop_idとitem_idの組み合わせを作り、
それが３５ヶ月間(0-34)あると考え、計算しようしました。
これは、データ数があまりにも大きくなってしまい、kaggleのKernelではメモリ不足になってしまったので、今回は諦めました。

```python
# Pattern 3
from itertools import product
index_cols = ['shop_id', 'item_id', 'date_block_num']
new_train_df = []
for block_num in train_df['date_block_num'].unique():
    cur_shops = train_df.loc[train_df['date_block_num'] == block_num, 'shop_id'].unique()
    cur_items = train_df.loc[train_df['date_block_num'] == block_num, 'item_id'].unique()
    new_train_df.append(np.array(list(product(*[cur_shops, cur_items, [block_num]])),dtype='int32'))
new_train_df = pd.DataFrame(np.vstack(new_train_df), columns = index_cols,dtype=np.int32)
```

パターン3で進めました。パターン3では、トレインデータの各月ごとで存在するshop_idとitem_idの組み合わせを全て考慮しました。

ここからは、再構築したトレインデータに、テストデータやitemsやitem_categoriesやshop_listのデータを結合させ、特徴量を作っていきました。

```python
test_df['date_block_num'] = 34
test_df1 = test_df.drop('ID', axis=1)
all_data = pd.concat([new_train_df, test_df1])
a = train_df.groupby(['shop_id', 'item_id', 'date_block_num'])['item_cnt_day'].sum().rename('item_cnt_month').reset_index()
all_data = pd.merge(all_data, a, on=['shop_id','item_id','date_block_num'], how='left')
all_data.fillna(0, inplace=True)
all_data = pd.merge(all_data, item, on='item_id', how='left')
all_data = pd.merge(all_data, item_categories, on='item_category_id', how='left')
all_data = pd.merge(all_data, shop_list, on='shop_id', how='left')
all_data['month'] = all_data['date_block_num'] % 12
days = pd.Series([31,28,31,30,31,30,31,31,30,31,30,31])
all_data['days'] = all_data['month'].map(days)
all_data = all_data.astype('int16')
all_data['item_cnt_month'] = all_data['item_cnt_month'].clip(0,20)
```

```python
del item
del item_categories
del shop_list
gc.collect()
```
####簡単な特徴量作成

まず、簡単な特徴量を作ってました。
2年目以降の12月前後の月では販売数が増えるので、それを考慮した特徴量を入れてみました。
後は、年数を特徴量にしてみました。

```python
all_data['sales_season'] = 0
all_data.loc[all_data.date_block_num  == 22, 'sales_season'] = 1
all_data.loc[all_data.date_block_num == 23, 'sales_season'] = 1
all_data.loc[all_data.date_block_num == 24, 'sales_season'] = 1
all_data.loc[all_data.date_block_num == 34, 'sales_season'] = 1
all_data['sales_season'] = all_data['sales_season'].astype('int8')
all_data['year'] = 14
all_data.loc[all_data.date_block_num / 12 < 1, 'year'] = 13
all_data.loc[all_data.date_block_num / 12 >=2, 'year'] = 15
all_data['year'] = all_data['year'].astype('int8')
```
####ラグ特徴量の作成とTargetエンコーディング

続いて時系列データでよく使うLag featureというテクニックを使いました。


```python
def lag_features(data, months, lag_column):
    for month in months:
        data_shift = data[['date_block_num', 'shop_id', 'item_id', lag_column]].copy()
        data_shift.columns = ['date_block_num', 'shop_id', 'item_id', lag_column+'_lag_'+ str(month)]
        data_shift['date_block_num'] += month
        data = pd.merge(data, data_shift, on=['date_block_num', 'shop_id', 'item_id'], how='left')
    return data
```

```python
all_data = lag_features(all_data, [1,2,3], 'item_cnt_month')
```

カテゴリカルデータをtarget encodingで色々特徴量を作っていきました。
また、データリークの対策としてLag featureでのtarget eoncodingを行いました。

```python
a = all_data.groupby(['date_block_num']).item_cnt_month.sum().astype('int32').rename('total_cnt_month').reset_index()
all_data = pd.merge(all_data, a, on=['date_block_num'], how='left')
all_data = lag_features(all_data, [1, 2, 3], 'total_cnt_month')
all_data.drop('total_cnt_month', axis=1, inplace=True)
```

```python
a = train_df.groupby(['shop_id', 'item_id', 'date_block_num']).item_price.mean().rename('mean_shop_price').reset_index()
all_data = pd.merge(all_data, a, on=['shop_id', 'item_id', 'date_block_num'], how='left')
all_data['mean_shop_price'] = all_data['mean_shop_price'].fillna(0).astype('float16')
```

```python
a = train_df.groupby(['item_id', 'date_block_num']).item_price.mean().rename('mean_item_price').reset_index()
all_data = pd.merge(all_data, a, on=['item_id', 'date_block_num'], how='left')
all_data['mean_item_price'] = all_data['mean_item_price'].fillna(0).astype('float16')
all_data['item_shop_price_mean'] = (all_data['mean_shop_price'] - all_data['mean_item_price']) / all_data['mean_item_price']
all_data['item_shop_price_mean'].fillna(0, inplace=True)
all_data = lag_features(all_data, [1, 2, 3], 'item_shop_price_mean')
all_data.drop(['mean_shop_price', 'mean_item_price', 'item_shop_price_mean'], axis=1, inplace=True)
```


```python
a = all_data.groupby(['date_block_num', 'item_id', 'city_id'])['item_cnt_month'].mean().astype('float16').rename('item_city_month_mean').reset_index()
all_data = pd.merge(all_data, a, on=['date_block_num', 'item_id', 'city_id'], how='left')
all_data = lag_features(all_data,[1,2,3], 'item_city_month_mean')
all_data.drop(['item_city_month_mean'], axis=1, inplace=True)
```

```python
a = all_data.groupby(['date_block_num','item_id', 'shop_id'])['item_cnt_month'].mean().rename('item_shop_mean').reset_index()
all_data = pd.merge(all_data, a, on=['date_block_num','item_id', 'shop_id'], how='left')
all_data['item_shop_mean'] = all_data['item_shop_mean'].fillna(0).astype('float16')
all_data = lag_features(all_data, [1, 2, 3], 'item_shop_mean')
all_data.drop(['item_shop_mean'], axis=1, inplace=True)
```

```python
all_data = all_data.fillna(0)
```
####少し発展した特徴量の作成
新たな特徴量として、そのitem_idが初めて販売された月かどうかを特徴量とし、また商品がそれまで売られていたかどうかを特徴量としました。また、それを元にラグ特徴量としました。

```python
first_item_block = train_df.groupby(['item_id'])['date_block_num'].min().reset_index()
first_item_block['item_first_interaction'] = 1
first_shop_item_buy_block = train_df.groupby(['shop_id', 'item_id'])['date_block_num'].min().reset_index()
first_shop_item_buy_block['first_date_block_num'] = first_shop_item_buy_block['date_block_num']
all_data = pd.merge(all_data, first_item_block[['item_id', 'date_block_num', 'item_first_interaction']], on=['item_id', 'date_block_num'], how='left')
all_data = pd.merge(all_data, first_shop_item_buy_block[['item_id', 'shop_id', 'first_date_block_num']], on=['item_id', 'shop_id'], how='left')
all_data['first_date_block_num'].fillna(100, inplace=True)
all_data['shop_item_sold_before'] = (all_data['first_date_block_num'] < all_data['date_block_num']).astype('int8')
all_data.drop(['first_date_block_num'], axis=1, inplace=True)
all_data['item_first_interaction'].fillna(0, inplace=True)
all_data['shop_item_sold_before'].fillna(0, inplace=True)
```

```
a = all_data[all_data['item_first_interaction'] == 1].groupby(['date_block_num','item_category_id','shop_id'])['item_cnt_month'].mean().rename("new_item_shop_cat_mean").reset_index()
all_data = pd.merge(all_data, a, on=['date_block_num','item_category_id', 'shop_id'], how='left')
all_data['new_item_shop_cat_mean'] = all_data['new_item_shop_cat_mean'].fillna(0).astype('float16')
all_data = lag_features(all_data, [1, 2, 3], 'new_item_shop_cat_mean')
all_data.drop(['new_item_shop_cat_mean'], axis=1, inplace=True)
```

特徴量を作成が完了したので、データを確認しました。

```python
all_data.info()
```
Output:

```python
<class 'pandas.core.frame.DataFrame'>
Int64Index: 11056277 entries, 0 to 11056276
Data columns (total 35 columns):
 #   Column                        Dtype  
---  ------                        -----  
 0   shop_id                       int16  
 1   item_id                       int16  
 2   date_block_num                int16  
 3   item_cnt_month                int16  
 4   item_category_id              int16  
 5   item_major_category_id        int16  
 6   item_sub_category_id          int16  
 7   city_id                       int16  
 8   city_coord_1                  int16  
 9   city_coord_2                  int16  
 10  country_part                  int16  
 11  month                         int16  
 12  days                          int16  
 13  sales_season                  int8   
 14  year                          int8   
 15  item_cnt_month_lag_1          float64
 16  item_cnt_month_lag_2          float64
 17  item_cnt_month_lag_3          float64
 18  total_cnt_month_lag_1         float64
 19  total_cnt_month_lag_2         float64
 20  total_cnt_month_lag_3         float64
 21  item_shop_price_mean_lag_1    float16
 22  item_shop_price_mean_lag_2    float16
 23  item_shop_price_mean_lag_3    float16
 24  item_city_month_mean_lag_1    float16
 25  item_city_month_mean_lag_2    float16
 26  item_city_month_mean_lag_3    float16
 27  item_shop_mean_lag_1          float16
 28  item_shop_mean_lag_2          float16
 29  item_shop_mean_lag_3          float16
 30  item_first_interaction        float64
 31  shop_item_sold_before         int8   
 32  new_item_shop_cat_mean_lag_1  float16
 33  new_item_shop_cat_mean_lag_2  float16
 34  new_item_shop_cat_mean_lag_3  float16
dtypes: float16(12), float64(7), int16(13), int8(3)
memory usage: 1.2 GB
```
一部float64だったりするので、メモリ削減しました。

```python
all_data = all_data.fillna(0)
# Memory reduction
all_data['item_first_interaction'] = all_data['item_first_interaction'].astype('int8')
all_data.iloc[:, 15:21] = all_data.iloc[:, 15:21].astype('int32')

del train_df
del test_df
gc.collect()
```

####トレイン・テスト・バリデーションデータの作成
トレインデータとテストデータを再び分けます。

```python
test = all_data[all_data.date_block_num == 34]
test = test.drop('item_cnt_month', axis=1)
new_train_df = all_data[all_data.date_block_num < 34]
```

lag featureを行いましたが、最初の3ヶ月間(date_block_num = 0 ~ 2)の lag　featureが０になっているので、トレインデータから省きました。

```python
From_Month = 3
new_train_df = new_train_df[new_train_df.date_block_num >= From_Month]
train = new_train_df.drop('item_cnt_month', axis=1)
y_train = new_train_df['item_cnt_month']
```

Validationとは、date_block_num = 33のデータとしました。

```python
To_Month = 33
tr_X = train[train.date_block_num < To_Month]
val_X = train[train.date_block_num >= To_Month]
ntr_X = tr_X.shape[0]
tr_Y = y_train[:ntr_X]
val_Y = y_train[ntr_X:]
```

```python
del all_data
del train
gc.collect()
```
####モデルの作成

勾配ブースティング木手法であるlightGBMを使用しました。
また、メトリックは、今回の評価と同じrmseを使用しました。
ここには記載しませんが、一応、ハイパーパラメータはOptunaを使用して最適化しました。
（どのパラメータが過学習するのか、どのパラメータが汎用化するのかはわかるのですが、
未だ、どの程度の値が経験的に妥当かはわかっていないです。:frowning2:）

```python
import lightgbm as lgb
#import optuna.integration.lightgbm as lgb
from sklearn.metrics import r2_score, mean_squared_error

lgb_train =lgb.Dataset(tr_X, tr_Y)
lgb_eval = lgb.Dataset(val_X, val_Y)

params = {'bagging_fraction': 1.0,
 'bagging_freq': 0,
 'boosting_type': 'gbdt',
 'feature_fraction': 0.48000000000000004,
 'feature_pre_filter': False,
 'lambda_l1': 9.870317725539854,
 'lambda_l2': 3.75055716395215e-07,
 'metric': 'rmse',
 'min_child_samples': 20,
 'num_leaves': 216,
 'objective': 'rmse',
 'learning_rate':0.005,
 'seed': 57}

num_round = 1000

categorical_features = ['shop_id', 'item_id','city_id', 'item_category_id', 'item_major_category_id', 'item_sub_category_id',
                        'country_part', 'sales_season', 'item_first_interaction', 'shop_item_sold_before']


model1 = lgb.train(params, lgb_train, num_boost_round=num_round,
                   categorical_feature = categorical_features,
                  valid_names=['train', 'valid'], valid_sets=[lgb_train,lgb_eval], early_stopping_rounds =30)

va_pred = model1.predict(val_X)
score = np.sqrt(mean_squared_error(val_Y, va_pred))
print(score)
```

```python
Early stopping, best iteration is:
[647]	train's rmse: 0.754511	valid's rmse: 0.917492
0.9174921913985981
```

そして、提出しました。

```python
sample_submission = pd.read_csv('/kaggle/input/competitive-data-science-predict-future-sales/sample_submission.csv')
LGBMpred = model1.predict(test)
LGBMpred = LGBMpred.clip(0, 20).astype('float32')
sample_submission['item_cnt_month'] = LGBMpred
sample_submission.to_csv('submission_a.csv', index=False)
```
せっかくなので、線形だったり、ニューラルネットワークも試してみました。
時系列データということもあり、アンサンブルは、簡単な加重平均で検討しました。


```python
del model1
gc.collect()
```

線形モデルでは、標準化が必要になるので、標準化しました。


```python
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
tr_X = scaler.fit_transform(tr_X)
val_X = scaler.transform(val_X)
test_X = scaler.transform(test)
```

```python
del scaler
gc.collect()
```
ラッソ回帰を用いて計算しました。

```python
from sklearn import linear_model
reg = linear_model.Lasso(alpha=0.1)
reg.fit(tr_X, tr_Y)
reg_pred = reg.predict(test)
va_pred = reg.predict(val_X)
score2 = np.sqrt(mean_squared_error(val_Y, va_pred))
print(f'rsme: {score2:.4f}')
```
Output:

```python
rsme: 0.9844
```

LightGBMより精度悪そうですね。

```python
reg_pred = reg_pred.clip(0,20).astype('float32')
```

```python
del reg
gc.collect()
```
続いてニューラルネットワークも使ってみました。

```python
from keras.layers import Dense, Dropout
from keras.models import Sequential
from sklearn.metrics import mean_squared_error

model2 = Sequential()
model2.add(Dense(256, activation='relu', input_shape=(tr_X.shape[1],)))
model2.add(Dropout(0.2))
model2.add(Dense(256, activation='relu'))
model2.add(Dropout(0.2))
model2.add(Dense(1))
model2.compile(loss='mse', optimizer='adam', metrics=['mean_squared_error'])
model2.summary()

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
callbacks = [
    EarlyStopping(patience=5, verbose=1),
    ReduceLROnPlateau(factor=0.25, patience=2, min_lr=0.000001, verbose=1),
    ModelCheckpoint('model.h5', verbose=1, save_best_only=True, save_weights_only=True)
]

model2.fit(tr_X, tr_Y, epochs=15, callbacks=callbacks, validation_data=(val_X, val_Y))

NN_predict = model2.predict(test)
va_pred = model2.predict(val_X)
score2 = np.sqrt(mean_squared_error(val_Y, va_pred))
print(f'rsme: {score2:.4f}')
```

```python
Epoch 00011: val_loss did not improve from 0.88227
Epoch 00011: early stopping
rsme: 0.9408
```

Lightgbmより精度は下がりそうです。

```python
NN_predict = NN_predict.clip(0,20).astype('float32')
NN_predict = NN_predict.ravel()
```

```python
del model2
gc.collect()
```
精度は下がりそうですが、せっかくなので最後までアンサンブルをやってみました。

```python
Ensemble = LGBMpred*0.8 
Ensemble += NN_predict*0.1
Ensemble += reg_pred*0.1
sample_submission['item_cnt_month'] = Ensemble.clip(0, 20)
sample_submission.to_csv('submission_b.csv', index=False)
```

実際、Lightgbm単体の方が精度が良かったです。
順位は、12000人中5100人くらいになりました。
まずまずの結果を出すことができました。

####結果に対する考察

とりあえずでアンサンブルしてみたのですが、よくよくデータをみると恥ずかしながらニューラルネットワークのモデルが過学習していて、全く精度が出ないモデルになってました。

```python
sample_submission['LGBMpred'] = LGBMpred
sample_submission['NN_pred'] = NN_pred
sample_submission['reg_pred'] = reg_pred
sample_submission.head()
```
Output:

```python
	ID	item_cnt_month	LGBMpred	NN_pred	reg_pred
0	0	0.885253	0.885253	0.173717	0.590238
1	1	0.074132	0.074132	0.030672	0.296229
2	2	1.401056	1.401056	0.173717	1.160684
3	3	0.200387	0.200387	0.173717	0.365134
4	4	0.899215	0.899215	0.031228	0.296229
```

グラフもするとこんな感じでした。

```python
plt.figure(figsize=(18,8))
plt.scatter(sample_submission.ID, sample_submission.LGBMpred, s=10, c='b', marker='.', alpha=0.5)
plt.scatter(sample_submission.ID, sample_submission.reg_pred, s=10, c='r', marker='.', alpha=0.5)
plt.scatter(sample_submission.ID, sample_submission.NN_pred, s=10, c='yellow', marker='.', alpha=0.5)
```
Output:

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1536936/832fc3e7-6539-532e-8491-f896d3b290e3.png)


ニューラルネットワークで計算したモデルが0に収束していました。なので、意味のない予測モデルになっていました。
また、後々考えたのですが、仮にこのニューラルネットワークの予測モデルがある程度精度が出ていたとしても、赤と青のプロットを見ると、加重平均のアンサンブルでは上手く行かないと思われます。
そう考えるに至った例を示します。

```python
# 加重平均アンサンブルの例
a = pd.DataFrame()
a['x'] = np.arange(0, 101, 1)
a['y_1'] = a['x'] + np.random.rand(101) * 40 + 5
a['y_2'] = a['x'] + np.random.rand(101) * 40 + 5
a['y_3'] = a['x'] + np.random.rand(101) * 40 + 5
a['y_4'] = (a['y_1'] + a['y_2'] + a['y_3']) / 3
plt.figure()
plt.scatter(a.x, a.y_1, color='b', marker='.')
plt.scatter(a.x, a.y_2, color='b', marker='.', alpha=0.6)
plt.scatter(a.x, a.y_3, color='b', marker='.', alpha=0.3)
plt.scatter(a.x, a.y_4, color='r', marker='.')
plt.xlabel('x')
plt.ylabel('y')
````
Output:

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1536936/c83e67bf-5993-6ac1-901a-1953b5a9a8c5.png)

赤のプロットが3つのプロットの平均の値を示してますが、平均化することで、予測モデルのばらつきを抑制することが可能になります。しかし、今回の予測は、各予測値の振れが大きく、正解のフレ(0-20)も大きくなると思われるので、目的のない機械学習同士のモデルのアンサンブルではあまり効果が期待できないと思われます。

そのため、今後の改良としては、アンサンブルは、特定の目的をもったモデルの組み合わせで検討したほうが良いと考えてます。例えば、売り上げ数が0かそうでないかの分類を行なって、0でない場合は、上記LightGBMを用いて予測するといったアンサンブルの方が精度が上がると思われるので試してみたいです。

そして、このコンペは、特徴量の生成が重要になると思うので、さらなる特徴量の追加も行っていきたいと思います。
特に、周期的な動きがあるので、移動平均を用いた特徴量の作成を検討したいです。
また、商品名の検討でfuzzywuzzyを検討されている方がいて、これも試してみたいです。

参考文献
１）kaggleで勝つデータ分析の技術
２）https://www.kaggle.com/dlarionov/feature-engineering-xgboost