tkherox blog

データサイエンスおよびソフトウェアについての話を書いています

matplotlibの文字化け解決の最適解『japanize-matplotlib』

matplotlibの文字化け

データ分析を行なっている方であれば当然EDA(探索的データ分析)のフェーズで自身が扱っているデータを理解することに努めると思います.このプロセスを丁寧に行うことで「扱っているデータがどのような情報を持ってるのか」,「データ分布がどのような形状になっているか」,「欠損値がどれくらい含まれているのか」などを把握することができます.

そして,分析者は理解したデータ内容を第3者にレポーティングするという責任を負っており,分かりやすく伝えるために データ可視化 を自在に使いこなすことがが非常に重要となってきます.

その可視化の際に頻繁に出くわす問題が Matplotlib を用いた可視化における文字化けです.データにマルチバイト文字を含まずとも,聴衆に合わせて仕方なく日本語でラベルを付与してグラフを可視化することによって文字化けが生じるなんてことも往々にしてあります.個人的には英語表記で可視化すれば済む話だと思うのですが,伝わりやすさという観点では日本語を利用した方が良い場合もあります. そこで,今回はこの Matplotlib を用いた可視化におけるマルチバイト文字に対する対処法について記載します.

ちなみに余談にはなりますが,データ可視化では以下のサイトが便利でよく参考にさせてもらっています.可視化パターンとPythonでの実装方法がセットになっているため効率的な可視化ライフを送ることができます.是非活用してみてください.

python-graph-gallery.com

また,以下の記事ではケース別でどの可視化を選択するべきかをわかりやすくまとめてくれています.こちらも非常に役立つので適宜活用していくことをお勧めします.

qiita.com

対処法

少し話がそれましたが,ここからは本題の Matpliotlib におけるマルチバイト文字の文字化けへの対処法についてです.

具体的には以下の対処法があります.

  1. スクリプト実行時にフォントを指定する
  2. matplotlibrcの設定ファイルでフォントを変更する
  3. japanize-matplotlibを利用する

個人的にマルチバイト文字をコストをかけずに文字化けすることなく可視化する方法としては 3番目のjapanize-matplotlibが有効 だと思います.そのため,以降ではjapanize-matplotlibの使い方について説明していきます.
1番目と2番目の対応を知りたいという方は以下のサイトが詳しく記載していますのでそちらを参照してみてください.

qiita.com

japanize-matplotlib

japanize-matplotlibとは Matplotlib を日本語表示に対応させるためのPythonライブラリです.

github.com

importと同時に IPAexGothic のフォントを自動で追加して,追加したフォントを利用する設定処理を適応することで日本語が文字化けしないようにしています.
また,Matplotlibのバージョンが 3.2 以上の場合は createFontList メソッドが非推奨になったため,createFontListを利用すると警告が表示されるようになりました.そのため,japanize-matplotlibでも内部で createFontList を利用していることから警告が表示されるようになっていましたが,こちらは2020年5月にソースコードが以下のように修正されて警告が出力されないように対応されています.

is_support_createFontList = LooseVersion(matplotlib.__version__) < '3.2'
if is_support_createFontList:
    font_list = font_manager.createFontList(font_files)
    font_manager.fontManager.ttflist.extend(font_list)
else:
    for fpath in font_files:
        font_manager.fontManager.addfont(fpath)
matplotlib.rc('font', family=FONT_NAME)

次からはインストールと利用方法について記載していきます.
実行環境は以下となっています.

$ sw_vers
ProductName:    Mac OS X
ProductVersion: 10.14.6
BuildVersion:   18G6042

$ python -V
Python 3.6.9

インストールはpipにて実施できます.

$ pip install japanize-matplotlib

続いてjapanize-matplotlibの利用方法です.
まず,通常の Matplotlib でマルチバイト文字を出力した場合のグラフを確認してみましょう.scikit-learnに含まれるワイン成分に関するデータについて,アルコール度数とりんご酸の関係を散布図で出力してみます.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_wine

data = load_wine()
df = pd.DataFrame(data.data, columns=data.feature_names)

# Visualization
fig, ax = plt.subplots(figsize=(12, 8))
plt.scatter(df.alcohol, df.malic_acid, cmap="Blues", alpha=0.8, edgecolors="grey", linewidth=2)
 plt.xlabel("アルコール")
plt.ylabel("リンゴ酸")
plt.title("2属性間の散布図")
plt.show()

上記ソースコードを実行すると以下のようなグラフが可視化されるはずです.しっかり文字化けしていますね.

f:id:takaherox:20210130174236p:plain

次にjapanize-matplotlibを利用して同じ要領で可視化を行ってみます. 利用方法は Matplotlib をインポートした後に japanize_matplotlib をインポートするだけです.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import japanize_matplotlib
from sklearn.datasets import load_wine

data = load_wine()
df = pd.DataFrame(data.data, columns=data.feature_names)

# visualization
fig, ax = plt.subplots(figsize=(12, 8))
plt.scatter(df.alcohol, df.malic_acid, cmap="Blues", alpha=0.8, edgecolors="grey", linewidth=2)
plt.xlabel("アルコール")
plt.ylabel("リンゴ酸")
plt.title("2属性間の散布図")
plt.show()

文字化けしていたマルチバイト文字がちゃんと表示されていますね.
このように簡単に文字化けを修正することができるので是非活用してみることをお勧めします.

f:id:takaherox:20210130174243p:plain

まとめ

今回は Matpliotlib におけるマルチバイト文字利用おける対応を「japanize-matplotlib」を中心にまとめてみました.
以前は私もフォントの設定を変更して文字化け対応をしていたのですが,japanize-matplotlibに出会ってからはこちらを利用させてもらっています.毎回スクリプトで処理を記述するのも,設定ファイルを作成する手間も省けるので是非活用してみてください.

令和2年秋季応用情報技術者試験の受験結果は...

経緯

過去の記事で「応用情報技術者試験に合格するまで」というタイトルで内容を記載しています.
その中で令和2年秋季の応用情報技術者試験の受験報告と自己採点を記載したのですが,正式な受験結果を記載していなかったのでこちらで展開しようと思います.

受験結果

受験結果は無事「合格」でした.

f:id:takaherox:20210103212144p:plain
合格発表

自己採点では以下の通りでしたが,実際は自己採点より下方修正された点数でした.午後の点数は割とギリギリでしたね...

試験項目 自己採点 試験結果
午前試験 90点 88点
午後試験 74点 69点

午前試験は選択方式ということもあり解答速報による採点結果と公式の採点結果がほとんど同じであるため,早く結果を知りたいという方の自己採点は有効そうですね.一方の午後試験は記述式の部分があるので公式の試験結果を見てみないと分からない場合もありそうです.特に,自己採点が合格ラインである60点付近となった場合は試験結果が出るまで落ち着かない日々を過ごすことになると思います.
ただ何にせよ地道に勉強した結果は裏切らないので直前に詰め込む勉強法より地道にコツコツ勉強する方法で学習することを私は勧めます.勉強法については以前の記事に方法を記載しているのでそちらを是非参照してみてください.

takaherox.hatenablog.com

次の試験に向けて

応用情報は情報処理技術者試験のレベル3の区分に位置付けられています.
次の試験としてレベル4の高度試験がありますので今後はそちらにも意識的に時間を作って挑戦していければと考えています.

www.jitec.ipa.go.jp

レベル4の高度試験について少し紹介しておくと,高度試験では分野が分かれており,それぞれの分野でより深い知識と実務能力を要求されるようになります.私はマネジメントよりはテクノロジの領域を実際の仕事でも扱っているので,「ネットワークスペシャリスト試験」か「データベーススペシャリスト試験」のどちらかを受験しようと思います.というのも,高度試験の中でも難易度にムラがあり比較的取得しやすい資格となっているためです.

これから心機一転して勉強を始めることになりそうですが,高度試験の受験についても別の記事で勉強法やTips等をまとめていけたらと思います.

まとめ

試験勉強に真剣に取り組んでいたので素直に応用情報技術者試験に合格していて良かったです.今後も新しい知識を身に着けるためにより高度な資格取得を目指していこうと思います.

データ分析でもアルゴリズム『いもす法』

はじめに

データサイエンスを日常的に行う中で大量のデータを扱うことが往々にしてあります.その際に頻繁に発生してくる問題が膨大な計算量による待ち時間発生や計算が有限時間内に終了しないといった問題です.

私は特にこの待ち時間を非常に厄介だと感じていてます. 何故かと言うと,待ち時間が発生すると当該処理が終わるまで別の作業をして効率的に物事を実施しようと思うのですが,逆にこのタスクの切り替えによってオーバヘッドがかかってしまい非効率になってしまうためです.

例えば,英語長文読解の勉強をしている途中で急に洗濯の依頼をされ,洗濯が終わった後に勉強を再開しようすると,途中まで読んでいた内容を思い出すために長文を読み直したりすることがあると思います.このようにタスクの切り替えにはオーバーヘッドが付き物であり,労力がかかることがしばしばあります.

そのため,データ分析に関しても可能な限り待ち時間を少なくして集中して取り組むことが良いと考えています.こういった経験から実行速度やメモリ効率に影響してくるアルゴリズムを理解することは重要であると思っており,時間があるときに私はアルゴリズムの学習をしています.
そこで,今回はその学習過程で出会った『いもす法』というアルゴリズムについてまとめていこうと思います.

『いもす法』ってなんぞや

いもす法は「ある連続する区間に、ある数 v を足す」という操作をK回繰り返した結果を、計算量 O(N+K) で高速に計算する方法です.
これだけ聞くとどういう事を意味しているのか分かりづらいと思うので,処理の具体的なプロセスを以下に記載します.

  1. 加算処理
    区間 [a, b]v を加算したいとき、a 番目の値に v を加算して b+1 番目の値に -v を加算する
  2. 累積和
    加算処理した結果を元に累積和を計算して結果を得る

要するに,いもす法では区間の入口で加算、区間の出口で減算をしたリストを作成して、リストの作成が終わったら前から順に累積和を計算していきます.この後ではPythonで実装した例を示していこうと思います.
また,いもす法の本家の解説は以下になります.より深い理解をしたい人は参照してください.

imoz.jp

Pythonでの実装例

さて,いもす法をPythonを用いて実装してみようと思います. 実行環境は以下となっています.

$ sw_vers
ProductName:    Mac OS X
ProductVersion: 10.14.6
BuildVersion:   18G6042

$ python -V
Python 3.6.9

簡単のために長さがNの1次元配列を題材とします.
以下が今回扱う問題です.

長さが10のリストにおいて、
- 区間[1, 7]に2を加算
- 区間[4, 8]に3を加算
- 区間[0, 5]に5を加算
という3つの操作をしたときの最終結果はいくつか.

まず長さが10の配列を作成します.

N = 10
data = [0] * N

次に区間[1, 7] に2を加算する処理を適応します.
この場合はリストのインデックスが 1 の時に 2 を加算して,インデックスが 8 の時に 2 を減算します.

a, b = 1, 7
v = 2
data[a] += v
if b+1 != N:
    data[b+1] -= v

同様に区間 [4, 8][0, 5] に3と5をそれぞれ加算してリストを更新します.

a, b = 4, 8
v = 3
data[a] += v
if b+1 != N:
    data[b+1] -= v

a, b = 0, 5
v = 5
data[a] += v
if b+1 != N:
    data[b+1] -= v

そして最後にこのリストより累積和を計算します.

ans  = [0] * N
for i in range(0, N):
    if i == 0:
         ans[i] = data[i]
    else:
        ans[i] = ans[i-1] + data[i]

print(sum(ans))
#59

また,処理が冗長な部分を省いた場合のコードは以下となります.

# 要素のリスト作成
N = 10
data = [0] * N

# 要素のリスト更新
rlist = [(1, 7, 2), (4, 8, 3), (0, 5, 5)]
for a, b, c in rlist:
    data[a] += c
    if b+1 != N:
        data[b+1] -= c

# 累積和の計算
ans = [0] * N
for i in range(0, N):
    if i == 0:
         ans[i] = data[i]
    else:
        ans[i] = ans[i-1] + data[i]

print(sum(ans))

実際の実装例を踏まえて『いもす法』の一連な流れが理解できたと思います.
今回の例ではリストの長さが小さいため,『いもす法』を使わずとも各区間について2重ループを回すことで結果を求めることができます.しかし,このリストの長さが非常に長くなった場合には計算が立ちゆかなくなってくるので『いもす法』はそう言った場合に非常に効力を発揮ので覚えておいて損はないと思います.

まとめ

今回はデータ分析の下支えとなるアルゴリズムに関して知識整理を兼ねてまとめてみました.
データ分析のゴールは分析して終わりではなく,データ分析で得られた知見を顧客までデリバリして価値を提供する事になります.そのデリバリの方法の1つとしてソフトウェアによる提供が多くあると思います.そういった観点からも開発サイドでアルゴリズムに精通することは決して無駄にはならないのでデータ分析と合わせて学習していくと良いと思います.

ofuse.me

Pytorchにおけるモデル保存の使い分け

はじめに

TorchServeを利用してサービングを実施する際にモデルの保存方法についていくつかパターンがあり,TorchServeで保存したモデルを読み込む際にうまく動作しないといった事があったのでしっかり違いを把握しようと思ってこの記事を書いています.この記事を読んでくださっている人の中にもよく分からずに何となくPytorchにおけるモデル保存を実施している人もいるかと思いますのでそう言った方の参考になればと思います.ちなみにPytorchのバージョンは1.7.0を前提として話を進めます.

モデル保存パターン

まず保存パターンについて説明していきます.
公式では大きく2つのパターンでのモデル保存を解説しています.また,そのほかにもTorchScriptを利用したモデルの保存方法もあります.方法別で記載すると以下のパターンがモデル保存方法として実現する方法としてあります.

  1. state_dictを利用したモデルの保存/読み込み
  2. entire のモデル保存/読み込み
  3. TorchScriptによるモデル保存/読み込み

pytorch.org

次から各パターンの特徴を実装例を交えて解説していきたいと思います.

各パターンの解説

ここからは先ほど列挙した各パターンのモデル保存方法を説明していきたいと思います.

前提情報としてモデル保存と読み込みを実装を交えて説明するためのモデルを以下に記載します.モデル自体はなんでも良いので適当に5層のMLPを定義しました.

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc1 = nn.Linear(128, 64)
        self.fc2 = nn.Linear(64, 32)
        self.fc3 = nn.Linear(32, 16)
        self.fc4 = nn.Linear(16, 8)
        self.fc5 = nn.Linear(8, 2)
    
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.dropout(x, p=0.5)
        x = F.relu(self.fc2(x))
        x = F.relu(self.fc3(x))
        x = F.relu(self.fc4(x))
        x = self.fc5(x)
        return x

model = MyModel()

state_dictのモデル保存

1番目の state_dict を用いたモデル保存について説明します.

state_dict はモデルで定義された各レイヤーにTensor形式のパラメーターをマッピングするための単純な辞書オブジェクトを返します.これによって,簡単にモデルを保存、更新、変更、復元できるようになります.

# モデル保存
torch.save(model.state_dict(), "models/model_state_dict.pth")

# モデル読み込み
model_state_dict = MyModel()
model_state_dict.load_state_dict(torch.load("models/model_state_dict.pth"), strict=False)

model_state_dict.state_dict() を実行すると学習ずみのパラメータが正しく読み込まれているのが分かります.

また, state_dictを用いることによってGPUで学習したモデルをCPUで推論したり,CPUで学習したモデルをGPUで推論したりすることができます.そのため,Pytorchの公式ドキュメントでは state_dict が推奨されています.

# GPU to CPU
# モデル保存
torch.save(model.state_dict(), "models/model_state_dict.pth")

# モデル読み込み
device = torch.device('cpu')
model = MyModel()
model.load_state_dict(torch.load("models/model_state_dict.pth", map_location=device))

# CPU to GPU
# モデル保存
torch.save(model.state_dict(), "models/model_state_dict.pth")

# モデル読み込み
device = torch.device("cuda")
model = MyModel()
model.load_state_dict(torch.load("models/model_state_dict.pth", map_location="cuda:0"))
model.to(device)

学習時と推論時で異なるプロセッサを利用する場合などはload関数を実行する際にmap_locationの引数にデバイスを指定してあげる必要があります.これによって,GPUで学習したモデルをCPUで読み込む際にはTensorを扱うストレージがCPUに動的再配置されるようになります.
逆に,CPUで学習したモデルをGPUde読み込む際も同様でload関数を実行する際にmap_locationの引数でTensorマッピングするGPUバイスを指定してあげる必要があります.ここで,GPUのどのデバイスに配置するのかを明示するためcuda:idの形式で指定してあげます.そして,CPUからGPUの場合では必ず model.to(torch.device('cuda')) を呼び出してモデルのパラメータであるTensorをCudaTensorに変換してあげてください.

entireのモデル保存

続いて,モデルとパラメータをセットで管理するモデル保存方法の説明です.

entire モデルではモデルに含まれるモジュール全体を保存することになります.メリットは少ないコード量で記述できることとその直感的な文法です.

# モデル保存
torch.save(model, "models/model_state_dict.pth")

# モデル読み込み
torch.load("models/model_state_dict.pth")

この方法では pickle モジュールを用いて保存されているおり,シリアル化されたデータが特定のクラスとディレクトリ構造にバインドされることになります.これによって,推論時のロードうやリファクタリングした場合に参照するパスが異なっていたりして致命的なエラーとなり利用できなくなります.このデメリットからも公式では非推奨となっています.
直感的で分かりやすいのですが,デメリットが大きすぎで実際に活用するシーンというのは少なそうです.

TorchScriptのモデル保存

まずTorchScriptについて簡単に説明します.

TorchScriptはPytorchで学習させたモデルをPython非依存な形でモデルを最適化してパラメータを保存することができます.この形式で保存したモデルはPython以外のC++iOSAndroidといった様々な環境で読み込んで利用することが可能になります.

こちらの記事で分かりやすくまとめられてますので,TorchScriptについて詳しく知りたいという方は是非参照してみてください.

pytorch.org

では,TorchScriptでモデルを保存する方法を以下に記載します.

# モデル保存
input_tensor = torch.rand(1, 128)
model_trace = torch.jit.trace(model, input_tensor)
model_trace.save('models/model_trace.pth')

# モデル読み込み
model_trace = torch.jit.trace('models/model_trace.pth')

TorchScript のモデルを作成するためにはサンプルデータを流して処理をトレースして変換を行うことで生成します.非常に簡単ですね.また,TorchScript のモデルを作成する方法にはトレースして生成する方法以外に直接的にモデルを記述する方法もあります.

べストな保存方法

さて,このパターンを踏まえてベストな保存方法について検討してみます.
まず,パターン2の entire のモデル保存ですがこちらは公式でも非推奨とされているので利用しない方が良いと思います.

次にパターン1の state_dictとパターン3の TorchScript のモデル保存ですが,こちらの2つは状況に合わせて使い分けを実施するのが良いです.
モデル作成途中やプロトタイプレベルで利用する場合にはパターン1のstate_dictによるモデル保存を利用します.TorchScriptでは最新の処理には対応していない場合があり,変換する際にエラー対応が必要になることがあります,そのため,試作レベルの時にはデバックに用する時間をかけるよりもスピード感を重要視して state_dict を利用する方が良いと思います.
そして,プロダクションフェーズの利用の際には TorchScript でのモデル保存を実施して最適化されたモデルを活用するといった使い分けが良いと言えます.TorchScriptも最近では改善や最適化が進んでいるので今後は全ての状況でTorchScriptでモデル保存する方が良いといった変化はあるかと思いますが,現状は上記のような使い方をするのがベストかと思います.

まとめ

今回はPytorchのモデル保存についてまとめてみました.
普段何気なく使っている人やTorchScriptを使ったことのない人にとって参考になればと思います.

TorchServe入門

TorchServeとは

TorchServeはPytorchで構築したモデルをサービングするためのモデルサービングライブラリです.

AWSFacebookが連携して開発しているため,Pytorchのコミュニティと共に今後の発展が期待できます.また,GithubのスターもTensorflow Servingの4515と比べると見劣りしますが,2020年12月時点で1464と様々な人から注目されていることが分かります.
また,AWSとの親和性も高く,TorchServeによる推論サーバをSageMakerやEKS上に構築して,スケールアウトする事例を公式のブログにて公開しています.このようにプラットフォーム側がサポート・推奨しているライブラリを利用することは安心感がありますし,本番環境までを意識したモデル構築を実現できるTorchServeの存在は非常に大きいと思います. 私自身もこれまではPytorchで作成したモデルをデプロイする際には自身でAPIサーバの設計と実装,ログ設計,テストなど多くのことを検討・実施しておりましたが,TorchServeの登場によって多くのプロセスを簡略化することができるため非常に有効なツールだと感じています.

github.com

pytorch.org

さて,以降ではTorchServeの紹介と独自で作成したオリジナルモデルをTorchServeにデプロイしてサービングを実践していきます.

アーキテクチャ

Pytorchのアーキテクチャは以下のようになっております.

TorchServeをデプロイするといくつかのコンポーネントが立ち上がります.Frontendと呼ばれるコンポーネントがInference APIを提供して推論用のAPIエンドポイントを提供します.モデルごとにエンドポイントが提供されるため,複数のモデルを同時に扱うことができます.
また,Process Orchestrationの部分ではManagement APIと呼ばれるモデルの登録やステータスを確認するためのエンドポイントも提供しています.モデル新規登録からバックエンドで動作するワーカーのスケールなどの制御を行うことができます.

f:id:takaherox:20200726152512p:plain
architecture

  • 構成要素
    • Frontend(フロントエンド)
      • リクエストとレスポンスを扱うTorchServeのコンポーネントで,クライアントからのリクエストとレスポンスの両方を処理してモデルのライフサイクルを管理します
    • Model Worker (モデルワーカー)
      • ワーカーはモデル推論を実際に実行する責任があり,実際に実行されるモデルのインスタンスを指します.
    • Model(モデル)
      • モデルはstate_dictsなどの他のモデルアーティファクトと共に,データに対してカスタマイズされた前処理や後処理を提供することができます.また,モデルはクラウドストレージまたはローカルホストからロードできます.
    • Plugins(プラグイン)
      • TorchServeの起動時に利用者によってカスタマイズされたエンドポイントや認証認可,バッチ処理を指定できます.
    • Model Store(モデルストア)
      • 読み込みが可能なモデルが存在するディレクトリを指します.

また,TorchServeで提供されるAPIはOpenAPIの標準仕様に則って作成されているため,APIインターフェース仕様を容易に理解できるようにもなっております.API仕様を説明したJson形式ドキュメントを介して以下に示すようなSwaggerUIも確認できるのでそちらも理解を手助けしてくれます.ドキュメントが手厚いのは利用者側からすると組織やグループで導入する際のハードルを下げる重要な要素になってくるので非常にありがたいです.

f:id:takaherox:20200725224319p:plain
swagger ui

メリット

次にTorchServeのメリットを記述します.
やはりTorchServeのメリットは以下になると思います.

  • 機械学習モデルを活用した機能のサービスへの導入高速化
    機械学習で作成したモデルをTorchServeによってAPI提供することができるため,サービス導入までのリードタイムを短縮することが可能となります

  • モデル構築部分へのリソース注力
    実際のビジネス現場ではモデルを構築して終わりではなく,それを活用してオペーレーションを最適化したり,ユーザに価値を届けたりします.そのため,モデル以外にもソフトウェア開発等にリソースを割く必要があるのですが.TorchServeによってその一部が簡略化できるためモデル部分にリソースを集中することができるようになります

  • オペレーションにおけるモデル運用の効率化
    複数のモデルを統一されたプラットフォームでサービングやモデル管理ができるため,運用時のオペレーションを効率化することが可能になります

  • アナリストによるソフトウェア開発への介入
    データサイエンティストがソフトウェア開発の領域に介入することを容易にするため,データサイエンティストがよりシームレスな顧客へのデリバリを可能にすることができます

このように大きなメリットがあるので小さいデメリットがいくつかあったとしても導入を検討する価値はあると思います.モデルをサービングする必要がある場合の実現方法の1つとして覚えておいて損はないはずです.

事前準備

TorchServeによるサービングを実践する前にモデル作成に必要なデータとTorchServeのインストール方法について記載します.

利用データ

今回利用するデータはUCI machine learning repositoryで公開されているadultデータセットになります.
このデータセットはユーザ属性と当該ユーザの年収が50Kを超えるかどうかを示すラベルのデータ内容から構成されています.そのため,分類タスクのデータセットとして一般的に用いられてます.これを使って予測モデルを以降で構築していこうと思います.

archive.ics.uci.edu

adultデータセットに含まれる属性値とその説明について簡単に以下にまとめておきます.

カラム名 説明 変数 補足
age 年齢 連続値 -
workclass 労働階級 カテゴリ変数 8種類
fnlwgt 国勢調査の人口重み 連続値 -
education 学歴 カテゴリ変数 16種類
education-num 教育期間 連続値 -
marital-status 世帯 カテゴリ変数 7種類
occupation 職業 カテゴリ変数 14種類
relationship 続柄 カテゴリ変数 6種類
race 人種 カテゴリ変数 5種類
sex 性別 カテゴリ変数 2種類
capital-gain キャピタルゲイン 連続値 -
capital-loss キャピタルロス 連続値 -
hours-per-week 週当たりの労働時間 連続値 -
native-country 母国 カテゴリ変数 41種類
target 年収ラベル '>50K' = 1, '<=50' = 0 -

インストール

実行環境は以下のようになっています.

$ sw_vers
ProductName:    Mac OS X
ProductVersion: 10.14.6
BuildVersion:   18G6042

$ python -V
Python 3.6.9

TorchServeのインストールは以下の pip コマンドでインストールします.

# pytorch インストール
$ pip install torch torchvision

# torchserve インストール
$ pip install torchserve torch-model-archiver

以上で環境構築は終わりです.
次からはモデル学習してTorchServeによる推論サーバをデプロイしていきましょう.

TorchServe実践

ここからが本題のモデルのデプロイ部分になります.
前置きが長くなりましたが,早速実際にモデルをデプロイしていきましょう.

モデル作成

まずデプロイするためのモデルの作成です.
ユーザ属性から年収が500ドルより高い収入を得るか得ないかを2値分類する予測モデルを構築していきます.

  • Pythonライブラリのインポート
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

from sklearn.preprocessing import StandardScaler
from sklearn.metrics import auc, roc_curve
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, classification_report
  • リスト定義
# データフレームに設定するカラムのリスト
cols = [
    'age', 'workclass', 'fnlwgt', 'education', 'education-num', 
    'marital-status', 'occupation', 'relationship', 'race', 'sex',
    'capital-gain', 'capital-loss', 'hours-per-week', 'native-country', 
    'target'
]

# 標準化を適応するカラムのリスト
scholar_cols = [
    'age', 'fnlwgt',  'education-num', 'capital-gain',
    'capital-loss', 'hours-per-week',
]

# ダミー化を実施するカラムのリスト
category_cols = [
    'workclass', 'education', 'marital-status', 'occupation',
    'relationship', 'race', 'sex', 'native-country'
]

カラム名のリスト,標準化を実施するカラム名のリスト,ダミー化を実施するカラム名のリストを事前に定義しておきます.後ほど,前処理の工程で利用します.

  • データの読み込み
# UCIのデータセットを読み込み
df = pd.read_csv('../data/adult.data', names=cols, header=None)
# 不完全なデータをNanに置換
df = df.applymap(lambda d: np.nan if d==" ?" else d)
# Nanのレコードを除外
df = df.dropna()

UCIのデータセットを読み込んだ後にデータに含まれている不完全なレコードを除去します.UCIのadultデータセットには欠損データが含まれており.『 ?』のレコードをNanに変換した後に dropna でレコード毎除外しています.
この時点でデータ数が 30162 になっているはずです.

  • 前処理の実施
# targetカラム数値に変換
_, y = np.unique(np.array(df.target), return_inverse=True)
df.loc[:, 'target'] = y

# 連続値を標準化
sc = StandardScaler()
features = sc.fit_transform(df.loc[:, scholar_cols].values)
features
df.loc[:, scholar_cols] = features

# カテゴリ値をダミー化
df = pd.get_dummies(df, columns=category_cols)

処理としては大きく3つの前処理を実施しています.
1つは target 列を学習で扱えるように0と1のラベルに変換します.
そして残りの2つは連続値の標準化とカテゴリ変数のダミー化です.

  • パラメータ定義とデータ分割
# 各種定数
SEED = 42             # シード値
BATCH_SIZE = 32       # バッチサイズ
epochs = 20           # エポック数
learning_rate = 1e-3  # 学習率
device = 'cuda' if torch.cuda.is_available() else 'cpu'
target = 'target'
predictors = [col for col in df.columns if col not in target]
input_num = len(predictors)

# データを学習用とテスト用に分割
X_train, X_test, y_train, y_test = train_test_split(df[predictors], df[target], test_size=0.2, random_state=SEED)

学習で利用するパラメータを定義します.
バッチサイズは32でエポック数は20としています.また,全データのうちの2割をテストデータとして分割します.

  • DatasetクラスとModuleクラスの定義
# 独自データセットの定義
class MyDataset(Dataset):
    def __init__(self, df, target):
        self.dataset = torch.Tensor(df.values)
        self.target = torch.Tensor(target.values).long()
        self.datanum = len(self.dataset)

    def __len__(self):
        return self.datanum
    
    def __getitem__(self, idx):
        out_dataset = self.dataset[idx]
        out_target = self.target[idx]
        return out_dataset, out_target

# ネットワークの定義
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc = nn.Sequential(
            nn.Linear(input_num, 64),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, 16),
            nn.ReLU(),
            nn.Linear(16, 8),
            nn.ReLU(),
            nn.Linear(8, 2)
        )
    
    def forward(self, x):
        x = self.fc(x)
        return x

Pytorchで学習するためにデータセットクラスを定義します.
利用するために必要なPytorchで独自データセットを定義する方法についてはこちらを参照ください.
ネットワークは単純な5層のMLPを定義して,最終層で2つのパラメータを出力するようにしています.

  • 学習
# ハイパーパラメータ初期化
criterion = nn.CrossEntropyLoss()
model = MyModel().to(device)
optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9)

# データローダーの作成
train_dataset = MyDataset(X_train, y_train)
test_dataset = MyDataset(X_test, y_test)
train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)

# 学習
train_loss = []
for epoch in range(0, epochs+1):
    running_loss = 0.0
    running_corrects = 0
    model.train()
    for idx, (inputs, targets) in enumerate(train_loader):
        inputs, targets = inputs.to(device), targets.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        _, preds = torch.max(outputs, 1)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()
        running_loss += loss.item() * inputs.size(0)
        running_corrects += torch.sum(preds == targets.data)

    epoch_loss = running_loss / len(train_loader.dataset)
    epoch_acc = running_corrects.double() / len(train_loader.dataset)
    
    print('{}/{} Loss: {:.4f} Acc: {:.4f}'.format(epoch, epochs, epoch_loss, epoch_acc))

# テストデータによる評価データ取得
y_tests = []
y_preds = []
model.eval()
with torch.no_grad():
    for idx, (inputs, targets) in enumerate(test_loader):
        inputs, targets = inputs.to(device), targets.to(device)
        outputs = model(inputs)
        _, preds = torch.max(outputs, 1)
        outputs = F.softmax(outputs, dim=1)
        y_preds.append(outputs[:, 1].detach().cpu().numpy())
        y_tests.append(targets.detach().cpu().numpy())

先ほど定義した MyDataset クラスを用いてPytorchでデータを呼び出すためのデータローダーを定義します.これを用いてモデルの学習とテストデータによる評価データの取得を実施します.

  • 評価とモデル保存
# numpy arrayの結合
y_preds = np.concatenate(y_preds)
y_tests = np.concatenate(y_tests)

# ROC Curveの表示
fpr, tpr, thresholds = roc_curve(y_tests, y_preds)
auc = auc(fpr, tpr)
fig = plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, label='ROC curve (area = %.3f)' % auc)
plt.xlabel('FPR: False positive rate')
plt.ylabel('TPR: True positive rate')
plt.title('ROC Curve')
plt.legend()
plt.grid()
plt.show()

# Confusion Matrixの表示
matrix_data = confusion_matrix(y_tests, np.round(y_preds), labels=[0, 1])
plt.figure(figsize = (10,7))
sns.heatmap(matrix_data, annot=True, cmap='Blues', fmt='4g')
plt.show()

# モデル保存
input_tensor = torch.rand(1, input_num)
export_model = torch.jit.trace(model, input_tensor)
export_model.save('../models/model.pth')

テストデータによって取得した評価データを用いてAUCと混合分布は以下の通りになりました. AUCは91.3%とかなり高精度のモデルになっていることを確認できました.
また,混合分布からもTrue PositiveとFalse Negativeに大半は分類できていることが見て取れます.
モデル保存は torch.save を用いてモデル全体の情報を保持する形でデータ出力をしています.こちらに関しては別の記事にて詳細にまとめていこうと思います.

f:id:takaherox:20201230160507p:plainf:id:takaherox:20201230160512p:plain
モデル評価のためのグラフ

次からはここで作成したモデルをTorchServeを用いてデプロイしていきましょう.

デプロイ

本題のTorchServeにてモデルのデプロイをします.
大きな流れは以下の通りです.

  • handlerの記述
  • 作成した学習済みモデルのアーカイブ
  • TorchServeでのデプロイ

まず始めにhandlerと呼ばれる推論ロジックを定義するための custom_handler.py ファイルを作成します.このファイルではモデルの読み込みやリクエストで受け取ったデータの前処理等を記述することができます.TorchServeではこのhandlerがエントリポイントになるため実行時にここで記述された内容が実行されます.デフォルトでいくつかのhandlerが用意されていますが,独自で作成したモデルには適応できないためカスタムhandlerを利用します.

今回作成したファイルは以下の通りです.
カスタムhandlerではBaseHandlerクラスを継承して独自の処理内容を記述したファイルを作成します.この際に initializehandle メソッドは必ず定義する必要があるので注意してください. 以下ではpreprocess メソッドでは前処理を postprocess 後処理の内容をオーバーライドして記述しています.

import os
import torch
import torch.nn as nn
import torch.nn.functional as F
from ts.torch_handler.base_handler import BaseHandler

class ModelHandler(BaseHandler):
    def __init__(self):
        self.manifest = None
        self._context = None
        self.initialized = False
        self.model = None
        self.device = None

    def initialize(self, context):
        self.manifest = context.manifest
        properties = context.system_properties
        model_dir = properties.get("model_dir")
        self.device = torch.device("cuda:" + str(properties.get("gpu_id")) if torch.cuda.is_available() else "cpu")

        # Read model serialize/pt file
        serialized_file = self.manifest['model']['serializedFile']
        model_pt_path = os.path.join(model_dir, serialized_file)
        if not os.path.isfile(model_pt_path):
            raise RuntimeError("Missing the model.pt file")
        
        self.model = torch.load(model_pt_path)
        self.initialized = True

    def preprocess(self, data):
        preprocessed_data = data[0]['body']['data']
        if preprocessed_data is None:
            preprocessed_data = data[0].get("data")
        return torch.FloatTensor([preprocessed_data])

    def inference(self, model_input):
        # Do some inference call to engine here and return output
        model_output = self.model.forward(model_input)
        return model_output

    def postprocess(self, inference_output):
        probs = F.softmax(inference_output, dim=1)
        results = [
            {
                "<=50K":  prob[0],
                ">50K": prob[1]
            } 
            for prob in probs.tolist()
        ]
        return results
    
    def handle(self, data, context):
        model_input = self.preprocess(data)
        model_output = self.inference(model_input)
        return self.postprocess(model_output)

続いて torch-model-archiver を利用してモデルをTorchServeで扱う .mar 形式に変換します.handler オプションで先ほど作成した custom_handler.py を指定してアーカイブします.アーカイブされた .mar ファイルは export-path で指定したディレクトリに<model-name>.mar のファイル名で出力されます.以下のコマンドではmodel_storeディレクトリ配下にsevremodel.marファイルが出力されているはずです.
オプションの細かい説明は公式ドキュメントをご覧ください.

$ mkdir model_store
$ torch-model-archiver --model-name servemodel \
                       --version 1.0 \
                       --serialized-file models/model.pth \
                       --handler handlers/custom_handler.py \
                       --export-path model_store

最後に torchserve コマンドによってデプロイを実行します.
先ほどアーカイブした servemodel.mar を指定してください. これでデプロイは完了です.

$ torchserve --start \
             --ncs \
             --model-store model_store \
             --models servemodel.mar

動作確認はヘルスチェック用のエンドポイント /ping に対してリクエストを投げてレスポンス内容を確認してください.statusに Healthy が返って来れば正常に動作しています.

$ curl curl http://127.0.0.1:8080/ping
{
  "status": "Healthy"
}

推論リクエス

さて,TorchServeによってデプロイしたモデルに対して推論を実施してみましょう.

TorchServeのデフォルトの設定では2つのAPIサービスが立ち上がり,ポート番号8080ではInference APIが,ポート番号8081ではManagement APIが利用できるようになります.Inference APIで推論を行うためのエンドポイントは /predictions/<model name>/<version>となるため,今回デプロイしたモデル名を指定して /predictions/servemodel/1.0/ に対してPOSTリクエストを投げて結果を確認してみます.

$ curl -X POST -H 'Content-Type: application/json' -d '{"data": [0.030671, -1.063611, 1.134739, 0.148453, -0.21666, -0.035429, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]}' http://127.0.0.1:8080/predictions/servemodel/1.0/

{
  "<=50K": 0.8627053499221802,
  ">50K": 0.13729462027549744
}

無事に推論が行えて正常にモデルがデプロイできていますね.
詳細な設定によるカスタマイズやバッチ推論等も行えるようなので自身の利用用途に合わせて柔軟に対応させることができると思います.是非皆様も活用してみてください.

まとめ

今回はPytorchで構築したモデルをサービングするためのTorchServeについてご紹介しました.開発が盛んなPytorchコミュニティですので今後の発展が楽しみですね.
また,まだPytorchに関してそんなに詳しくないという方については少し内容が難しかったかと思います.そう言った方には以下のような書籍で学習することをおすすめします.こちらは私も日々参考に利用している書籍で,様々なアルゴリズムの実装例ととフレームワークの詳細な説明があるため1冊で網羅的にPytorchに関する学習をすることが可能です.

DjangoのORMにおけるコネクション管理

事の経緯

DjangoのORMについて深く理解しておらず,Djangoにおけるコネクションの管理とかってどうなっているのだろと気になったので調べてみました.
加えて,このままなんとなくで利用していたら,いつか絶対バグを生み出しかねないと不安になったのも調べたいと思った1つの要因です.

本記事は自身の備忘録としてまとめようと思います.
そのため,詳細な解説等は省いてしまう部分もあるかと思いますが,Djangoのデータベースに関する記事って意外と少なくて探すのに苦労するので,少しでも他の方の参考になれば幸いです. (公式ドキュメント読めって話ですが...)

Django ORMとは

Djangoではデータベースの操作をORMと呼ばれるデータベースとプログラムミング言語間のオブジェクトを変換するプログラミング技法が使われております.利用者はこのORMを介してデータベースを操作することで効率的な開発やセキュアプログラミングを実現することができます.
例えば,以下のようなモデルを定義していた場合を想定してみましょう.

from django.db import models

class Post(models.Model):
    author = name=CharField(max_length=255) 
    title = models.CharField(max_length=200)
    text = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

このモデルに対してORMを利用することでSQLを意識することなくデータベースの情報を取得してオブジェクトとして扱うことが可能になります.

from django.http import HttpResponse
from .models import Post

def index(request):
    post = Post.objects.all()  # データベースにあるPostを全て取得
    return HttpResponse(post)

非常に便利な機能ですよね.
ORMを利用することでMigration等も実施できるため類似機能としてSQLAlchemyやStormといった別のツールがありますが,Djangoを利用するのであればDjango ORMを利用した方が良いかと思います.

Connection管理

さて,本題のDjangoのORMにおけるコネクションの管理についてです. DjangoのORMでコネクションを接続するタイミングはいつなのでしょうか.

答えはリクエストを受けてから 初めてSQLが発行されるタイミング の時です.
以下で説明するとHTTPリクエストを受けてルーティングによってupdateメソッドが呼び出された時の1回目のPost.objects.get(id=id)を実行したタイミングでデータベースのコネクション接続が行われます.以降は初回に接続したコネクションを利用してSQLを実行するため,2回目のPost.objects.get(id=id)ではコネクション接続はせずにSQLを実行しています.

from django.http import HttpResponse
from .models import Post

def index(request):
    posts = Post.objects.all()  # データベースにあるPostを全て取得
    return HttpResponse(posts)

def update(request, id):
    # 1回目の変更
    post = Post.objects.get(id=id)
    post.title = 'first change!'
    post.save()
    # 2回目の変更
    post = Post.objects.get(id=id)
    post.text = "second change!"
    post.save()

    return HttpResponse(post)

ここで,ごく稀にDBのコネクション接続をSQL毎に実施したいという要望があるかと思います.その場合は以下のように実装して強制的にコネクションをクローズするように実装します.

from django.db import connection
from django.http import HttpResponse
from .models import Post

def update(request, id):
    # 1回目の変更
    post = Post.objects.get(id=id)
    post.title = 'first change!'
    post.save()
    connection.close()    # コネクションのクローズ

    # 2回目の変更
    post = Post.objects.get(id=id)
    post.text = "second change!"
    post.save()

    return HttpResponse(post)

ただし,これはリソースの観点からは推奨されません.
というのもデータベースへの接続を再確立することになるため接続のオーバーヘッドが増加することになります.リクエストで接続を開始してからコネクションを継続するのはこのオーバーヘッドを回避するための仕様になります.そのため,必要がない限りはコネクションを開始してからはリクエストが終了するまで継続して利用するようにしましょう.

まとめ

今回はDjangoのコネクションに関する内容を記載しました.
CONN_MAX_AGEConnection Poolなど他にも残しておきたい備忘録は多々ありますが,今回はコネクション管理のみについて簡単にまとめておきました. また,別の機会にDjango ORMに関する情報は継続的に記載していこうと思います.

応用情報技術者試験に合格するまで

応用情報技術者試験とは

応用情報技術者とはIPAが試験を運営実施するIT系の国家資格です.
応用情報技術者試験の対象者は「高度IT人材となるために必要な応用的知識・技能をもち,高度IT人材としての方向性を確立した者」とされています. 試験は選択式の午前と記述式の午後の2つの構成から成り,一般的な合格率は約20%程度となっています.
特に受験資格等はないことから誰でも受験することができます.ITスキル保有の証明としては有効かと思いますのでこれから様々な業界でIT化が進んでいくと想定される中で取得して損はない資格だと思います.次の高度試験の午前試験を一部免除できるのでその点もメリットです.

www.jitec.ipa.go.jp

受験日までのロードマップ

ちゃんと勉強を開始し始めたのは試験日の2020年の1月からです.
当初は令和2年春期の試験を受験しようと考えていたので,大まかに以下のようなロードマップで試験対策を実施していこうと思っていました.

期間 対策内容
2020/1月 勉強開始・午前対策
2020/2月 午後対策
2020/3月 苦手分野の対策
2020/4月 直前の詰め込み

ですが,令和2年春期の試験はコロナの影響で中止となってしまったため,当初計画よりも勉強期間を長めに確保できるようになったことから以下の流れで勉強を実施しました.

期間 対策内容
2020/1月 勉強開始・午前対策開始
2020/2月 午前対策(教本)
2020/3月 午後対策開始(問題演習)
2020/4月~8月 午前対策(1問1問)・午後対策(問題演習)
2020/9月 過去問演習
2020/10月 直前の詰め込み

ちなみに私のバックボーンを簡単に補足しておくとITに関する職務経験は4年半ほどあります.フロントエンド・バックエンドの開発からインフラ構築まで運用以外の業務を中心に行ってきて,最近はデータサイエンスの領域を中心に作業するといった経歴のためアドバンデージがある状態からのスタートでした.学生の頃を含めるとITに触れていた期間はもっと長いので文系初学者ではないので参考にされる方はご注意ください.

書籍やツール

私が試験に向けて利用した書籍とツールは以下の3つです.

三種の神器ではないですが応用情報では技術に関する知識の幅と深さを求められますので,「応用情報技術者 合格教本」で幅を「応用情報技術者 午後問題の重点対策 2019」で深さを補うという意識で学習を実施していきました.
また,「応用情報技術者試験ドットコム」は応用情報に関する情報を公開している無料サイトで,コンテンツとして1問1問形式で過去問を解くことができるため午前試験を確実に突破するために利用しました.

2019応用情報技術者午後問題の重点対策 (重点対策シリーズ)

2019応用情報技術者午後問題の重点対策 (重点対策シリーズ)

  • 作者:小口達夫
  • 発売日: 2018/10/31
  • メディア: 単行本(ソフトカバー)

www.ap-siken.com

だだ,正直なところ午前試験の勉強のために「応用情報技術者合格教本」を購入しましたが,振り返ると必要なかったなと感じます.というのも「応用情報技術者試験ドットコム」の1問1答が非常に有力なツールだからです.1問1答の問題は過去の午前試験からの出題になるのですが,解説が1つ1つに丁寧に設けられているため,合格教本を買わずとも問題を問いて解説を読むという工程を繰り返すだけで合格に必要な知識が身につきます.そのため,ある程度知識がある人は合格教本を買わずに「応用情報技術者試験ドットコム」と「応用情報技術者 午後問題の重点対策 2019」だけで乗り切れた方がコスパが良い気がします.

具体的な勉強法

勉強の方法について記載します.
社会人のため基本的にはまとまった学習時間を確保することが難しいためコツコツ勉強するスタイルで学習しました.他のブログやネット記事では応用情報は1ヶ月勉強すれば受かるみたいな記事を見かけたりしますが,私の感覚としてはまとまった時間が確保できる人向けの勉強法だと思います.社会人であれば少なくとも3ヶ月くらいは勉強時間を確保した方が無難かと思います.

では,午前対策,午後対策,直前対策の3つに分けて個別に勉強方法を説明していきます.

【午前対策】通勤時間での1問1答

午前試験対策の開始時期は2020年2月から教本にてはじめました.
しかし,1ヶ月で教本を軽く読んで全体像を掴んだそれ以降の2020年3月からは教本にはほとんど触れず,通勤時間を活用して出勤と帰宅の時間で合計20問を解くという方法で勉強を繰り返しました.期間的には7ヶ月の間で約3000問を解いてましたが,最後の方は過去問と回答を覚えてしまうくらいには取り組んだかと思います.
この方法は習慣化してしまえば苦なく取り組めるので,長時間机に向かうのが苦手な人にはオススメです.

【午後対策】仕事終わりの1時間で午後対策

午後試験対策は仕事から帰宅後に「応用情報技術者 午後問題の重点対策 2019」の演習問題を1問を解くという方法で勉強していました.こちらも午前対策と同様に苦なく勉強するためには良いと思います.私自身は休日にまとまった時間を取ることができない訳ではなかったのですが,不定期に予定があったりして習慣化するのが難しいと思ったために平日にコツコツやるようにしました.
また,午後試験では11問から5問を選択して回答するため,解く問題を事前に決めて分野を絞って勉強する方がいますが,私は敢えて重点対策の演習問題の全てを解いていました.理由は大きく2つあって,試験時に難しい問題に直面した時に別の問題を解けるようにというリスクヘッジと午後試験の特徴である記述問題に対する慣れを獲得するためです.これは非常に効果があると思っていて,実際に本試験でも受験前はネットワークの分野を解く予定だったのですが,受験中に問題を見て意外と回答しづいらい問題だなと感じたために別の問題を解くことにしました.こういったイレギュラーな対応にも焦ることなく試験に臨むことができるように準備しておくのが良いと思います.

【直前対策】過去問演習

2020年9月の試験1ヶ月前からは過去問を使った演習を時間が取れる範囲で実施していました.午前と午後のどちらも実施することで問題の時間配分や試験イメージを掴むという感じです.
直近の3年分の過去問を解きましたが,午前試験は過去問と同じ問題が出題されることもあるので多く解くことにも意味があるかと思いますが,午後試験は同じ問題が出題されることはないので試験傾向を掴むという意味では1年分をしっかり解くだけでも十分かと思います.(重点対策の本で対策は実施しているため)

試験

さて,最後に実際の試験についてです.

令和2年秋期の試験形式は 2015年以降の形式からの変更はなく以下のような時間と問題数になります.

午前 午後
試験時間 9:30~12:00(150分) 13:00~15:30(150分)
出題形式 多肢選択式(四肢択一) 記述式
出題数
解答数
出題数: 80問
回答数: 80問
出題数: 11問
解答数: 5問

令和2年秋期試験は午前試験が難化したとネットでは騒がれていました.しかし,個人的にはあまり難化したという感覚はなくこれまで通りの難易度だと感じました.過去試験で出題された問題と全く同じ問題も約10問くらいあり,午前対策をしっかり実施していればこれらを高速に解くことで安定して点数を確保することができると思います.また,他の問題にしっかり時間をかけて解くことができるようにもなるため過去問をたくさん解くことは重要なポイントだと言えます.

続いて午後試験ですが,私は11問中から以下の5問を選択して回答をしました.

当初の予定では前章でも記載した通りネットワークを回答する予定だったのですが,非常に取り掛かりづらかったため組み込みシステム開発を別途切り替えて選択してます.
令和2年秋期のネットワーク問題ではVDIを導入する問題を取り扱っていたのですが,セッション管理などの仕組みに関しても試験では問われていたため確実に得点する自信がなかったことが要因です.
ちなみに私の個人的な感覚ですが,やはり実務経験がある方が午後試験を解く際に有利に働くのは往々にしてあると思います.今回のVDIのテーマも昨今のテレワーク導入の話と近しい内容で実務経験がある方の方が試験問題の全体イメージが湧きやすく解きやすかったかと言えます.また,情報システム開発における問題ではスクラム開発をテーマとして扱っており,スクラム開発を経験したことがある方であれば問われている内容が基本的なことばかりで,非常に簡単な問題でした.
選択問題の5つのうち2つを確実に得点できるようであれば合格率が格段に上がるので,何かしらでIT関連の経験がある人はまずは自分の経験と関連する分野を選択することをお勧めします.

合格判定

令和2年秋期の 合格発表日は2020年12月25日 となっております.
まだ合格発表はこれからなので解答速報をベースに採点した結果になりますが,自己採点結果は以下となっています.

  • 午前試験: 90点
  • 午後試験: 74点

現時点では合格ラインは超えていると思っておりますが,早く合格発表して欲しいところですね.特に午後試験は記述ということもあり,採点者がどのような基準で採点をしているのかによって多少の前後があるかと思うので...
実際の合格発表の結果はこちらで記載しています.

まとめ

今回は令和2年秋期の応用情報技術者に関する勉強法と試験傾向について記載しました.
これから勉強・受験する人の手助けに少しでもなればと思います.特に社会人でまとまった時間が取れない人や長期間でコツコツ勉強するタイプの人の参考になれば幸いです.
試験もあったため少しブログ更新の頻度が下がっていたのでこれからはデータ分析や開発関連の情報を定期的に発信して行こうと思います.