Introduction こんにちは、データサイエンティストの善之です。 Insight Edgeの分析チームでは、有志が技術テーマについて1時間枠で講義し、チーム内でディスカッションを行う「技術研修会」を不定期に実施しています。 先日の研修会では、チーム内でのアンケート結果から最も希望が多かった「プレゼン資料作成術」をテーマに実施しましたので、そのレポートを行います。 技術とは少しテーマがズレますが、他の技術的テーマよりも希望が多く、他部署（開発チーム・管理部）からも参加希望があるなど、皆さん関心の高いテーマだと感じました。 今回は私の前職（コンサルティングファーム）での経験をもとに、プレゼン資料作成術についてお話ししました。 slackでのアンケート結果 目次 講義内容 ①全体のストーリーライン&各スライドのメッセージを作る ②各スライドのチャートを作成 ③ページをレイアウトする ④見やすいデザインに整える 当日の質疑内容 実施後アンケートの結果 まとめ 参考書籍 講義内容 まずはIntroductionとして「ありがちなスライド作成のプロセス」「あるべきスライド作成のプロセス」についてお話ししました。 私の経験上、ありがちなスライド作成のプロセスは ① 各スライドのチャートを作成 ② 各スライドのメッセージを作成 ③ 見やすいデザインに整える ④ 全体のストーリーラインを作成 という手順が多いです（私も以前はこの手順で作成していました）。 しかし、この手順でスライドを作成すると ボツになるスライドやストーリーからずれるスライドが大量に生成される 結局何が言いたいのかよくわからない資料になる場合が多い といった問題が起こりがちです。 そこで、今回の研修会で紹介した手順はこちらです。 こちらのプロセスは ① 全体のストーリーライン&各スライドのメッセージを作る ② 各スライドのチャートを作成 ③ ページをレイアウトする ④ 見やすいデザインに整える という順序です。 こうすることで メッセージとストーリーをサポートする必要十分なスライドが生成される 言いたいことがストレートに伝わる ようになります。 今回の研修会では、この4ステップについて、それぞれ詳細にお話ししました。 ①全体のストーリーライン&各スライドのメッセージを作る このパートでお伝えしたことは主に2つです： まずロジックツリーを書いてから、各スライドのメッセージとストーリーラインを作る（いきなりスライドを作り始めない） メッセージには必ず解釈を含める 特にロジックツリーをまず書くことが最も重要です。 有名な「雲雨傘」を例に、ロジックツリーからストーリーラインに落とし込む方法を紹介しました。 ②各スライドのチャートを作成 このパートでお伝えしたことは、「チャートは基本的にテンプレートから選びましょう」ということです。 一般的なビジネスのプレゼン資料であれば、チャートの「型」があるので、そこから選べばスライド作成時間も短縮されますし、受け手にとっても「よく見るチャート」なので理解がしやすくなります。 そこでこのパートでは、定性・定量に分けてチャートのテンプレートを紹介しました。 定性チャートとしては、ツリー、テーブル、マトリックス、分岐図などを紹介しました。 こちらはツリーの例です。定性的な要素分解にも使えますし、エンジニア/データサイエンティストであれば複雑な計算式を分解する際にも便利です。 定量チャートとしては、横棒グラフ、積み上げ棒グラフ、ウォーターフォール、折れ線グラフなどを紹介しました。 こちらは横棒グラフの例です。データサイエンティストであれば、アルゴリズムの性能比較などでもよく使えるグラフです。 ③ページをレイアウトする このパートでお伝えしたことは、レイアウトについてもチャートと同じくテンプレートから選びましょうということです。 基本的なテンプレートはこちらの3種類になります。 研修会では、実際に具体的なスライド例を示しながら、チャートのレイアウト方法について解説しました。 例えば、こちらは「単一チャート（補完情報あり）」の例で、データ処理の結果・解釈を補完する際に用いるレイアウトです。 ④見やすいデザインに整える 最後にここまでで作成したスライドを見やすいデザインに整えますが、 こちらについては素晴らしい書籍がたくさんあるので、詳しい解説は行いませんでした。 紹介した書籍は記事末尾の 参考書籍 に記載しました。 ただし、あまり書籍に書いていないポイントとして 文字の大きさは12pt以上に 細部にこだわる の2点を紹介しました。 当日の質疑内容 一通り説明を行った後、QAセッションを行いました。 当日は活発な議論があり、例として以下のようなQAがありました。 Q: 資料に情報をどの程度詰め込むべきでしょうか？今日紹介いただいた資料よりも情報を詰め込む場合もあれば、もっと情報量が少ない場合もあると思います A: 情報を詰め込みすぎると分かりづらくなるので、1スライド1メッセージが基本です。一方で、ビジネスのプレゼン資料は打ち合わせに出ていない人が読む場合があるので、口頭補足がなくとも意図が明確に伝わる程度には情報を入れた方が良いです。 Q: グラフは何で作ると良いですか？Matplotlibの場合、綺麗なグラフを作ることが難しいと感じています。 A: 分析時はMatplotlibが便利ですが、最終的に資料化する際はExcelで作成して見た目を綺麗にするのがオススメです。 実施後アンケートの結果 実施後に、今後の参考のためにアンケートを実施しました。 参加者37名中19名に回答いただきました。 Q.1 研修の内容は今後のご自身の業務に活用できると思いますか 5段階で評価いただきましたが、ありがたいことに回答者全員の方に「とてもそう思う」と回答いただきました。 Q.2 具体的に活用できそうなポイントを教えてください 自由記述で記載いただきましたが、研修会で紹介した①-③の内容全般について、さまざまなコメントをいただきました。 ①全体のストーリーライン&各スライドのメッセージを作る 資料作成の考え方（特に設計⇨作成）を活用すると資料・業務が変わると思いました。 メッセージを絞るところとか、先にストーリーを作るとか、全体的に色々ためになるお話でした! ②各スライドのチャートを作成 紹介いただいた定性チャートのテンプレートが今後活用できると思いました チャートの選び方が業務に活かせると感じました 業務における資料作成を行う指針ができたため、迷うことが減り早く作成ができそうです。 ③ページをレイアウトする 見やすいスライド構成（タイトル、メッセージ、チャート）やチャートの補完情報をどう書くかというのがとても勉強になり、活用できそうです。 Q.3 研修内容の改善点があれば教えてください こちらについては演習とフィードバックを設けた方が良いという意見をいただきました。 今回は一通り説明した後にQAセッションという形を取りましたが、もう少し時間を拡大して演習を入れると、より効果的かもしれません。 workshopなども開催して、体に染み込ませる取り組みがあると良いと感じました。 演習時間を実際に取って、作業内容に対してフィードバックする時間があると良いと感じました。 1スライド1メッセージの原則に則りメッセージについて考えるパートもあればより良いと感じました。 Q.4 プレゼン資料作成に関して、追加で取り扱ってほしい内容があれば教えてください こちらについては、より実践を見据えて社内の資料レビュー会であったり、そもそも資料の種別ごとに推奨のテンプレートを用意した方が良いというご意見がありました。 テンプレートの用意については、前々から社内で声が上がっていたこともあり、現在整理を進めている状況です。 社内でよく使われる具体的な資料テーマや実際の資料を使いながらのレビュー会も面白そうと思いました。 どのような資料を作れば良いかについても体系的に整理していただけるとありがたいです（相談があった時にどのような構成の提案資料とすれば良いか等）。 まとめ 研修会を実施してみて、アンケートでもたくさんのポジティブなご意見をいただきましたし、 その後実際に研修会の内容を参考に資料作成いただいているという嬉しい声を複数の方からいただきました。 技術者であっても資料作成の機会は意外と多く、その方法論が分からず困っている場合がそれなりにあるのだと感じました。 アンケート結果を踏まえつつ、今後もプレゼン資料の品質向上と作成効率化に向けた取り組みを行っていければと思います！ 参考書籍 外資系コンサルのスライド作成術―図解表現23のテクニック (山口 周) 伝わるデザインの基本 増補改訂版 よい資料を作るためのレイアウトのルール（高橋 佑磨, 片山 なつ） ノンデザイナーズ・デザインブック [第4版]（Robin Williams）

init_mathjax = function() { if (window.MathJax) { // MathJax loaded MathJax.Hub.Config({ TeX: { equationNumbers: { autoNumber: "AMS", useLabelIds: true } }, tex2jax: { inlineMath: [ ['$','$'], ["\\(","\\)"] ], displayMath: [ ['$$','$$'], ["\\[","\\]"] ], processEscapes: true, processEnvironments: true }, displayAlign: 'left', CommonHTML: { linebreaks: { automatic: true } } }); MathJax.Hub.Queue(["Typeset", MathJax.Hub]); } } init_mathjax(); addEventListener("DOMContentLoaded",function(){var a=document.getElementsByClassName("entry-content");if(a)for(var i=0;i こんにちは、InsightEdgeでデータ分析をしている新見です。 今日はUberAIからNeurIPS2019に出た 論文 を紹介します。 この論文では、ベイズ最適実験計画（Bayesian Optimal Experimental Design：BOED）における期待情報利得（Expected Information Gain：EIG）の推定を高速かつ正確に行う新しい手法を提案しています。 BOEDは、限られた実験リソースを効率的に活用するための枠組みですが、EIGの正確な推定が難しいという課題があります。今回紹介する論文では、変分推論の手法を用いることで、高速化を達成しています。 本記事では提案されたEIGの近似式を紹介し、その使用例をコードベースで紹介します。 もくじ もくじ ベイズ最適実験計画（BOED）とは EIGの近似指標 Variational Posterior $\hat{\mu}_{\text{post}}$ Variational marginal $\hat{\mu}_{\text{marg}}$ Variational NMC $\hat{\mu}_{\text{VNMC}}$ Implicit Likelihood $\hat{\mu}_{m+l}$ 近似式の使い分けについて プログラム例:短期記憶モデルの推定 まとめ ベイズ最適実験計画（BOED）とは 一般的に、何かしらの仮説を立証したいときは実験をし、その結果をデータとして取得します。ただし、実験には、時間的金銭的なコストが発生する場合があるので、そのようなケースではなるべく最小の実施回数で仮説を立証できることが望ましいです。このように、効率的な実験条件を設計すること実験計画法と呼びます。たとえば、ある化合物の収量を最大化するための条件の調整や心理学実験における適切な質問の作成等が代表的な例として挙げられます。また、機械学習の枠組みにおいても、最適なハイパーパラメータの探索にこの考え方が応用されています。 ベイズ最適実験計画(BOED)は、立証したい仮説をデータ生成プロセスとしてモデリングを行い、シミュレーションした結果得られる情報が最大となるような実験を実施する方法になります。 具体的には、次式で与えられるような期待情報利得(EIG)を最大化するような実験を設計します。変数$\theta$を目標変数とした時、EIGは実験$d$の結果$y$として $$ \text{EIG}(d)=\mathbb{E}_{p(y|d)}[\text{H}[p(\theta)] - \text{H}[p(\theta|y,d)]] $$のように書けます。$\text{H}[\cdot]$はエントロピーを表し、$p(\theta|y,d) \propto p(y|\theta,d)p(\theta)$は実験$d$の結果$y$を得た時の$\theta$の事後分布を表します。 式の意味は、実験とその結果によってどの程度知りたい変数の不確定性が減少したか、その得られた情報の期待値となります。これを最大とするような実験$d^{*}$を選択することがBOEDの目的になります。 しかしながら、一般的にEIGの計算は困難です。事後分布$p(\theta|y,d)$の評価に入れ子となったモンテカルロ積分(NMC)が必要で（この後すぐ説明）、高い計算コストになります。NMC計算の収束速度は、計算量を$T$とした時、$O(T^{-1/3})$となります。 今回提案する近似手法の収束速度は$O(T^{-1/2})$で、NMCよりも良い性質を持つことが証明されています。 EIGの近似指標 EIGの式をさらに書き変えると、 $$ \text{EIG}(d) =　\mathbb{E}_{p(y,\theta|d)}\left[\log \frac{p(\theta|y,d)}{p(\theta)}\right] = \mathbb{E}_{p(y,\theta|d)}\left[\log \frac{p(y|\theta,d)}{p(y|d)}\right] $$となります。 EIGを先ほど述べたモンテカルロ(NMC)で計算する場合の推定式$\hat{\mu}_{\text{NMC}}$は次のように書けます。 $$ \hat{\mu}_{\text{NMC}} = \frac{1}{N} \sum_{n=1}^{N} \log \frac{p(y_{n}|\theta_{n},d)}{\frac{1}{M}\sum_{m=1}^{M}p(y_{n}|\theta_{n,m}, d)} \\ \text{where} \space \theta_{n,m} \sim p(\theta) \space y_{n} \sim p(y|\theta=\theta_{n,0},d) $$上式の計算量は$T=\mathcal{O}(NM)$で、収束速度は$O(T^{-1/3})$です。提案手法では、期待値中の分布関数を近似式で変分的に評価します。 Variational Posterior $\hat{\mu}_{\text{post}}$ 事後分布$p(\theta|y,d)$を変分分布$q_{p}(\theta|y,d)$で近似することを考えます。この時、近似EIGは真のEIGの下限となり、その推定量は$\hat{\mu}_{\text{post}}$は $$ \text{EIG}(d) \ge \mathcal{L}_{\text{post}}(d) = \mathbb{E}_{p(y,\theta|d)}\left[\log \frac{q_{p}(\theta|y,d)}{p(\theta)}\right] \\ \approx \hat{\mu}_{\text{post}} = \frac{1}{N} \sum_{n=1}^{N} \log \frac{q_{p}(\theta_{n}|y,d)}{p(\theta_{n})} $$と表せます。近似分布をパラメトリックに書けると仮定し、以下のSGDを用いて、$\mathcal{L}_{\text{post}}(d) $の最大値を求めます。 $$ \nabla_{\phi}\mathcal{L}_{\text{post}}(d;\phi) \approx \frac{1}{S} \sum_{i=1}^{S} \nabla_{\phi}\log q_{p}(\theta_{i}|y,d;\phi) \space \text{where} \space y_{i}, \theta_{i} \sim p(y,\theta|d) $$ここで、パラメータの更新回数を$K$回とすると、$\hat{\mu}_{\text{post}}$の計算量は$T=\mathcal{O}(SK+N)$で、収束速度は$O(T^{-1/2})$となります。収束の証明は論文を参照してください。 Variational marginal $\hat{\mu}_{\text{marg}}$ 次は、周辺分布$p(y|d)$を$q_{m}(y|d)$で近似することを考えます。この時、近似式はEIGの上限となります。 $$ \text{EIG}(d) \le \mathcal{L}_{\text{marg}}(d) = \mathbb{E}_{p(y,\theta|d)}\left[\log \frac{p(y|\theta,d)}{q_{m}(y|d)}\right] \\ \approx \hat{\mu}_{\text{marg}} = \frac{1}{N} \sum_{n=1}^{N} \log \frac{p(y_{n}|\theta_{n},d)}{q_{m}(y_{n}|d)} $$ $\hat{\mu}_{\text{post}}$の計算時と同様、$q_{m}(y|d,\phi)$の最適なパラメータは$\mathcal{L}_{\text{marg}}(d,\phi)$を最小化することで、計算できます。 Variational NMC $\hat{\mu}_{\text{VNMC}}$ $\hat{\mu}_{\text{post}}$と$\hat{\mu}_{\text{marg}}$はともにNMCよりも高速に収束しますが、近似分布が真の分布に対してバイアスが残る可能性があります。 ここでは、バイアスを低減する為にNMCの計算をベースに、提案分布に近似分布を用いることで高速化を考えます。この時、EIGの変分上限として $$ \text{EIG}(d) \le \mathcal{L}_{\text{VNMC}}(d;M) = \mathbb{E} \left[ \log p(y|\theta_{0},d) - \log \frac{1}{M} \sum_{m=1}^{M} \frac{p(y,\theta_{m}|d)}{q_{v}(\theta_{m}|y,d)} \right] \\ \approx \hat{\mu}_{\text{VNMC}} (d)= \frac{1}{N} \sum_{n=1}^{N} \left( \log p(y_{n}|\theta_{n,0},d) - \log \frac{1}{M} \sum_{m=1}^{M} \frac{p(y_{n},\theta_{n,m}|d)}{q_{v}(\theta_{n,l}|y_{n},d)} \right) $$が得られます。 サンプリングは$\theta_{n,0} \sim p(\theta)$,$y_{n} \sim p(y|\theta=\theta_{n,0},d)$, $\theta_{n,m} \sim q_{v}(\theta_{n,m}|y=y_{n},d)$で行います。1サンプル$(\theta_{n,0}, y_{n})$ごとに、$\{\theta_{n,m}\}_{m\ge1}$のサンプルを発生させているイメージです。 $\mathcal{L}_{\text{VNMC}}(d)$の第二項は$p(y|d)=\mathbb{E}_{p(\theta|d)}\left[p(y|\theta,d)\right]$を提案分布$q_{v}(\theta|y,d)$で重み付けした重点サンプリングで計算しています。 たとえ$q_{v}$が真の分布に収束しなくても、$L\rightarrow \infty$とした時、$\mathcal{L}_{\text{VNMC}}(d)$はEIGに収束することが証明されており、バイアスが生じないことが保証されています。 計算は、学習と評価の２ステップに分かれており、学習時の$y$のサンプル数を$S$、$\theta$のサンプル数を$L$、学習ステップを$K$回とした時、計算量は$T=\mathcal{O}(SKL+MN)$となります。NMCの計算量と同じのように見えますが、学習フェーズがあることにより、$M$の値を小さくでき、実際は早く収束します。 Implicit Likelihood $\hat{\mu}_{m+l}$ (なかなかわかりにくい名前ですが)、$y$のサンプリングはできるけど、明示的に尤度$p(y|\theta,d)$を計算できない場合に使える手法になります。 例えば、潜在変数$\psi$を有するモデル$p(y|\theta, d)=\mathbb{E}_{p(\psi|\theta)}\left[p(y|\theta, \psi, d)\right]$はよく見かけますが、これはサンプルは簡単に計算できるものの、尤度の計算は困難なことが多いです。 ここでは、周辺分布$q_{m}(y|d)$と尤度$q_{l}(y|\theta,d)$の２つを変分分布で近似した上で、EIGを計算します。 $$ \text{EIG}(d) \approx \mathcal{I}_{m+l}(d) = \mathbb{E}_{p(y,\theta|d)}\left[\log \frac{q_{l}(y|\theta,d)}{q_{m}(y|d)}\right] \\ \approx \hat{\mu}_{m+l} = \frac{1}{N} \sum_{n=1}^{N} \log \frac{q_{l}(y_{n}|\theta_{n},d)}{q_{m}(y_{n}|d)} $$ これまでの手法と違って、$\mathcal{I}_{m+l}(d)$は上限、下限ではないので、この値をターゲットとして、$q_{m}(y|d)$と$q_{l}(y|\theta,d)$を学習できません。 幸い、以下の不等式が成り立つのとで、次式の右辺を最小化することで学習可能です。 $$ |\mathcal{I}_{m+l}(d) - \text{EIG}(d)| \le - \mathbb{E}_{p(y,\theta|d)}\left[\log q_{l}(y|\theta,d) + \log q_{m}(y|d)\right] $$ $q_{l}$と$q_{m}$は別々のパラメータとしても、$q_{m}(y|d)=\mathbb{E}_{p(\theta|d)}\left[q_{l}(y|\theta,d)\right]$を利用してパラメータを共有しても学習可能です。 近似式の使い分けについて $\hat{\mu}_{\text{VNMC}}$は唯一バイアスが生じない手法なので、計算コストが許容できる場合は、優先して利用すべき選択となります。その上で、$y$と$\theta$それぞれの次元数の大小と尤度$p(y|\theta,d)$を陽的に計算できるかを基準に使い分けることができます。 $\hat{\mu}_{\text{post}}$と$\hat{\mu}_{\text{VNMC}}$は$\theta$に対する近似分布を、$\hat{\mu}_{\text{marg}}$と$\hat{\mu}_{m+l}$は$y$に対する近似分布を利用しています。よって、$\dim(y) \ll \dim(\theta)$の場合は、より推定が容易になる$\hat{\mu}_{\text{marg}}$と$\hat{\mu}_{m+l}$を利用することが望ましいです。その上で、陽的に尤度$p(y|\theta,d)$を計算できる場合は$\hat{\mu}_{\text{marg}}$を、できない場合は$\hat{\mu}_{m+l}$を利用することが推奨されます。$\hat{\mu}_{\text{post}}$は陽的な尤度評価が必要ないので、そのような時に利用できます。 プログラム例:短期記憶モデルの推定 今紹介した手法を、確率プログラムPyroで実装した例が 公式 にありましたので、紹介します。 人は最大７つのことまでは短期記憶で覚えることができると言われています。ここでは、ある集団の短期記憶を測定する実験を考えたいと思います。 まず、短期記憶をモデル化し、そのパラメータを推定するための実験計画を考えてみます。 短期記憶のモデルを簡単に以下のように設定します。 $$ p(\theta) = \text{N}(\mu_{pre}, \sigma_{pre}^{2}) \\ p(y|\theta,d) = \text{Bernoulli}(p=\text{sigmoid}(k(\theta - d)) $$$d$は実験で提示する数列のサイズを、$y$は答えられたかどうかの結果を表します。たとえば、$d=5$の場合、$(1,2,3,2,5)$のような5つの数列を提示された時、全て正しく答えられた場合は$y=1$となります。$\theta$はこの実験における短期記憶の容量を表します。モデル上では50/50の確率で正解できる最大の数列数を意味します。 以下のコードは、上記のモデルをPyroで実装したものです。 sensitivity = 1.0 prior_mean = torch.tensor( 7.0 ) prior_sd = torch.tensor( 2.0 ) # theta ~ p(theta), y ~ p(y|theta, d) def model (d): # Dimension -1 of `l` represents the number of rounds # Other dimensions are batch dimensions: we indicate this with a plate_stack with pyro.plate_stack( "plate" , d.shape[:- 1 ]): theta = pyro.sample( "theta" , dist.Normal(prior_mean, prior_sd)) # Share theta across the number of rounds of the experiment # This represents repeatedly testing the same participant theta = theta.unsqueeze(- 1 ) # This define a *logistic regression* model for y logit_p = sensitivity * (theta - l) # The event shape represents responses from the same participant y = pyro.sample( "y" , dist.Bernoulli(logits=logit_p).to_event( 1 )) return y 今回は、$\hat{\mu}_{\text{marg}}$を計算することでEIGを推定します。その為には、$q_{m}(y|d)$を変分近似する必要がありました。以下のコードでは、その実装です。候補となる実験それぞれにパラメータを割り振っています。 # q(y|d) def marginal_guide (design, observation_labels, target_labels): # This shape allows us to learn a different parameter for each candidate design l q_logit = pyro.param( "q_logit" , torch.zeros(design.shape[- 2 :])) pyro.sample( "y" , dist.Bernoulli(logits=q_logit).to_event( 1 )) 以下は、EIGを計算するコードになります。 marginal_eig 関数の引数として上で定義した$p(y,\theta|d)$と近似分布$q_{m}(y|d)$を与えています。 また、陽に観測値と潜在変数のラベルを指定する必要があります。これは、 model と marginal_guide 関数の中で指定したラベルと一致する必要があります。加えて、実験候補を candidate_designs として与えます。ここでは次元を [N, 1] として、 N 人に対して1回ずつ実験をを行っているイメージです。 from pyro.contrib.oed.eig import marginal_eig # The shape of `candidate_designs` is (number designs, 1) # This represents a batch of candidate designs, each design is for one round of experiment candidate_designs = torch.arange( 1 , 15 , dtype=torch.float).unsqueeze(- 1 ) pyro.clear_param_store() num_steps, start_lr, end_lr = 1000 , 0.1 , 0.001 optimizer = pyro.optim.ExponentialLR({ 'optimizer' : torch.optim.Adam, 'optim_args' : { 'lr' : start_lr}, 'gamma' : (end_lr / start_lr) ** ( 1 / num_steps)}) eig = marginal_eig(model, candidate_designs, # design, or in this case, tensor of possible designs observation_labels = [ "y" ], # site label of observations, could be a list target_labels = [ "theta" ], # site label of 'targets' (latent variables) num_samples= 100 , # number of samples to draw per step in the expectation num_steps=num_steps, # number of gradient steps guide=marginal_guide, # guide q(y) optim=optimizer, # optimizer with learning rate decay final_num_samples= 10000 # at the last step, we draw more samples ) ここでは、 marginal_eig 関数内でのlossの計算部分の実装を見てみます.$\hat{\mu}_{\text{marg}}$の計算に相当します。 def _marginal_loss (model, guide, observation_labels, target_labels): """Marginal loss: to evaluate directly use `marginal_eig` setting `num_steps=0`.""" def loss_fn (design, num_particles, evaluation= False , **kwargs): expanded_design = lexpand(design, num_particles) # Sample from p(y | d) trace = poutine.trace(model).get_trace(expanded_design) y_dict = {l: trace.nodes[l][ "value" ] for l in observation_labels} # Run through q(y | d) conditional_guide = pyro.condition(guide, data=y_dict) cond_trace = poutine.trace(conditional_guide).get_trace( expanded_design, observation_labels, target_labels ) cond_trace.compute_log_prob() terms = - sum (cond_trace.nodes[l][ "log_prob" ] for l in observation_labels) # At eval time, add p(y | theta, d) terms if evaluation: trace.compute_log_prob() terms += sum (trace.nodes[l][ "log_prob" ] for l in observation_labels) return _safe_mean_terms(terms) return loss_fn Pyroでは、 poutine.trace(model) を使って、モデルの内部状態をトレースすることができます。このオブジェクトに model と同じ引数を与えた上で get_trace を呼ぶことで、サンプリングを行い、内部変数の情報を取得できます。 上の例では、まず model の定義に従い$y$のサンプリングを行い、その結果を y_dict に格納しています。 次に、 guide で定義された$q(y|d)$を結果 y_dict で条件付けを行い、対数尤度を計算しています。得られた対数尤度の平均をlossとして$q(y|d)$のパラメータを最適化しています。 評価時では、学習時には不要だった$p(y|\theta,d)$の対数尤度を加算し、その値を最終的なEIGの推定値としています。 上の marginal_eig の結果をplotしたものが以下になります。 plt.figure(figsize=( 10 , 5 )) matplotlib.rcParams.update({ 'font.size' : 22 }) plt.plot(candidate_designs.numpy(), eig.detach().numpy(), marker= 'o' , linewidth= 2 ) plt.xlabel( "$d$" ) plt.ylabel( "EIG($d$)" ) plt.show() eig ここでは、EIGの最大値は$d=7$となりました。初回なので、事前分布の平均に引っ張られる形となりました。 紹介したリンクでは、その後上の操作を繰り返し、$p(\theta)$の更新とEIGの計算を繰り返し、最適な事後分布の算出しています。興味がある方は参考にしてみてください。 まとめ 今回は、実験計画法における期待情報利得の計算時の変分ベイズ法の適用について紹介しました。データの発生プロセスをモデル化するというハードルはあるので、使いどころは限定される印象です。しかし、実験のコストが高い場合において、より効率的に仮説を立証するためにどのような実験計画を組むべきかを定量的に評価できるのはメリットといえるでしょう。

こんにちは。InsightEdgeのDataScientistのSugaです。最近もサウナに通っていますが、サウナ好きのなかではオロポという飲み物があります。 オロナミンC+ポカリスエットというもので独特な味がして気にっています。さて、今回は、生成AIを駆使して、バーチャル水田で稲作をシミュレーションしてみようと思います。 取り組むきっかけ 最近のニュースから 最近のニュースを見ていたら、「農林水産省、「天穂のサクナヒメ」とコラボ」という記事がありました。知らない方もいると思うので、少し説明すると、「天穂(てんすい)のサクナヒメ」というゲーム作品が2020年にリリースされました。ゲームの中で米作りの工程をする必要があり、その内容がとてもリアルだと話題になりました。さらに、農林水産省の公式WEBサイトがゲームの攻略に使えるということがわかり、そのことがニュースになっていたりしました。 Youtube : アニメ「天穂のサクナヒメ」とのコラボに寄せて　坂本農林水産大臣メッセージ 農林水産省のプレスリリース より 2020年に原作ゲームが発売された当時、「田起こし」「種籾選別」「田植え」等の米作りの工程が非常にリアルだと大きな話題になり、また、農林水産省の公式ウェブサイトがゲーム攻略に使えると評判にもなりました。 このようなご縁もあり、この度のテレビアニメ化にあたり、正式にコラボする運びとなりました。サクナヒメたちとともに、「生きるための食べものを作る大切さ」、「仲間とともに食卓を囲む喜び」、そして「お米の魅力」をお伝えしてまいります。多くの皆さまに、食や農林水産業について興味や関心を持っていただけるきっかけになることを期待しています。< 農業xTech 近年の世界人口の増加や気候変動もあって食料安全保障の問題に対応するためにも農業分野には注目が集まっていると思います。特にIT技術を使った農業の発展には著しいものがあります。 技術革新の例としては、 IoTデバイスやセンサーデバイスの活用：作物や家畜のリアルタイム監視と管理を可能にします。センサーは土壌の湿度、温度、植物の健康状態を追跡し、自動化された灌漑システムは正確なデータに基づいて最適な灌漑をします。 精密農業：衛星データやセンサーデータなど様々な情報源から畑の詳細な区分レベルで管理をして、植え付け、施肥、収穫といった管理の意思決定をデータを用いて行います。 農業ロボット：従来は農業機械を人が操作して行っていた除草や収穫などを自律ロボットが自動で作業します。これにより単純な機械化よりも効率化して、労働コストを削減するものです。 再生農業：土壌の健康と生物多様性を回復させることに焦点を当てるなど、耕作しない農法、カバークロップの利用、輪作放牧などの技術を含みます。これにより、土壌構造が改善され、侵食が減少し、長期的な持続可能性と生産性向上を目指した取り組みです。 データ活用やクラウド技術活用：精密農業と関連しますが、広範なデータ収集と分析によって作物管理するものです。さらに発展させて、収穫量予測、灌漑量予測、可変施肥予測などを行います。 これらの取り組みでは従来の農業分野で活躍していた、農家や農業研究者、農学者、農業経済学者だけではなく他の分野の専門家も農業分野に進出して、協力して技術開発が行われています。 稲作について 　米は世界で最も重要な穀物の1つで、多くの国で主食として広く消費されています。米の栽培は約10,000年前にアジアで始まったとされ、特に中国、インド、タイなどが古くからの主要産地です。現在では、世界中の熱帯・亜熱帯地域で広く栽培されています。米は温暖な気候を好みます。最適な気温は20℃から30℃で、特に生育期には十分な日光が必要です。多くの品種が水田で栽培され、水の管理が重要です。水田は、稲の根が常に水に浸かっている状態を保つため、灌漑システムが必要となります。 さらに、米は肥沃な粘土質の土壌でよく育ち、土壌のpHは5.5から7.0が適しているといわれています。米には数多くの品種があり、大きくジャポニカ種（短粒種）とインディカ種（長粒種）に分類されます。ジャポニカ種は、日本や韓国、中国北部で多く栽培され、粘り気が強く、寿司やおにぎりに適しています。インディカ種はインド、タイ、ベトナムなどで広く栽培され、パラパラとした食感が特徴です。バスマティ米やジャスミン米が代表的です。 日本では、米は主食として広く消費されており、稲作は農業の中心的な役割を果たしています。主要な稲作地域としては、新潟、秋田、山形などの県が挙げられます。近年では、品種改良や農業技術の進歩により、より高品質な米の生産が可能となっています。 稲作の基本プロセス 田んぼの準備 田んぼの準備が行われます。これは、耕起と呼ばれる土壌を耕す作業から始まります。耕起により、土壌が均一に整えられ、稲の根が張りやすくなります。次に、代かきが行われます。これは、田んぼに水を張り、土を泥状にして均一にする作業です。代かきにより、田んぼ全体が均一な状態となり、苗が均等に育ちやすくなります。 苗の育成 田んぼの準備が整ったら、次に苗の育成が始まります。まず、種もみを苗床にまき、苗を育てます。この段階を種まきと呼びます。苗床で育った苗は、苗代と呼ばれる場所に移され、一時的に育てられます。ここで苗が十分に育つまで待ちます。 田植え 苗が十分に育ったら、田植えを行います。田植えは、育てた苗を田んぼに植える作業です。手作業で行う手植えと、機械を使う機械植えがあります。機械植えは、大規模な稲作地帯でよく使われ、効率的に作業を進めることができます。 生育管理 田植えが終わったら、生育管理の段階に入ります。この段階では、水管理、施肥、除草などが行われます。水管理は、稲の成長に必要な水を適切に供給し、過剰な水を排水する作業です。施肥は、稲に必要な栄養分を補うために肥料を与えることです。除草は、田んぼの中の雑草を取り除く作業です。これらの作業を通じて、稲が健康に育つ環境を維持します。 収穫 稲が成熟したら、収穫の時期となります。収穫は、稲刈りと呼ばれ、手作業で行う手刈りと機械を使う機械刈りがあります。 乾燥と脱穀 収穫された稲をまず乾燥させます。乾燥により、稲から余分な水分を取り除きます。次に、脱穀が行われます。脱穀は、稲のもみを取り除く作業です。脱穀されたもみは、玄米として保存されます。 精米 最後に、玄米を精米して白米にする作業が行われます。精米により、玄米の外皮が取り除かれ、白くて美しい米が出来上がります。この米が最終的に食卓に並ぶことになります。 稲作は一連の精密なプロセスを経て行われ、このように各段階で適切な管理と作業が求められます。 対象の作物選定 今回のTechblogを書くにあたっては、作物の題材を決める必要があり、その題材として当初は「コーヒー」を選んでいました。単純に自分がコーヒー好きという理由からです。しかし、調査をしてみると、コーヒーはとても情報が少ないことに気づきました。 研究例としては、 コロンビアのサンタ・マルタ山脈地方でスペシャリティコーヒー栽培に作物モデルを適用した例（Vega Molina et al., 2018） がありました。この研究では特定の農業気象条件で生産性を予測することに成功したという内容です。ただ、コーヒーは主要作物ではないため、元となるデータが少なく手元で再現することが難しかったために、以後の対象作物は「米」にしています。 作物モデル研究 農業研究の分野として、作物モデルを用いるものがあります。これは、作物成長をシミュレーションするための数理モデルです。作物の生理学的過程の理解を深めて、農業生産の効率化や最適化を図る目的で研究されています。そのなかでも、いつくかの種類があり、経済モデルといわれる少し大きなマクロな視点で統計的にモデリングする手法やプロセスベースモデルといった、光合成、呼吸、蒸散など生理学的過程をシミュレーションするものなどがあります。 作物モデルを使うことによって、気候変動の影響評価や農業経営支援や農業政策など広範に利用することが出来ます。ですので、世界中の研究者によって様々な研究が行われてきました。 代表的な作物モデル： DSSAT（Decision Support System for Agrotechnology Transfer）: 作物の生育、収量、リソース利用をシミュレートする総合的なモデルシステムです。多くの作物と気象条件に対応しており、研究や実務で広く使用されています​。特徴としては、多種多様な作物（穀物、野菜、果物など）をモデリング可能であり、土壌、水分、気象データを統合して作物の成長をシミュレートできます。作物管理の決定支援、収量予測、環境影響評価に使用されます。 APSIM（Agricultural Production Systems Simulator）: 作物、家畜、気象、土壌の相互作用をシミュレートするためのモデルで、農業システムの管理と持続可能性を評価するために使用されます​。特徴としては、作物と気象条件の詳細なシミュレーションが出来て、土壌水分動態、栄養素循環、作物管理オプション、作物ローテーション、混作システムの評価に使用できます。 CERES（Crop Environment Resource Synthesis）: トウモロコシ、米、小麦などの主要作物の成長と収量を予測するためのモデルです。土壌、水分、気象データを使用して作物の生理学的過程をシミュレートします。特徴としては、作物の成長、生理学的プロセスの詳細なシミュレーションを行い、天候、土壌、管理条件に基づく収量予測や作物生育の段階的なモデル化に対応していることです。 シンプルな作物モデル 稲作の成長をシミュレーションするにあたって、シンプルな作物モデル成長モデルを実装して、原理を確認しました。モデルとしては土壌栄養素と水分を消費して作物が育つようにしました。 サンプルコードは以下のようになります。 import numpy as np import pandas as pd import matplotlib.pyplot as plt from scipy.integrate import odeint # 作物成長モデルの定義 def crop_growth (y, t, params): C, N, W = y # C:作物バイオマス, N:土壌栄養素, W:土壌水分 k1, k2, k3 = params # 成長率、栄養素吸収率、水分吸収率 dCdt = k1 * N * W dNdt = -k2 * C * W dWdt = -k3 * C * N return [dCdt, dNdt, dWdt] # 初期条件とパラメータの設定 initial_conditions = [ 1 , 1 , 1 ] # 初期バイオマス、栄養素、水分 params = [ 0.1 , 0.05 , 0.02 ] # 成長率、栄養素吸収率、水分吸収率 t = np.linspace( 0 , 100 , 100 ) # シミュレーション期間 # シミュレーションの実行 result = odeint(crop_growth, initial_conditions, t, args=(params,)) C, N, W = result.T # 結果のプロット plt.figure(figsize=( 10 , 6 )) plt.plot(t, C, label= 'Crop Biomass' ) plt.plot(t, N, label= 'Soil Nutrients' ) plt.plot(t, W, label= 'Soil Moisture' ) plt.xlabel( 'Time' ) plt.ylabel( 'Quantity' ) plt.legend() plt.title( 'Crop Growth Simulation' ) plt.show() 実行結果は以下のようになります。時間の経過とともに作物が成長して、土壌栄養素と水分が減少する様子を示しています。このモデルは、作物成長における基本的な相互作用をシンプルに表現したものです。 シンプルな作物モデルのシミュレーション結果 米の作物モデル 今回のTechBlogのテーマとしては、実際に米の作物モデルを実験してシミュレーションしてみることを目的としたので、ChatGPTに米の作物モデルで使いやすいものはあるかを聞いて見ました。その結果、 PCSE（Python Crop Simulation Environment） というライブラリがあることや、シミュレーション手順についても教えてくれました。PCSEはオランダで開発されたPythonパッケージです。 適用できる作物モデルとして WOFOST(WOrld FOld Studies) というものがあります。 一年生作物の成長と生産を定量的に分析するためのモデルだそうです。 実行手順 PCSEを使用して米のシミュレーションを行うためには、まず米に関する適切なパラメータセット、天候データ、土壌データ、そして農業管理データを準備する必要があります。以下にその手順を詳細に説明します。こちらもChatGPTに聞いたら見事に答えてくれていました。 手順 1.パラメータセットの準備 米の成長に関するパラメータセット（作物データ、土壌データ、サイトデータ）を準備します。これらのデータは、PCSEの提供するフォーマットに従って準備する必要があります。 作物データ：米の成長段階、光合成効率、呼吸率、成長期間などの生理学的パラメータ。 土壌データ：土壌の物理的・化学的特性（水分保持能力、浸透率、栄養素含有量など）。 サイトデータ：地理的特性（水分バランス、CO2濃度など）。 2.天気データの取得 PCSEは様々な天気データプロバイダーをサポートしています。NASA Power Weather Data Providerを使用して、シミュレーションに必要な天気データ（温度、降水量、日照量など）を取得します。 3.農業管理データの作成 農業管理データ（例えば、播種日、灌漑スケジュール、施肥計画など）をYAML形式で作成します。 4.モデルの設定とシミュレーションの実行 これらのデータを使用して、PCSEのWOFOSTモデルを設定し、シミュレーションします。 シミュレーション実行 シミュレーションコードもChatGPTに聞いて見ましたが、こちらは全くうまくいかずにある程度の限界があることに気づきました。ですので、PCSEの本家のサイトを参考にシミュレーションコードを実行してみました。 関連モジュールのインポートとバージョン確認 まずはpip install pcseを実行してライブラリをインストールした後で、インストールがされているかの確認します。 %matplotlib inline import sys from pathlib import Path import matplotlib matplotlib.style.use( "ggplot" ) import matplotlib.pyplot as plt import pandas as pd data_dir = Path.cwd() / "data" import pcse print ( "This notebook was built with:" ) print (f "python version: {sys.version}" ) print (f "PCSE version: {pcse.__version__}" ) 作物パラメータの指定 作物固有のパラメータが提供されているので、ここでは作物と品種の指定を行います。このパラメータはフェノロジー(Phenology)と呼ばれる成長段階や成長ステージを表すものが表現されていて、特定の気象条件や時間経過に基づいて育成をシミュレートします。また、同化(Assimilation)と呼ばれる作物が光合成によって二酸化炭素を取り込み、有機物を生成するプロセスも含まれます。光合成の効率は光強度、温度、CO2濃度、葉面積などに影響されます。 さらに、呼吸(Respiration)という植物がエネルギーを消費して成長や維持活動を行うプロセスもあります。加えて、分配(Partitioning)と呼ばれる植物が生成した有機物を各器官(根、茎、葉、穂など)に対してどのように分配するかも考慮されています。 from pcse.fileinput import YAMLCropDataProvider, CABOFileReader cropd = YAMLCropDataProvider() cropd.set_active_crop( 'rice' , 'Rice_501' ) 土壌パラメータ 土壌の種類と土壌の物理的特製に関連するパラメータを決定します。今回は自由排水土壌(過剰な水分が土壌中に滞留せず、速やかに排出される特性を持つ土壌)、中細砂の土壌ファイルを指定しています。 soilfile = data_dir / "soil" / "ec3.soil" soild = CABOFileReader(soilfile) サイトパラメータ サイトパラメータは作物や土壌に関連しない補助的なパラメータです。初期土壌水分含有量(WAV) や初期および最大表面貯留量(SSI、SSMAX)などの水バランスの初期条件があります。また、大気中のCO2濃度も、典型的なサイトパラメータです。今回はデフォルト値を採用しました。 from pcse.util import WOFOST72SiteDataProvider sited = WOFOST72SiteDataProvider(WAV= 10 ) print (sited) {'IFUNRN': 0, 'NOTINF': 0, 'SSI': 0.0, 'SSMAX': 0.0, 'WAV': 10.0, 'SMLIM': 0.4} パラメータをパッケージ これまで指定してきたパラメータを1つの変数にまとめる。 from pcse.base import ParameterProvider parameters = ParameterProvider(cropdata=cropd, soildata=soild, sitedata=sited) 農業管理 作物を育てるときにどのようなオペレーションをするかを指定します。主な要素は種まきをいつ開始したかや収穫時期の指定などです。このファイルはYAML形式で入力します。今回はデフォルト値を参考にして、米で使えるように少し変更したファイルを用いました。 from pcse.fileinput import YAMLAgroManagementReader agromanagement_file = data_dir / "agro" / "rice_calendar.agro" agromanagement = YAMLAgroManagementReader(agromanagement_file) 天気観測 シミュレーションするには天気の情報も必要です。PCSEには天気データを読み取るためのデータプロバイダーの機能もあります。空間解像度0.5度(約50km)で世界の気象データを提供するNASA PowerDataの気象データを読み込むことが出来ます。今回は日本の新潟市の緯度経度を指定してみました。 from pcse.input import NASAPowerWeatherDataProvider wdp = NASAPowerWeatherDataProvider(latitude= 37.9123837 , longitude= 140.0106058 ) print (wdp) Weather data provided by: NASAPowerWeatherDataProvider --------Description--------- NASA/POWER CERES/MERRA2 Native Resolution Daily Data ----Site characteristics---- Elevation: 551.5 Latitude: 37.912 Longitude: 140.011 Data available for 1984-01-01 - 2024-07-20 Number of missing days: 3 作物シミュレーションの実行 PCSEのエンジンをインポートして、指定した構成ファイルとパラメータで初期化して起動します。その後、シミュレーションした結果を時系列データとして取得します。結果はpandasデータフレームに格納しておきます。 from pcse.models import Wofost72_WLP_CWB wofsim = Wofost72_WLP_CWB(parameters, wdp, agromanagement) wofsim.run_till_terminate() df_results = pd.DataFrame(wofsim.get_output()) df_results = df_results.set_index( "day" ) df_results.tail() シミュレーション結果(テーブル) シミュレーション結果 発育 (Development Stage, DVS) 発育段階 (Development Stage, DVS) は、作物の成長段階を数値化したものです。DVSは通常、0から2の範囲で表され、作物のライフサイクルを以下のように示します。 DVS = 0：播種（種まき）または発芽の段階 DVS = 1：花が咲く段階（開花） DVS = 2：作物が完全に成熟する段階（収穫準備） DVSは、作物の成長に伴う生理的な変化を示すため、モデル内で成長段階ごとの異なるプロセス（例えば、葉の展開、実の形成など）を管理するのに役立ちます。 総バイオマス (Total Above Ground Biomass, TAGP) 総バイオマス (Total Above Ground Biomass, TAGP) は、地上部における作物全体のバイオマス量を示します。これは、作物が光合成によって生成した有機物の総量であり、以下の要素を含みます。 葉：光合成を行う主要な部位 茎：作物の支持構造 穂や果実：作物の収穫部位 TAGPは作物の全体的な成長と生産性を評価する重要な指標です。 葉面積指数 (Leaf Area Index, LAI) 葉面積指数 (Leaf Area Index, LAI) は、単位地表面積あたりの総葉面積の割合を示す指標です。具体的には、以下のように定義されます。 LAI=葉の総面積/地表面積 例えば、LAIが3の場合、地表1平方メートルあたりに3平方メートルの葉面積が存在することを意味します。LAIは、作物の光合成能力を評価するために使用され、光エネルギーの捕捉効率や蒸散量に直接影響します。 根圏土壌水分 (Soil Moisture, SM) 根圏土壌水分 (Soil Moisture, SM) は、根が存在する土壌層の水分量を示します。これは、作物の水利用効率と成長に大きな影響を与えます。SMは以下のような要因に影響されます。 降水量：自然の雨水供給 灌漑：人工的な水供給 蒸発散：土壌からの蒸発と作物からの蒸散による水分損失 土壌の保水力：土壌の種類や構造による水分保持能力。 SMは、作物の水ストレスを評価し、灌漑スケジュールの最適化や水管理戦略の立案に役立ちます。 シミュレーション結果の可視化 シミュレーション結果を表示します。DVSは0からはじまり10月には収穫段階の2まで成長しています。TAGPも順調に量が増えていることがわかります。LAIは8月頃をピークに減少していますが、 過去の調査結果（堀江・桜谷, 2014） を参照する限りにおいては、出穂期ごろに最大値へ達して、その後は減少していくとの記述があるので、この時系列変化で概ねあっているように見えます。また、稲作では「中干し」「土用干し」と言われる夏の時期に田んぼの水を抜いて乾燥させる農法があるため、SMの推移もこれに近いグラフの形になっていると思われます。 fig, axes = plt.subplots(nrows= 4 , ncols= 1 , figsize=( 12 , 12 ), sharex= True ) for var, ax in zip ([ "DVS" , "TAGP" , "LAI" , "SM" ], axes.flatten()): ax.plot_date(df_results.index, df_results[var], 'b-' ) ax.set_title(var) fig.autofmt_xdate() シミュレーション結果(グラフ) まとめと今後 今回は作物モデルを用いて稲作をシミュレーションしてみることをやってみました。この分野自体は初めて調査してみたので、わからないことも多かったですが、あらためて農場分野の専門知識も大切だと感じました。データ分析だけでなくドメイン知識も大事と言われますが、まさにこのことだと思いました。 また、作物モデルにおいては指定するパラメータの数が多かったのでベイズ最適化のようなパラメータ探索と決定といった分野と親和性が高いとも思いました。例えば、収穫量を最大化するようなパラメータを探索してそれを営農に活用するなどまだまだデータを活用できる余地は大きいと思いました。

目次 はじめに GitHub Copilotとは 導入背景と期待効果 なぜGitHub Copilotを導入したのか 組織内の活用状況 GitHub Copilotの利用状況 利用者の声 まとめと今後の展望 まとめ 今後の展望 はじめに Insight Edgeで開発チームのLead Engineerをしている三澤です。 Insight Edgeではチームの開発効率の向上と品質の向上を狙い、さまざまなツールやサービスの検証と導入を進めています。その中で弊社内で活用しているGitHub Copilot Businessについて社内の活用状況を公開します。実際の利用統計の他、ソフトウェアエンジニア・データサイエンティストそれぞれの視点で感想を公開しますので是非ご覧ください。 GitHub Copilotとは GitHub Copilotは、GitHubが提供する開発者がコードをよりすばやく書き込みできるようになるAIを活用したコード補完ツールです。GitHub Copilotは、開発者がコードを書く際に、コードのコンテキストに合わせてコードの補完候補を提案してくれます。これにより、開発者はコードをより迅速に書くことができるようになります。 このGitHub Copilotには3種類のプランがあり、それぞれ図に示すような特徴があります。 我々が導入しているのはGitHub Copilot Businessです。このプランは、個人用アカウントであるGitHub Copilot Individualと比べて、価格が1か月のユーザーあたり19米国ドルと若干高額ですが、その分機能が充実しています。例えば、GitHubのOrganization全体にわたるポリシー管理や、指定したファイルをGitHub Copilotの学習から除外する機能があります。また、Copilot Businessは、Copilot Individualと比べて、パブリックコードに一致する候補をブロックする機能や監査ログの機能があります。これらの機能は、ビジネス用途でGitHub Copilotを使用する際には必要不可欠な機能です。 また、通常のコード中での補完だけでなく、GitHub Copilotと対話できるチャットインターフェイスのCopilot Chatも提供されています。Copilot Chatは、コードの説明や質問にも対応してくれるため、開発者はより効率的にコードを書くことができるようになります。 導入目的と期待効果 なぜGitHub Copilotを導入したのか GitHub Copilotを導入した背景には、以下のような4つの理由があります。 開発効率の向上 コード品質と一貫性の向上 学習曲線の短縮 最新技術トレンドへの適応 それぞれについて詳しく説明します。 開発効率の向上 コードの補完候補を提案してくれるため、開発者はコードをより迅速に書くことができるようになります。これにより、開発効率が向上することを期待できます。 コード品質と一貫性の向上 コードのコンテキストに合わせてコードの補完候補を提案してくれるため、コードの品質と一貫性が向上します。これにより、バグの発生を防ぐことができます。ただしこちらについては注意が必要です。Copilotはあくまで補完候補を提案するツールです。開発者が提案されたコードをそのまま採用するのではなく、提案されたコードを検証し、適切なコードを採用するようにすることが必要になります。 学習曲線の短縮 コードの補完候補を提案してくれるため、開発者はたとえ新しい技術やフレームワークに迅速に適応することができます。これにより、学習曲線が短縮されます。 最新技術トレンドへの適応 AI支援ツールを活用したソフトウェア開発は現在トレンドとなっており、早期に導入することで最新の技術トレンドに迅速に追従することが可能です。これにより、競争力を維持することができます。 以上の4点の効果を見込み、我々は導入を決定し運用してきました。 組織内の活用状況 ここからは、GitHub Copilotの社内活用状況についてご紹介します。 GitHub Copilotの利用状況 弊社では2023年3月からGitHub Copilot Businessを導入し、現在までに約40名の開発者が利用しています。まずは、実際にどれくらいの頻度でどのような言語に対して利用されているかをご紹介します。これらの情報はGitHubが提供するAPIを通じて取得したものです。 統計情報の取得 GitHub Copilotの統計情報はAPIを通じて取得できるため、利用頻度を分析することができます。ただし本APIは直近28日間の情報しか取得できないため、それよりも長い期間をそのまま分析することはできません。長きに渡る利用統計を分析するためには、現時点では1ヶ月1回等の定期的な頻度でAPIを実行し情報を取得保存して集計する必要があります。なお、今回はAPIが最近利用可能になったということもあり、直近28日間の情報を取得し利用頻度を分析しました。 APIを利用する最も簡単な方法は、Pythonのrequestsモジュールを使用することです。以下に、GitHub CopilotのAPIを使用して統計情報を取得するPythonのコードを示します。こちらのコードを実行することで直近28日間の統計情報を取得できます。 import requests # GitHub API URL enterprise_name = "XXX" url = f "https://api.github.com/enterprises/{enterprise_name}/copilot/usage" # APIにアクセスするためのトークン token = "YOUR_TOKEN" # リクエストヘッダー headers = { "Accept" : "application/vnd.github+json" , "Authorization" : f "Bearer {token}" , "X-GitHub-Api-Version" : "2022-11-28" , } # GETリクエストを送信 response = requests.get(url, headers=headers) # リクエストが成功したかどうかを確認 if response.status_code == 200 : data = response.json() # JSON形式のデータを取得 print ( "データの取得に成功しました:" ) print (data) # データを表示 else : print (f "データの取得に失敗しました。ステータスコード: {response.status_code}" ) print (response.text) # エラーメッセージを表示 利用頻度 弊社では1日平均12.0人がGitHub Copilotを利用しています。これは弊社の約1/3が毎日利用しているということになります。ちなみにCopilot Chatの利用者は1日平均0.16人であり、Copilot Chatの利用者は非常に少ないことが分かりました。こちらの機能については私自身以前は何回か使ったことがあるものの、日常の開発シーンにおいては利用はほとんどありません。利用開始当初は実装をしながらChatGPT等のサービスと行き来せずにVS Code内で自由に対話ができることに期待していたものの、実際に使ってみると利便性を感じることができず次第に利用しなくなってしまいました。他の開発者も同様の理由でCopilot Chatの利用がなくなったか、あるいは存在を知らない可能性があるため、改めてその機能について検証し、必要であれば周知をする必要があるかもしれないと考えています。 利用言語 以下は、直近28日間の利用言語で実際にCopilotが提案したコードから採択された行数を元に算出した結果になります。最も利用されている言語はPythonであり、次いでTypeScript、hcl、yamlと続いています。 弊社では、主にPythonやTypeScriptを使用しているため、これらの言語が上位にランクインしていることは自然な結果と言えます。また、インフラ管理のためにTerrformを使用しているため、hclとyamlも上位にランクインしていることはとても自然な結果と言えます。 提案されたコードの採択率 最後に、Copilotが提案したコードの採択率についても調査しました。提案されたコードの採択率は、提案されたコードのうち、実際に採用されたコードの割合を示しています。これは開発者がCopilotの提案をどの程度採用しているかを示す指標となります。言語問わずの平均は30.12%となりました。言語別では、採用された行数で最も多かったPythonに対して、JSONが最も高い採択率を示しています。これはテストデータの生成やAPIのレスポンスのモックなど、JSONを扱う機会が多いためと考えられます。 利用者の声 弊社のエンジニアの声をヒアリングしましたのでご紹介します。エンジニアの声を聞くことで、GitHub Copilotの導入による効果や課題についてより具体的に把握することができます。ちなみに弊社のエンジニアは大きく2つのグループに分かれています。システム開発を担う開発チームと、データ分析を担う分析チームです。今回はそれぞれ異なる視点からGitHub Copilotについてどのような定性効果があったのかをヒヤリングしましたので、その結果をご紹介します。 開発チーム （ソフトウェアエンジニア） 開発チームからは、生産性の向上や学習効果に関するポジティブな意見が多く聞かれました： 定型的なコードをいちいち書く必要がなくなり、開発スピードが格段に上がった。よりコアなロジックに集中できるようになった。 テストコードを書くのが面倒だったが、Copilotが自動生成してくれるので助かる。テストケースを考える時間もしっかり取れるようになった。 Copilotがないと生きていけない体になってしまった。 一方で、Copilotの提案の質や依存度に関する課題も指摘されています： Copilotが提案してくれるコードが、いつも最適な方法とは限らない。時には、自分で書いた方が早いし、分かりやすい場合もある。 クラウド環境のSDKを使う場合、Copilotが生成するコードが不安定で、エラーが発生することがある。最新のAPIに対応できていないこともある。 分析チーム （データサイエンティスト） 分析チームからは、特に学習効果や新しい知識の獲得に関するポジティブな意見が聞かれました： Copilotが提案してくれるコードを通して、知らなかったAPIやライブラリを知ることができ、学習の機会になっている。 データ前処理や可視化のコードを書く際に、Copilotの提案を参考にすることで、より効率的なアプローチを学べることがある。 Copilotのおかげで、コードを書く際のストレスが減り、より分析業務に集中できるようになった。 一方で、分析チームからもCopilotの提案の質や依存度に関する課題が指摘されています： Copilotが提案するコードは、あくまでも参考程度に捉えている。最終的には、自分の知識と経験に基づいて判断する必要がある。 以上のように、開発チームと分析チームともに、Copilotの利用による生産性向上や学習効果については肯定的な意見が多く聞かれましたが、提案の質や依存度に関する課題も指摘されています。ただし、総じて、Copilotの導入による効果は大きいと考えています。 まとめと今後の展望 ここまで、GitHub Copilotの導入背景と目的、組織内の活用状況についてご紹介しました。最後に、まとめと今後の展望について述べます。 まとめ GitHub Copilotは、我々の開発において生産性向上や学習効果の向上に大きく貢献しています。特に、定型的なコードの自動生成や馴染みのないAPIやライブラリの学習や定型的なコードの自動生成において、Copilotの提案は非常に有用であると感じています。一方で、提案の質や依存度に関する課題もあるため注意は必要ですが、総じて、Copilotの導入による効果は大きいと考えています。むしろ、なくてはならないツールとなっています。 今後の展望 今後は、GitHub Copilot Enterpriseの導入を検討しています。Copilot Enterpriseは、Copilot Businessよりもさらに高度な機能を提供しており、より大規模な組織での利用に適しています。弊社では7月中にCopilot Enterpriseの検証開始を予定しており、その結果を踏まえて、Copilot Enterpriseの導入を検討していきます。なお、その結果については今後の報告でご紹介しますので是非ご期待ください！

init_mathjax = function() { if (window.MathJax) { // MathJax loaded MathJax.Hub.Config({ TeX: { equationNumbers: { autoNumber: "AMS", useLabelIds: true } }, tex2jax: { inlineMath: [ ['$','$'], ["\\(","\\)"] ], displayMath: [ ['$$','$$'], ["\\[","\\]"] ], processEscapes: true, processEnvironments: true }, displayAlign: 'center', CommonHTML: { linebreaks: { automatic: true } } }); MathJax.Hub.Queue(["Typeset", MathJax.Hub]); } } init_mathjax(); DALL-Eで生成した「複雑な株価の動き」 こんにちは！Insight Edge データサイエンティストの伊達です。 昨年9月より、Kaggleにて株価予測コンペ「Optiver - Trading at the Close」が開催され、4000以上のチームが参加する盛り上がりを見せました。 私は参加できませんでしたが、Insight Edgeの分析プロジェクトでも時系列データを扱う場面があるため、今回の記事では、コンペ終了後に共有された上位解法から得られた学びを紹介したいと思います。 今回の記事の執筆にあたって、コンペで共有されたディスカッションやノートブックだけでなく、国内の金融データサイエンスコミュニティであるマケデコ（Market API Developer Community）様が今年5月に開催された「OptiverコンペKaggle上位解法勉強会」での発表内容も参考にさせて頂きました。 www.youtube.com zenn.dev 目次 Optiverコンペについて 問題設定 データ期間と評価 データ項目 Optiverコンペの上位解法まとめ 上位解法一覧 ポイントになったと思われる技術 まとめ Optiverコンペについて www.kaggle.com 今回のコンペの課題は、アメリカの代表的な株式市場の1つであるNASDAQにおいて、15時50分〜16時（取引終了）という最後の10分間で、各銘柄の株価がどう動くかを予測するというものです。 なぜ最後の10分間の株価予測なのか？その背景に、近年、米国株市場において取引終了直前の短時間での売買量が増加しており、市場に与える影響が大きくなっていることがあるようです。 米国株の取引時間は通常390分だが、ここにきて最後の10分間のみが相場にとって重要になりつつあるかもしれない。 アルゴリズム取引を開発するベストExリサーチがまとめたデータによると、S&P500種株価指数採用銘柄の株式売買では、全体の約3分の1が最後の10分間に執行されている。この割合は2021年の27％から上昇している。 www.bloomberg.co.jp また、NASDAQでは取引方式としてマーケットメイク方式が採用されており、オークション方式のように投資家同士が直接売買するのではなく、NASDAQが認可したマーケットメーカーと呼ばれる業者が投資家の売買注文を成立させます。 www.investopedia.com 今回のコンペの主催者であるOptiverはNASDAQにおけるマーケットメーカーであり、取引が集中する「最後の10分間」で各銘柄の株価がどう動くかを予測することはOptiverにとって非常に重要なタスクです。 問題設定 今回のコンペのターゲットは「各銘柄の株価が60秒後にどう動くか」です。 より正確に書くと、「各銘柄の加重平均価格（WAP）の60秒後のリターン」から「インデックスの加重平均価格の60秒後のリターン」を引いた値がターゲットとなっています： $$(\frac{\text{StockWAP}_{t+60}}{\text{StockWAP}_{t}} - \frac{\text{IndexWAP}_{t+60}}{\text{IndexWAP}_{t}}) * 10000$$ 加重平均価格（WAP）：板における買い・売り値の加重平均 $$\frac{\text{買い値} * \text{売り数量} + \text{売り値} * \text{買い数量}}{\text{買い数量} + \text{売り数量}}$$ インデックス：日経平均のように、NASDAQを構成する各銘柄の株価を加重平均した値 評価指標としては、平均絶対誤差（MAE）が採用されていました。 データ期間と評価 今回のコンペの課題は時系列予測であるため、各チームは締切までにノートブックを提出し、Kaggle側が各チームの提出したノートブックと評価期間データ（サブミッション締切より後のデータ）を用いて精度を評価する「Code Competition」となっていました。 データ期間の長さは下記の通りになっていたようです： 学習用：96週分 Publicリーダーボード評価用：9週分 評価に使われないデータ：7週分 Privateリーダーボード評価用：6週分 データ項目 今回のコンペで提供されたデータは下記の通りです： 銘柄ID 日付ID クロージング・オークション開始（15:50）から経過した秒数（ seconds_in_bucket ） ターゲット 価格系データ bid/ask_price ：最良気配（最も高い買値、最も安い売値） wap ：買値・売値の加重平均価格 far_price ：オークション注文板（auction order book）で取引量が最大となる約定価格。板情報（order book）は考慮されない。 near_price ：オークション注文板と板情報を合わせた時に取引量が最大となる約定価格 reference_price ：最良気配の範囲（最も安い売値〜最も高い買値）に制限された near_price サイズ・インバランス系データ bid/ask_size ：板情報において最良気配の買い/売り注文量 imbalance_size ： reference_price で約定した時、約定しない注文量 imbalance_buy_sell ：オークションのインバランスの方向（1: 買い側、-1: 売り側、0：インバランスなし） matched_size ： reference_price で約定した時、約定する注文量 Optiverコンペの上位解法まとめ Optiverコンペの上位リーダーボード 上位解法一覧 本記事執筆時点で公開されている上位解法をまとめます。 今回は、特徴量、モデル構成、再学習の有無、後処理、バリデーション戦略という5つの観点で各解法を整理しました。 1位： hydさん（スコア: 5.4030） 1位解法 特徴量 よく使われる特徴量に加え、「秒群」を使ったグループ集計（後述）による特徴量を使用 変数選択：CatBoostの重要度で上位300個 モデル構成：CatBoost + GRU + Transformer 再学習（オンライン学習）：あり 後処理：各銘柄の予測値の加重平均を引く バリデーション戦略：時系列分割（学習期間最後の81日分でバリデーション） その他工夫 polars使用によるデータ処理効率化？ 学習データを日付ごとに保存しておくことで、推論時のメモリ制約の中で使える特徴量の数をできるだけ増やした 6位: Daniel FGさん（スコア: 5.4285） 6位解法 特徴量：よく使われる特徴量40個弱 モデル：Transformer（少し設定を変えた3個）+ GRU 再学習（オンライン学習）：あり 後処理：一つのモデルを除き、予測値の合計が0になる制約を加えて学習させた バリデーション戦略：時系列分割（学習期間最後の121日分でバリデーション） 7位: NimaShahbaziさん（スコア： 5.4300） 7位解法 特徴量：よく使われる特徴量に加え、価格やサイズデータが日付/秒軸で計算した中央値からどれだけ乖離しているか（"deviation features"）を使用 モデル：LightGBM + LSTM + CNN 再学習（オンライン学習）：あり 後処理：なし？ バリデーション戦略：時系列分割 9位: ADAM.さん（スコア： 5.4352） 9位解法 特徴量 よく使われる特徴量に加え、テクニカル指標（MACD）などを使用 変数選択：特徴量を10〜30個ずつグループ分けし、各グループを追加したときにバリデーション結果が良くなるか確認。グループ単位の結果が良かったら、その中で一つずつ追加して同様に結果を確認し、グループ内で5〜10個程度のみ採用。 モデル：XGBoost 3個 学習期間最後の45日間のデータの重みを増やした 再学習（オンライン学習）：あり 後処理：各銘柄の予測値の加重平均を引く バリデーション戦略：時系列分割 その他工夫 polars使用 pandas dataframeのメモリ使用量を減らす ポイントになったと思われる技術 特徴量 ほとんどの上位解法の特徴量エンジニアリングは、 こちらのノートブック で紹介されているような基本的なものと大きく変わらない印象です。 1位解法 では"magic features"として、「秒群」を使ったグループ集計による特徴量が紹介されていました。 これは、クロージング・オークション開始（15:50）から経過した秒数が、 0〜290秒であればグループ0 300〜470秒であればグループ1 480〜540秒であればグループ2 として、各銘柄について、同じグループ内の最初の秒の値・移動平均値との比率を計算するものだそうです。 グループの区切り方については、 公式のチュートリアル にもあるように、 15:55（300秒）：NASDAQからclosing informationの公表が開始 15:58（480秒）：Limit-On-Close (LOC) 注文の受付停止 というドメイン知識が使われたのだと思われます。 また、1位解法では、同じ日・秒について、銘柄軸で計算された平均値との比率やランクも使われていたそうです。 1位解法の"magic features"についての説明は、 マケデコ勉強会でのnishimotoさんの発表 が分かりやすかったので、おすすめです。 モデル モデルに関して、上位解法では GBDTとニューラルネット（1位、7位） GBDTのみ（9位） ニューラルネットのみ（6位） の3パターンになっていました。 興味深かったのは、1位解法が、CatBoostに加えて、GRUを時系列軸のモデリング（入力シェイプ：バッチサイズ × 55時点 × 隠れ層サイズ）に、Transformerを銘柄軸（クロスセクション）のモデリング（入力シェイプ：バッチサイズ × 200銘柄 × 隠れ層サイズ）に使うことで、アンサンブル全体でのモデル多様性を持たせていたことです。 コードコンペの制約があり、使用できるモデル数や特徴量が限られる中で、モデルの多様性を最大限広げている辺り、さすが1位だなという印象です。 再学習（オンライン学習） 今回のコンペでの評価はCode Competition形式で、評価期間の各時点において、それより前の時点のターゲットの値が随時提供される形になっていました。 つまり各参加者は、提出するノートブックの中で、随時提供される評価期間中のデータを使ったモデルの再学習（オンライン学習）を導入するチャンスがありました。 上記の上位解法の全てがこの再学習を使用しており、上位入賞の鍵になった要素と考えられます。 後処理 今回のコンペのターゲットは、 「各銘柄の加重平均価格（WAP）の60秒後のリターン」から「インデックスの加重平均価格の60秒後のリターン」を引いた値 でした。 ターゲットの計算で使われるインデックスは今回のコンペ用にOptiverによって作成されたもので、公式からはインデックスがどう構成されているか説明されていませんでした。 しかし、 有志によりインデックスの計算方法が推測 されており、今回のインデックスは各銘柄の株価ではなく60秒後リターンの加重平均になっていたようで、インデックス構成用の各銘柄の重みが公開されていました。 今回の1・9・15位の解法ではこの知見と重みを用いて、モデルが出力した各銘柄の予測値から、推測された重みを使った予測値の加重平均を引くという後処理が使われていました。 これは、各銘柄でインデックスのリターンを引いているため、ある時点での全銘柄の予測値を合計すると0になるという知識を使ったものです。 上記以外のアプローチとして、6位と14位の解法では、単純に各時点で全銘柄の予測値の合計を引くという処理を入れていたようです。 バリデーション戦略 今回確認した上位解法の全てが、バリデーション戦略として、学習期間の最後の部分を検証用データとする時系列分割（time-series split）を採用していました。 Public LB・Private LBともに、評価用データは学習期間よりも後の時期のデータとなっており、CVのようなランダム分割ではなく、より新しいデータでバリデーションすることで評価期間での精度を正確に推測することが重要だったようです。 他の解法ではCVを採用したものもあり、今回のようなタスクではCVを使うか、時系列分割を使うか、あるいは CPCV などのように、より複雑なものを使うか、判断が難しかったのではないかと思われます。 まとめ 上位解法の内容から、今回のコンペのキーになったと考えられるのは下記のポイントです： 特徴量：ドメイン知識に基づく特徴量エンジニアリング、実行制約がある中で有効な特徴量をできるだけ多く使うための実装上の工夫 モデルの多様性：GBDT + GRU/CNN（時系列方向のパターンを捉える）+ Transformer（クロスセクション：銘柄間の関係性を捉える） 再学習（オンライン学習）：非定常なタスクにおいて、新たに手に入るターゲットデータを使ってモデルを更新 後処理：ドメイン知識に基づく予測値の後処理 バリデーション戦略：非定常なタスクにおいて、評価期間に近い期間のデータを使ったバリデーション 今回のように4000チーム以上が参加するような大きなコンペでは、特徴量、モデル、推論時に手に入るターゲットを使った再学習、予測値の後処理、バリデーション戦略と、全方位で高いクオリティの解法を作り上げる必要があるのだなと感じました。 今回確認した上位解法の全てがソロ参加のチームによるもので、3名がGrandmaster、1名が Masterの称号を獲得されているようです。 さらに、1位を獲得した hydさん は、本記事執筆時点でコンペ部門のランキングが世界1位となっています。 強者があらゆる創意工夫を尽くし、上位を争ったという意味で、非常に良いコンペだったと思いますし、自分にとっても上位解法の知見は学びが多かったです。 次回金融系のコンペが開催されたら、ぜひ次こそ自分も参加してみたいと思います。

こんにちは！Insight Edgeの小林まさみつです。 Insight Edgeでは、単一のプロジェクトでバックエンドとフロントエンド両方の開発を担当することがあります。 開発時にはバックエンドとフロントエンドをうまく連携することが求められます。 その際、それぞれで型情報を定義すると多重管理することになり、管理の手間がかかることに加えて整合性が保ちづらくなります。 本記事では、型情報を含むAPIをスムーズに連携することでこれらの問題を解決し、開発プロセス全体の効率化を実現する方法を紹介します。 目次 1. 概要 2. 使用する主要な技術 3. 本記事で扱うデータモデル 4. バックエンドの型情報と FastAPI の役割 5. フロントエンド開発の効率化 6. バックエンドとフロントエンド間の型同期 7. 注意点 8. まとめと今後の展望 1. 概要 型付けの重要性 型情報を明示することは、ソフトウェアをより堅牢かつ安全なものとするために重要です。 コードの可読性向上、開発者間のコミュニケーションの明確化、誤解の減少などのメリットがあります。 特に、バックエンドとフロントエンドが同じ型情報を共有することは、APIを介したシステム連携において重要な役割を果たします。 バックエンド・フロントエンド間の型情報連携の重要性 型情報の連携は、複数のシステム(今回はバックエンドとフロントエンド)が互いに連動するプロジェクトにおける整合性を保つ上で欠かせません。 型情報を共有することで、多重管理を避け修正もれや開発スピードの向上が見込めます。 2. 使用する主要な技術 本記事では下記の技術スタックを利用してスムーズな型情報連携を実現します。 openapi-zod-clientを除き、主要な技術については理解している前提で話を進めます。 バックエンド 言語： Python APIフレームワーク： FastAPI 型管理ライブラリ： Pydantic パッケージ管理ツール： poetry Pydanticに関しては本techblogの以下の記事にも登場しているのでご一読ください。 AdhocなPythonコードをProduction-readyにするために心掛けていること FastAPI,Pydantic,AWS DynamoDBを組み合わせた型安全なAPI構築方法について フロントエンド 言語： TypeScript 型管理ライブラリ： Zod 型情報生成： openapi-zod-client パッケージ管理ツール： pnpm 3. 本記事で扱うデータモデル 本記事では、サンプルとして「User」というデータモデルを利用します。 Userモデルは、名前（name）と年齢（age）という２つの属性を持ちます。 ここでの型付けルールは以下の通りです。 名前：1文字以上かつ、10文字以下の文字列であること。 年齢：0歳から130歳までの整数であること。 また、このデータを用いて以下の流れで開発していきます。 ③〜④の部分で、バックエンドで定義した型情報を含むAPIをフロントエンドに連携させます。 4. バックエンドの型情報と FastAPI の役割 ディレクトリ構造について 本記事では、以下のディレクトリ構成となるように進めていきます。 プロジェクトに導入する際には、プロジェクトごとに管理しやすいディレクトリ構成としてください。 / ├── backend/ │ └── app.py ├── frontend/ │ ├── index.ts │ └── services/ │ └── openapiClient.ts # 自動で生成する ├── build_openapi.py ├── openapi.json # 自動で生成する ├── package.json ├── pnpm-lock.yaml ├── poetry.lock └── pyproject.toml ①Pydanticモデルの作成 APIでやり取りをする際にどのような情報を扱うかを明確とするために、まずはPythonで型情報を定義します。 その際、バリデーションを行い型安全を保証するためにPydanticモデルを作成します。 初めにPydanticをインストールします。 poetry add pydantic 次に、Userクラスを作成しモデル定義をします。 # ./backend/app.py from pydantic import BaseModel, Field class User (BaseModel): name: str = Field(..., min_length= 1 , max_length= 10 ) age: int = Field(..., ge= 0 , le= 130 ) 以上で、要件を満たすPydanticモデルの定義ができました。 このようにすることで条件を満たさない入力がUserに対して行われた際、例外を返すようになります。 ②APIルートの作成 次に、作成したPydanticモデルを取得するためのAPIを作成します。 まずはFastAPIとそれを実行するためのuvicornをインストールします。 poetry add fastapi uvicorn 次に、FastAPIのルートを定義します。 今回は簡単にするため、APIは以下の仕様とします。 ルートへのgetリクエストを受け取り、固定のUserを返却する。 # ./backend/app.py (追記) from fastapi import FastAPI app = FastAPI() @ app.get ( "/" , response_model=User) def get_user () -> User: return User(name= "masam" , age= 20 ) 以下のコマンドを実行し、アプリを起動します。 その後、ブラウザからアクセスすることでAPIを呼び出せることを確認します。 poetry run uvicorn backend.app:app --host 0.0.0.0 http://localhost:8000/ にアクセスすると以下の内容が表示されます。 {"name":"masam","age":20} ③OpenAPIドキュメントの生成 作成したPydanticモデルとFastAPIルートを基にOpenAPIドキュメントを生成します。 OpenAPIドキュメントはFastAPIの機能を用いることで生成できます。 ルートディレクトリに build_openapi.py を作成し、以下を記述します。 ./build_openapi.py import json from backend.app import app with open ( 'openapi.json' , 'w' ) as f: json.dump(app.openapi(), f, ensure_ascii= False ) その後 build_openapi.py を実行します。 python build_openapi.py ルートディレクトリに openapi.json が生成されていることを確認します。 作成したAPIのコードからOpenAPIドキュメントを生成できました。 以上でバックエンド側の作業は完了です。 5. フロントエンド開発の効率化 ④Zodスキーマの生成 生成したOpenAPIドキュメントを基にZodスキーマとAPIクライアントを生成します。 まずは生成するためのライブラリと、ターミナル上でTypeScriptを実行するためのライブラリをインストールします。 pnpm add openapi-zod-client zod @zodios/core　ts-node 次に、簡単に生成できるようにするため、 package.json のscriptsに以下を追加します。 "generate-openapi-zod-client": "openapi-zod-client ./openapi.json -o frontend/services/openapiClient.ts -a" 上記コマンドを実行する前に、生成するクライアントコードを配置するディレクトリを作成します。 mkdir -p frontend/services これで準備が整いました。 設定したスクリプトを実行し、必要なコードが生成されることを確認します。 pnpm generate-openapi-zod-client 以下のようなコードが生成されます。 frontend/services/openapiClient.ts import { makeApi, Zodios, type ZodiosOptions } from "@zodios/core"; import { z } from "zod"; const User = z .object( { name : z.string().min( 1 ).max( 10 ), age : z.number().int().gte( 0 ).lte( 130 ), } ) .passthrough(); export const schemas = { User , } ; const endpoints = makeApi( [ { method : "get" , path : "/" , alias : "get_user__get" , requestFormat : "json" , response : User, } , ] ); export const api = new Zodios(endpoints); export function createApiClient ( baseUrl : string , options? : ZodiosOptions ) { return new Zodios(baseUrl, endpoints, options); } ⑤Zodを用いた開発 次に、生成されたAPIを実行するコードを作成します。 今回はAPIから受け取ったデータをコンソールに出力するだけにします。 // frontend/index.ts import { z } from "zod" ; import { createApiClient, schemas } from "./services/openapiClient" ; const BASE_URL = "http://localhost:8000" ; type UserType = z.infer < typeof schemas.User >; const getUser = async () => await createApiClient(BASE_URL).get_user__get(); getUser(). then (( user : UserType ) => { console .log( `name: ${ user. name} , age: ${ user.age } ` ); } ); 以下のコマンドで実行し、データを受け取れることを確認します。 ※取得できない場合はFastAPIを動かすuvicornが起動していない可能性があるので再度ご確認ください。 npx ts-node frontend/index.ts 6. バックエンドとフロントエンド間の型同期 これまでの内容により、バックエンドで定義した型情報をフロントエンドに取り込むことができました。 システム開発においては1度取り込んで終わりというわけにはいきません。 システム改修に伴い型情報や、APIでやり取りするモデルを変更することが多々あります。 特に、バックエンドとフロントエンドの両方を並行して開発している際には高頻度でモデルが変わります。 その際にモデル変更に対して素早く追随するために、簡単に同期をとるためのコマンドを開発サイクルに組み込むと良いです。 今回作成したコードを利用すると、以下の2コマンドを実行することで実現できます。 python build_openapi.py pnpm generate-openapi-zod-client 7. 注意点 現時点ではPydanticで定義したカスタムバリデーションをZodへ同期できていません。 そのため、厳密なバリデーションに関しては追加で実装するか、諦めてAPI側で担保するかの方針を決める必要があります。 この問題に対する解決策をご存じの方がいらっしゃれば、ぜひフィードバックをお寄せください。 8. まとめと今後の展望 バックエンドで定義した型情報を活用してフロントエンドコードを簡単に実装する方法を解説しました。 この連携がスムーズに行われれば、バグのリスクを減らしつつ開発速度を劇的に向上させることができます。 今後もAPIを介した型情報の活用して開発速度を上げていこうと思います。

はじめまして！2024年5月よりInsight EdgeにジョインしたData Scientistの市川です。 まだ入社して間もないですが、オルタナティブデータを活用した案件や、金融市場のオプション等を活用した分析などに携わっております。 今回は、先日人工知能学会（JSAI2024）に行ってきましたので、そのレポートをさせて頂きます。 イベントの概要 発表の概要 [2J1-KS-19] 金融分野における大規模言語モデルの活用 [2A2-PS-2] 進化する大規模言語モデル [2O4-OS-25a] 不動産とAI [2O4-OS-25a-01] 住宅価格予測モデルの経時的な精度の変化分析 [2O4-OS-25a-02] 地理空間ネットワークデータと機械学習を用いた説明可能性の高い賃料予測 [2O4-OS-25a-03] 機械学習を用いた物件設備スコアの推定：不動産データを使用したケーススタディ [2O4-OS-25a-04] Stable Diffusionによる部屋間取りを保持したホームステージング画像生成 [2I6-GS-10] AI応用：金融 [2I6-GS-10-01] 会社四季報のセンチメントを用いた株式銘柄選定の試み [2I6-GS-10-02] 事業セグメント関連語の拡張による金融文書に対するセグメント別センチメント分析の改善 [2I6-GS-10-03] コーポレート・ガバナンスに関する報告書のテキストマイニングによる人的資本情報開示の分析 [2I6-GS-10-04] 大規模言語モデルを利用したパンデミック期の事業等のリスクの記述分析 [2I6-GS-10-05] Graph Based Entropyと領域間相互作用を用いた株式市場の異常検知 [3Xin2] ポスターセッション1 [3Xin2-83] LLM-Traders : 大規模言語モデルを用いた金融時系列予測 [3Xin2-36] 大規模言語モデルの金融投資意思決定バイアスに関する評価指標の構築 [3Xin2-68] 衛星画像による雲量を用いた電力需要予測の基礎検討 [3A4-PS-3] AIは『鉄腕アトム』の夢をみるか？～生成AIによるコンテンツ制作の可能性と問題 [3D5-GS-2] 機械学習：時系列 [3D5-GS-2-04] 階層型ネットワークの階層構造推定と異常検知への応用　金融時系列データの階層構造分析より金融市場異常検知とその原因分析 [3D5-GS-2-05] 主成分等価法による残差リターン抽出 雑感 イベントの概要 人工知能学会 は1986年7月に設立された学術研究団体です。 詳細は上記リンクに譲るのですが、歴史がある学会ではあるものの、かなり広い領域の研究を扱っている認識で、近年LLMへの注目の高まりとともに人が集まっている学会という認識です。 スケジュールは以下の通りでした。 日時：2024年5月28日（火）～31日（金） 会場：アクトシティ浜松(静岡県浜松市) 参加人数は対面とオンラインで3500人超となっているようでして、巨大な学会になっています。2017の名古屋の大会では2000人を初めて超えたという状況を考えると、かなり大きい大会になったなという印象です。また、スポンサーのブースがとても多かった印象で、大学はもとより企業からの注目もかなり高い大会という認識です。 私は今回、29（水）〜30（木）に参加させていただきました。一部ですが、簡単にレポートさせていただきます。 主に、金融分野の研究を見てまいりました。 発表の概要 こちらの研究会はありがたいことに 各発表の概要pdfが公開されています 。 以下、著者の敬称略とさせて頂きます。 [2J1-KS-19] 金融分野における大規模言語モデルの活用 資料は公開されているものとされていないものがあるのですが、このセッションでは、東大の和泉研究室を中心に金融分野におけるLLMの適用についての解説になっていました。 興味深かった話としては、 営業員の練習として、LLMを用いた対話のシミュレーションを検討している RAGを社内に実装することを優先している。社内に散らばっている情報をRAGによって拾えるようにする といった話が、実務上大変興味深かったです。 [2A2-PS-2] 進化する大規模言語モデル NIIの 相澤先生 から、LLMについての説明がありました。 特に日本語に特化した取り組みである、 LLM-JP NII LLM研究開発センター の取り組みの話がありました。 また、 Token Crisis：良質かつ大量のテキストが必要だが、オープンデータでは枯渇しつつある トークナイザーの性能：言語間で不平等が生じている LLMの出現によって、使用頻度が増えてきた表現がある などについても触れられていました。 [2O4-OS-25a] 不動産とAI [2O4-OS-25a-01] 住宅価格予測モデルの経時的な精度の変化分析 〇寺﨑 海翔1、岡本 一志1、柴田 淳司2 (1. 電気通信大学、2. 東京都立産業技術大学院大学) 住宅価格予測モデルの経時的な精度の変化を分析した研究です。新築戸建住宅と賃貸マンションの価格予測において、学習から予測までの期間を設け、その期間の長さと予測精度の関係を明らかにしています。 新規性は、住宅価格予測モデルが時間経過により劣化する様子を定量的に評価した点です。先行研究では、時間経過によるモデルの劣化に焦点を当てた研究は少ないようです。 LIFULL HOME’Sデータセット を用い、学習から予測までの期間を設けることで、時間経過による精度の劣化をMAPE（Mean Absolute Percentage Error）を用いて評価しています。 データ：2015年7月〜2017年6月の新築戸建と賃貸マンションのデータ モデル：Ridge回帰、SVR、LightGBM、kNN 学習データ、検証データ、テストデータを時系列に沿って抽出し、期間を設けて各モデルの精度を評価しました。特に、12ヶ月後の予測精度の劣化を分析し、全てのモデルで劣化が見られることを確認しています。 [2O4-OS-25a-02] 地理空間ネットワークデータと機械学習を用いた説明可能性の高い賃料予測 Bramson Aaron1,2、〇三田 匡能1 (1. 株式会社GA technologies、2. Ghent University) 地理空間ネットワークデータを利用した賃料予測モデルの説明可能性の研究です。 既存のヘドニック価格モデルは単純な分析モデルに頼ることが多く、予測精度が低い傾向にあります。 新規性は、LightGBMを使用して、説明変数のみに依存するハイブリッドアプローチを採用している点です。 使用したデータは、 東京の住宅賃料データ（国道16号の内側） 地理空間データと交通ネットワークデータ 上記のデータなどから算出した、地理空間特徴量（駅、店舗、緑地など）のスコア モデルはLightGBMで、これらの特徴量が予測精度に与える影響を分析しています。 [2O4-OS-25a-03] 機械学習を用いた物件設備スコアの推定：不動産データを使用したケーススタディ 〇宋 宛丘1、尾𥔎 幸謙2、山内 翔大1、三田 匡能1、福中 公輔1 (1. 株式会社GA technologies、2. 筑波大学) マンション投資物件の設備状況を評価するための機械学習モデルを開発し、評価結果を数値化して再現することが目的です。 専門家の主観的な設備評価を基に採点表を作成し、その採点表を用いて機械学習モデルを訓練しました。 新規性は、専門家の主観的な評価を数値化して機械学習モデルに反映させる点のようです。 また、設備に関するデータが欠測している場合でも高精度な予測を行える点も特徴的です。 データと前処理については、 専門家へのインタビューを通じて作成した設備スコア採点表 販売図面 物件の構造化データ データが欠測している場合の処理方法として、欠測値を「numpy.nan」や「-1」を代入 モデルはLightGBMです。 350件の物件データを用いてモデルを訓練し、交差検証法（LOOCV）を用いてモデルの性能を評価しています。 評価指標としてRMSE（Root Mean Squared Error）や決定係数（R2）を使用し、複数のモデル間で性能を比較しています。 また、欠測データを生成して、欠測比率が予測精度に与える影響も見ています。 [2O4-OS-25a-04] Stable Diffusionによる部屋間取りを保持したホームステージング画像生成 〇服部 翔1、山崎 俊彦2 (1. アットホームラボ株式会社、2. 東京大学) 元々、ホームステージング画像を生成しようとすると、エアコンが消えてしまったり、間取りが変わったりしてしまっていた状況だったようです。 そこで、Stable diffusionに 家具配置LoRA 間取り保持Centrol Net 建具保持Control Net を準備し、そのような課題の解決を目指しています。 [2I6-GS-10] AI応用：金融 [2I6-GS-10-01] 会社四季報のセンチメントを用いた株式銘柄選定の試み 〇鈴木 雅弘1,2 (1. 日興アセットマネジメント株式会社、2. 東京大学) 会社四季報（日本の上場企業の動向をまとめたデータブック）のテキストデータからセンチメントスコアを算出し、そのスコアを基に株式銘柄を選定する研究です。 大規模言語モデル（LLMs）や金融極性辞書など、複数の手法を用いてセンチメントを計算し、それが株式の超過リターンに与える影響を分析しています。 四季報のテキストデータを用いてセンチメントスコアを算出する先行研究は少ない状況です。 既存のデータセットを学習したモデルやChatGPTを用いた複数のセンチメント算出手法を比較しており、特に小型銘柄に対して、高いセンチメントスコアが高い超過リターンを示すことを明らかにしています。 センチメントスコアの算出方法は、 金融極性辞書: テキストを形態素に分割し、各形態素のスコアを合計 chABSAモデル: 特定の語に対するセンチメントをラベル付けしたデータセットを学習 景気ウォッチャー調査モデル: 景気に敏感な人々のアンケートデータを基に5段階の分類タスクを学習。日本語DeBERTaV2、日本語Llama2を使用。テストデータによる評価のみを行うモデルとしてChatGPT、GPT-4を使用 ChatGPT: 直接入力テキストに対してセンチメントスコアを出力する方法 センチメントスコアと株式の超過リターンの関係を見るために、四季報の発行日から次の発行日の前日までの各企業のリターンを計算し、センチメントスコアの高低による超過リターンの違いを比較しています。 結果として、センチメントスコアの高い企業は高い超過リターンを示す傾向が確認されました。 [2I6-GS-10-02] 事業セグメント関連語の拡張による金融文書に対するセグメント別センチメント分析の改善 〇平松 賢士1、伊藤 友貴2 (1. 株式会社アイフィスジャパン、2. 三井物産株式会社) 金融文書に対して「ゼロショットで」事業セグメントごとのセンチメント分析を改善するための手法を提案しています。 LLMを用い、有価証券報告書などの文書から事業セグメント関連の語句を抽出し、既存の手法よりも精度の高いセンチメント分析を実現することが目的です。 新規性は、事業セグメント関連語の拡張することで、サービス名や関係会社名など、従来の手法では見逃されがちな情報も抽出可能になったことや、教師なしでの手法を開発し、新規上場企業や組織改組などの変化に柔軟に対応したことです。 事業セグメント関連語の拡張として、有価証券報告書から事業セグメントの説明記載を抽出し、セグメント関連語を用いて文書内の関連文を検索 抽出された段落に含まれる事業セグメント関連語に基づき、ポジティブ、ネガティブ、ニュートラルのセンチメントを付与。 実際のアナリストレポートを用いて提案手法を検証し、提案手法が既存のベースライン手法やGPTモデルを単独で使用した場合よりも高いF1スコアを達成していることに加え、アナリストレポートと決算短信の両方を用いた検証で、関連語の拡張によるセンチメント分析の精度向上を確認しています。 [2I6-GS-10-03] コーポレート・ガバナンスに関する報告書のテキストマイニングによる人的資本情報開示の分析 紙谷 青1、松岡 深雪1、〇中居 拓海1 (1. 大阪市立大学) コーポレートガバナンス報告書における人的資本管理に関する情報をテキストマイニングによって分析しています。 2023年3月期の財務諸表における人的資本管理情報の開示が義務付けられたことから、ステークホルダーの関心が高まっていることが背景です。 新規性は、年次有価証券報告書ではなく、コーポレートガバナンス報告書からの人的資本情報の分析をした点です。 階層クラスタ分析：KHCoderを使用して、特定のキーワード間の強い関連を調査 共起ネットワークグラフ：形態素解析はMeCabを用い、共起関係を視覚化 [2I6-GS-10-04] 大規模言語モデルを利用したパンデミック期の事業等のリスクの記述分析 〇梅原 武志2,3、武田 英明1,2 (1. 国立情報学研究所、2. 総合研究大学院大学、3. 株式会社日経リサーチ) 日本の上場企業の有価証券報告書における新型コロナウイルス感染症（COVID-19）のパンデミック前後での感染症リスク記述を、LLMを用いて分析する研究です。 新規性は、 有価証券報告書の「事業等のリスク」に関する定性的な記述情報を、LLMを用いて体系的に分析 特に感染症リスクに焦点を当て、パンデミック前後のリスク認識の変化を時系列で可視化 事前のデータラベルのアノテーションやモデルの追加学習を行わず、公開情報のXBRLファイルと学習済みモデルのみを利用している 手法としては、 2016〜2018年度（コロナ前）と2019〜2021年度（コロナ後）の有価証券報告書のXBRLファイルを使用 有価証券報告書の「事業等のリスク」のセクションから、「可能性があります」を含む記述を抽出 金融BERT（東大和泉研）の学習済モデルを用いて分散表現を作成し、K-means法でクラスタリング Sentence BERTを用いてリスク記述文を再度分散表現化 PacMAPを用いて2次元空間上に次元縮約し、コロナ前後のデータ構造の差異を可視化 のプロセスで実施しています。 感染症リスクの記述件数を年度別に集計し、パンデミック前後での変化を確認したことや、次元縮約後のデータをプロットし、コロナ前後の記述内容の変化を視覚的に分析しています。 [2I6-GS-10-05] Graph Based Entropyと領域間相互作用を用いた株式市場の異常検知 〇中田 喜之1、吉野 貴晶1、杉江 利章1、夷藤 翔1、関口 海良2、劉 乃嘉2、大澤 幸生2 (1. ニッセイアセットマネジメント株式会社、2. 東京大学) 株式市場における異常検出を目的とし、Graph Based Entropyと領域間相互作用を使用してリスク指標を計算する方法の研究です。 長期的なビジネスサイクルに関連する株式の売却に偏りがあることを定量化し、これを基にリスク指標を導出ししていることに特徴があります。 TOPIX 500、S&P 500、STOXX Europe 600という3つの株価指数を対象に、既存のリスク指標（ボラティリティ、流動性、相関性）と比較したところ、既存の指標では捉えられないリスクを検出できる可能性が示されています。特に、下方リスクを抽出できているようです。 ランダム行列理論とLouvain法を用いて、強い関係を持つ株式群を抽出 構成銘柄を領域分けする 上記2点から、領域間相互作用を計算 上記を週次ごとに計算し、その性質を評価 [3Xin2] ポスターセッション1 [3Xin2-83] LLM-Traders : 大規模言語モデルを用いた金融時系列予測 伊藤 克哉1、〇中川 慧2 (1.三井物産株式会社、2.野村アセットマネジメント株式会社) 金融時系列の分析にLLMを使用する新しいアプローチの研究です。 ノイズの多いデータ、複雑かつ多様なモデル、そして常に変化する市場動向という3つの主要な課題に対処するために、LLMのファインチューニングとプロンプトエンジニアリングを組み合わせた方法を提案しています。 手法として、 時系列データを用いた教師ありfine-tuning：時系列データを文字列データに加工して、few-shot学習を行う 遺伝的アルゴリズムを用いて、ランダムにプロンプトを生成する。良いパフォーマンスだったプロンプトを生存させ、良いプロンプト同士を交雑させつつ、ランダムにプロンプトを発生させ続ける 動的アンサンブル法: 複数のプロンプト応答を組み合わせることで、分析の精度と適応性を向上 データはKaggleの「JPX Tokyo Stock Exchange Prediction」コンペティションのデータです。 LLM-Tradersは他のモデル（例えば、Lasso、LightGBM、RandomForest）と比較して優れたパフォーマンスを示し、特にAccuracy（ACC）やCorrelation（CORR）などの指標で高い評価になったようです。 [3Xin2-36] 大規模言語モデルの金融投資意思決定バイアスに関する評価指標の構築 〇立花 竜一1、中川 慧2、伊藤 友貴3、高野 海斗2 (1.三井情報株式会社、2.野村アセットマネジメント株式会社、3.三井物産株式会社) LLMが金融教育支援サービスにおいて、投資助言におけるバイアスを持つ可能性を評価するための指標を開発が目的です。 行動経済学の概念を用いて、リスク選好、時間選好、社会的選好に基づいたバイアス評価手法を提案し、実際にGPT-3.5およびPaLM2といったLLMを対象に評価を行っています。 評価メトリクスの開発: リスク選好、時間選好、社会的選好に基づいてLLMのバイアスを評価するメトリクスを開発 プロンプト設計: プロフィール情報（年齢、国籍、性別）と選好質問を組み合わせたプロンプトをLLMに入力し、出力を分析 統計分析: 出力結果を統計的に分析することで、LLMが持つバイアスの存在を定量化 GPT-3.5とPaLM2に対して、提案した評価手法を適用し、各種選好（リスク、時間、社会）に基づく出力結果を分析しています。 具体的な質問リストを用い、年齢、国籍、性別ごとに出力結果を比較・統計分析し、各LLMのバイアスの傾向を評価しています。 [3Xin2-68] 衛星画像による雲量を用いた電力需要予測の基礎検討 〇新沢 陸1、浦野 昌一1 (1.明治大学) 衛星画像を用いて電力需要予測を行うための基礎研究です。 衛星画像から雲量データを計算し、電力需要予測の特徴量として使用することで、予測の精度向上と衛星画像の有効性を確認することを目的としています。 従来の電力需要予測は、主に気象データや過去の需要データに依存していましたが、衛星画像という新しいデータソースを取り入れることで、予測精度の向上を図っています。 また、雲量データを具体的に利用することで、天候の変動が電力需要に与える影響をより詳細に把握しようとしています。 衛星画像から計算した雲量データを実際の電力需要予測に適用し、その予測精度を評価しています。 [3A4-PS-3] AIは『鉄腕アトム』の夢をみるか？～生成AIによるコンテンツ制作の可能性と問題 手塚 眞1 (1. 有限会社ネオンテトラ) NEDOの研究として、慶應大学の栗原教授と共同で プロジェクトを行っている （TEZUKA2020, TEZUKA2023）。 現状のAIの力に限界があることを理解しつつも、積極的に活用しているようでした。粘り強く取り組まれている印象でした。 「AIでは手塚治虫のような作品は作れない」という話に対し「人間でも無理ではないですか？」という質問があったのが印象的でした。 → ある程度平均的な作品と、将来にインパクトを与える高度なクリエイティブを分けて考える必要があるとの主張でした。 [3D5-GS-2] 機械学習：時系列 [3D5-GS-2-04] 階層型ネットワークの階層構造推定と異常検知への応用　金融時系列データの階層構造分析より金融市場異常検知とその原因分析 〇劉 乃嘉1、大澤 幸生1、関口 海良1、吉野 貴晶2、杉江 利章2、中田 喜之2、夷藤 翔2 (1. 東京大学、2. ニッセイアセットマネジメント株式会社) 金融市場の異常検知に階層型ネットワークモデルを適用する手法を提案です。 確率的ブロックモデル（SBM）を拡張して、階層型確率的ブロックモデル（HSBM）を構築し、市場構造の変化を検出することを目指しています。これにより、リーマンショックやコロナショックのような大規模な市場変動前の構造変化を早期に検出することが可能となります。 既存のLouvain法や単層のSBMに対して、階層型モデルを導入することで、より詳細かつ早期に市場構造の変化を検出できる点が新規性となります。 研究のポイント： 階層型確率的ブロックモデル（HSBM）の構築: 既存のSBMを拡張し、複数の階層を持つモデルを構築 階層構造推定: 下層のブロックを上層のノードと見なし、層ごとの隣接行列を用いて階層構造を推定 異常検知: 構造変化を検出し、その変化の原因を階層構造を通じて分析 S&P100の株式インデックスを対象に、リーマンショック（2008年）とコロナショック（2020年）の前後の構造変化を分析し、Louvain法およびSBMと比較して、HSBMがより早期かつ明確に構造変化を検出できることを示しました。 [3D5-GS-2-05] 主成分等価法による残差リターン抽出 〇今城 健太郎1、中川 慧2、的矢 知樹1、平野 正徳1、青木 雅奈2、今長谷 拓2 (1. 株式会社Preferred Networks、2. 野村アセットマネジメント株式会社) 金融資産リターンの共通ファクターに含まれない残差リターンを抽出する新しい手法の提案です。 この手法は主成分分析(PCA)に基づいており、従来のPCAが持つ問題点を解決するために、リターンを2つのグループに分けて解析します。 従来のPCAは共通ファクターの数を事前に決める必要があり、ファクターの数を多くするとノイズも増えるという問題がありました。 提案手法は、リターンを2つのグループに分け、一方から主成分を抽出し、もう一方から固有値を推定することで、安定的に良質な残差リターンを抽出できるようです。 手法： リターンをランダムに2つのグループに分ける 一方のグループから主成分を抽出し、もう一方のグループから固有値を推定 変換行列を作成し、残差リターンを抽出 複数回の試行で得られる変換行列の平均を使用 人工データおよび実際の市場データを用い検証した結果、 人工データでは、PCA法と比較して固有値の推定がより正確 実データを用いた検証では、提案手法が従来のPCA法よりも良質な残差リターンを抽出可能 という結果になったようです。 雑感 上記で書かせていただいたもの以外にも、大変高名な先生の基調講演があったり、ポスターセッションも素晴らしい発表ばかりでした。 夜は懇親会等にも顔を出させて頂きまして、大変勉強になりました。 企業のスポンサーも多く、webを見ますと96の組織が出展したようでした。企業側の注目度も高い大会だったように思います。

はじめに Insight EdgeのLead Engineerの日下です。 弊社ではフロントエンドのスクラッチ開発にReactを採用することが多いのですが、フロントエンドの保守性はしばしば課題となっています。 というのも、要求仕様が曖昧なPoC（Proof of Concept）の段階からMVP（Minimum Viable Product）として開発を進めることも多く、 ビジネス側ユーザの意見にも左右されながらアプリを改善していくため、画面のレイアウトやデザイン、画面遷移の変更が多発するためです。 こうした状況の中でスピードと品質を両立するためには良質なテストコードが不可欠なのはもちろん、 プロダクトコードとテストコードの双方とも、変化に対応しやすく作る必要があります。 過去にテスト駆動開発を挫折した要因 実は、筆者は過去にReactのテスト駆動開発の実践、および社内普及活動に挑戦したことがあったものの、以下のような理由で挫折してしまいました。 要因① テストコードの書き方を調べるのに時間がかかり、開発のスピードが落ちた Reactのテスト駆動開発に挑戦した際、最初に直面した大きな壁はテストコードの書き方を理解することでした。 React Testing LibraryのWebサンプルや書籍を参考にしながらテストコードを書いていましたが、 複雑なDOM構造のテストや非同期処理のテストをしようとすると初歩的な教材では対応できず、 プロダクトコードは書けてもテストコードをスムーズに書けないという状況に陥ってしまいました。 特に、UIの操作が関係するテストの書き方は複雑になることが多く、 テストコードの書き方を調べるのに時間がかかり、開発のスピードが落ちてしまいました。 要因② 画面の仕様変更が頻発し、テストコードの保守が重荷になった 前述の通り、弊社の開発では画面の仕様変更が頻発するため、テストコードの保守性が重要です。 しかし、ReactテストプログラムのWebサンプルや書籍では、ロジックと画面レイアウトが密結合になっている入門的なコンポーネントの例が多く紹介されていました。 それを参考にしたことで画面の仕様変更に対してテストコードの修正箇所が多くなってしまい、テストコードの保守が重荷になってしまいました。 要因③ ロジックとビューの分離を難しく考えすぎた 上記の問題は、ロジックとビューが密結合だったことに起因するため、ロジックとビューの分離を試みました。 Reactの場合、ロジックはカスタムフックとしてコンポーネントの外に切り出すことが一般的です。 しかし、どういう固まりで切り出して1つのカスタムフックにするかの考え方に悩んだり、 ロジック部分をhooksディレクトリに移動したことでコーディング時のファイル切り替えの手間が増えたりしてしまいました。 その結果、テストは書きやすくなったものの開発効率は上がりませんでした。 再挑戦への道筋 はてさて、挫折した当時から時代は移り変わり、今ではGitHub CopilotやChatGPTなどの生成AIを活用できるようになりました。弊社ではGitHub Copilot Businessを導入しており、全エンジニアが利用できます。 今なら、、、今ならあの頃のリベンジを果たせるかもしれない！ というわけで、今回はAIの力を借りてReactのテスト駆動開発に再挑戦してみることにしました。 リベンジに向けての方針は以下の通りです。 方針① はじめの一歩をAIに書いてもらう 生成AIを活用すれば、プロダクトコードからテストコードを生成できます。 仕様を網羅する完璧なテストケースとまではいかなくとも、典型的なテストケースを生成してもらえれば、 あとはそれを参考にして入出力値のバリエーションを変えたテストを追加するだけで良いため、 テストコード作成にかかる時間を大幅に短縮できるはずです。 方針② 完璧なテスト駆動にこだわらない テスト駆動開発は本来、テストコード→プロダクトコードの順に開発を進めますが、 そもそもプロダクトコードは書けるけどテストコードを書けないことが当初の挫折要因だったので、 テストコード作成で生成AIの力をフル活用したいところです。 そこで、まずは最低限の単純なプロダクトコードを書いて、AIに初期テストコードを書いてもらうことにします。 その上で、仕様を追加する際には生成されたテストコードを参考にすれば、テストコードの書き方に悩むことなくテスト駆動で開発を進められます。 また、画面レイアウトやUIコンポーネント等は動くモックアップとしてコーディングしながら仕様を固めていくことも多いため、テスト駆動で開発する対象はロジック部分に注力します。 ビュー部分については仕様が固まってからスナップショットテストを追加することとし、回帰テストを主目的とします。 （本記事ではビューのテストの詳細は割愛します。） 方針③ ロジックとビューの分離を単純化する ロジックとビューを分離してReactコンポーネントを記述しようとすると、そのコンポーネントでしか使われない（であろう）カスタムフックが多くなります。再利用性の高いロジックであれば単独のカスタムフックに切り出すことも重要ですが、一度しか使わないロジックまでhooksディレクトリに切り出すのは過剰な分離となり、凝集度が下がってしまいます。 そこで、再利用可能ロジックの部品化という観点とは無関係に、同一ファイル内でもできる単純なロジックとビューの分離方法をパターン化することで、デメリットを減らしつつコンポーネントの保守性を高めることを目指します。 コーディング例 前置きが長くなりましたが、ここからはサンプルコードを交えて上記内容の実践例を紹介します。 テスト対象コンポーネント（Before） ここではサンプルのコンポーネントとして、ごく簡易なユーザ登録フォームのUIを例にして説明します。 主な仕様は以下のとおりです。 メールアドレス、パスワード、パスワード再入力の3つの入力項目と、登録ボタンがある。 各入力項目は全て必須項目とする。 パスワード再入力の値がパスワードと一致しない場合はエラーメッセージを表示する。 入力内容にエラーがある場合、登録ボタンは非活性とする。 登録処理の結果をメッセージ領域に表示する。 まずはテストしにくいコードの例として、ロジックとビューが密結合になっているコンポーネントのコードを示します。 実際には、フォームを作るときはフォーム向け特化のhooksライブラリを使ったりしますが、今回はサンプルのため基本的なライブラリのみを使っています。 // import文は省略 export type ComponentProps = { onSubmit : ( data : { email : string ; password : string } ) => void ; signUpErrorMessage ?: string ; } ; export default function SignUpForm ( props : ComponentProps ) { const { onSubmit , signUpErrorMessage } = props; const [ email , setEmail ] = useState( "" ); const [ password , setPassword ] = useState( "" ); const [ passwordToConfirm , setPasswordToConfirm ] = useState( "" ); // パスワード再入力不一致のエラーメッセージ // メッセージ文字列の外部定義化は今回の論点ではないので、ここでは直接記述 const passwordToConfirmErrorMessage = password === passwordToConfirm ? "" : "Passwords do not match." ; // 入力エラーの有無（Submitボタンの活性/非活性に利用） const hasError = [ // 未入力チェック !email, !password, !passwordToConfirm, // エラーチェック passwordToConfirmErrorMessage, ] . some (( b ) => b); const handleSubmit = ( e : FormEvent ) => { e. preventDefault (); onSubmit( { email , password } ); } ; return ( < form onSubmit = { handleSubmit } > < div > < TextInput label = "Your Email" type = "email" value = { email } onChange = { ( e ) => setEmail(e. target .value) } /> </ div > < div > < TextInput label = "Your Password" type = "password" value = { password } onChange = { ( e ) => setPassword(e. target .value) } /> </ div > < div > < TextInput label = "Confirm Password" type = "password" value = { passwordToConfirm } onChange = { ( e ) => setPasswordToConfirm(e. target .value) } error = { passwordToConfirmErrorMessage } /> </ div > < Button type = "submit" disabled = { hasError } > Sign Up </ Button > { signUpErrorMessage && < Alert color = "red" > { signUpErrorMessage } </ Alert > } </ form > ); } このコードに対してCopilot Chatでテストを生成してもらうと、以下のようなテストコードが生成されました。 // import文は省略 describe ( "SignUpForm" , () => { let mockSubmit: jest.Mock < void , [{ email : string ; password : string }] >; beforeEach (() => { mockSubmit = jest.fn(); } ); it ( "フォームのレンダリング" , () => { const { getByLabelText } = render( < SignUpForm onSubmit = { mockSubmit } /> ); expect (getByLabelText( /your email/i )).toBeInTheDocument(); expect (getByLabelText( /your password/i )).toBeInTheDocument(); expect (getByLabelText( /confirm password/i )).toBeInTheDocument(); } ); it ( "パスワードが一致しない場合、送信されない" , async () => { const { getByLabelText , getByText } = render( < SignUpForm onSubmit = { mockSubmit } /> ); fireEvent.change(getByLabelText( /your email/i ), { target : { value : "test@example.com" } , } ); fireEvent.change(getByLabelText( /your password/i ), { target : { value : "password" } } ); fireEvent.change(getByLabelText( /confirm password/i ), { target : { value : "different" } , } ); fireEvent.click(getByText( /sign up/i )); await waitFor(() => { expect (mockSubmit).not.toHaveBeenCalled(); } ); } ); it ( "パスワードが一致する場合、送信される" , async () => { const { getByLabelText , getByText } = render( < SignUpForm onSubmit = { mockSubmit } /> ); fireEvent.change(getByLabelText( /your email/i ), { target : { value : "test@example.com" } , } ); fireEvent.change(getByLabelText( /your password/i ), { target : { value : "password" } } ); fireEvent.change(getByLabelText( /confirm password/i ), { target : { value : "password" } , } ); fireEvent.click(getByText( /sign up/i )); await waitFor(() => { expect (mockSubmit).toHaveBeenCalledWith( { email : "test@example.com" , password : "password" , } ); } ); } ); } ); 画面のDOM構造や入力項目のラベル文字列に強く依存したテストが生成されているため、画面レイアウトやラベル文字列が変更されるとテストコードも修正が必要になります。 また、このテストコードを参考にしながらロジックに対してテスト駆動開発をしようとすると、テストコードを書くときにビューのDOM構造を意識する必要があるため、 画面デザインが先に決まっていないとロジックの開発も進めづらいという問題があります。 テスト対象コンポーネント(After) 次に、ロジックとビューを分離したコンポーネントのコードを示します。 同一ファイルの中で、コンポーネントのロジックであるカスタムフック関数と、ビューを描画する関数に分割します。 // import文は省略 export type ComponentProps = { onSubmit : ( data : { email : string ; password : string } ) => void ; signUpErrorMessage ?: string ; } ; export function useComponent ( props : ComponentProps ) { const { onSubmit } = props; const [ email , setEmail ] = useState( "" ); const [ password , setPassword ] = useState( "" ); const [ passwordToConfirm , setPasswordToConfirm ] = useState( "" ); // パスワード再入力不一致のエラーメッセージ const passwordToConfirmErrorMessage = password === passwordToConfirm ? "" : "Passwords do not match." ; // 入力エラーの有無（Submitボタンの活性/非活性に利用） const hasError = [ // 未入力チェック !email, !password, !passwordToConfirm, // エラーチェック passwordToConfirmErrorMessage, ] . some (( b ) => b); const handleSubmit = ( e : FormEvent ) => { e. preventDefault (); onSubmit( { email , password } ); } ; return { email , setEmail , password , setPassword , passwordToConfirm , setPasswordToConfirm , passwordToConfirmErrorMessage , hasError , handleSubmit , } ; } type ComponentHookReturnType = ReturnType < typeof useComponent >; function ComponentView ( { props , hook , } : { props : ComponentProps ; hook : ComponentHookReturnType ; } ) { const { signUpErrorMessage } = props; const { email , setEmail , password , setPassword , passwordToConfirm , setPasswordToConfirm , passwordToConfirmErrorMessage , hasError , handleSubmit , } = hook; return ( < form onSubmit = { handleSubmit } > < div > < TextInput label = "Your Email" type = "email" value = { email } onChange = { ( e ) => setEmail(e. target .value) } /> </ div > < div > < TextInput label = "Your Password" type = "password" value = { password } onChange = { ( e ) => setPassword(e. target .value) } /> </ div > < div > < TextInput label = "Confirm Password" type = "password" value = { passwordToConfirm } onChange = { ( e ) => setPasswordToConfirm(e. target .value) } error = { passwordToConfirmErrorMessage } /> </ div > < Button type = "submit" disabled = { hasError } > Sign Up </ Button > { signUpErrorMessage && < Alert color = "red" > { signUpErrorMessage } </ Alert > } </ form > ); } // 親コンポーネントから呼ばれる、このコンポーネントのエントリポイント関数 export default function SignUpForm ( props : ComponentProps ) { const hook = useComponent(props); return < ComponentView hook = { hook } props = { props } /> ; } このコードのカスタムフック関数である useComponent に対してCopilot Chatでテストを生成してもらうと、以下のようなテストコードが生成されました。 // import文は省略 import { useComponent, ComponentProps, } from "@/components/features/file-upload/elements/SignUpFormAfter" ; describe ( "useComponent" , () => { let props: ComponentProps ; let onSubmitMock: jest.Mock ; beforeEach (() => { onSubmitMock = jest.fn(); props = { onSubmit : onSubmitMock, } ; } ); it ( "初期値が正しい" , () => { const { result } = renderHook(() => useComponent(props)); expect (result. current .email).toBe( "" ); expect (result. current . password ).toBe( "" ); expect (result. current .passwordToConfirm).toBe( "" ); } ); it ( "email, password, passwordToConfirmが更新される" , () => { const { result } = renderHook(() => useComponent(props)); act(() => { result. current .setEmail( "test@example.com" ); result. current .setPassword( "password" ); result. current .setPasswordToConfirm( "password" ); } ); expect (result. current .email).toBe( "test@example.com" ); expect (result. current . password ).toBe( "password" ); expect (result. current .passwordToConfirm).toBe( "password" ); } ); it ( "passwordToConfirmErrorMessageが設定される" , () => { const { result } = renderHook(() => useComponent(props)); act(() => { result. current .setPassword( "password" ); result. current .setPasswordToConfirm( "password2" ); } ); expect (result. current .passwordToConfirmErrorMessage).toBe( "Passwords do not match." ); } ); it ( "hasErrorが設定される" , () => { const { result } = renderHook(() => useComponent(props)); act(() => { result. current .setEmail( "" ); result. current .setPassword( "" ); result. current .setPasswordToConfirm( "" ); } ); expect (result. current .hasError).toBe( true ); } ); it ( "handleSubmitでonSubmitが呼ばれる" , async () => { const { result } = renderHook(() => useComponent(props)); act(() => { result. current .setEmail( "test@example.com" ); result. current .setPassword( "password" ); } ); act(() => { result. current .handleSubmit( { preventDefault : jest.fn() } as any); } ); expect (onSubmitMock).toHaveBeenCalledWith( { email : "test@example.com" , password : "password" , } ); } ); } ); ロジックのみを抽出したことによってフックの戻り値の各変数に対してのテストとなり、画面のDOM構造に依存しなくなったためテストコードの保守性が高まりました。 AIが生成したテストケースだけでは入力条件の網羅性は十分ではないものの、生成されたコードを参考にして入力値を変えるだけならば、イチからテストコードを書くよりもずっと容易にテストケースを追加できます。 テスト駆動で機能追加 さて、ここで新たな仕様として以下の機能を追加することを考えます。 メールアドレスの入力値がメールアドレス形式でない場合はエラーメッセージを表示する。 パスワードは8文字以上、英数記号の全てを含むことを必須とし、満たさない場合はエラーメッセージを表示する。 まず、フックの戻り値としてエラーメッセージ用の変数を追加し、固定値として空文字を返すようにしておきます（これだけ先に書いておかないとテストコードが型チェックにひっかかるため）。 // useComponent関数の戻り値 return { email, setEmail, emailErrorMessage: "" , // 追加 password, setPassword, passwordErrorMessage: "" , // 追加 passwordToConfirm, setPasswordToConfirm, passwordToConfirmErrorMessage, hasError, handleSubmit, } ; 次に、テストコードを追加します。 参考にすべきテストコードが既にある状態なので、テストケースの追加は容易です。 簡単なので自分でコーディングしても良いし、AIに書いてもらうこともできるでしょう。 筆者が以下のサンプルコードを書くときは自分で書き始めましたが、GitHub Copilotによる補完が良い感じに効いていました。 追加するテストケースの例を以下に示します。 it ( "Emailフォーマット正常" , () => { const { result } = renderHook(() => useComponent(props)); act(() => { result. current .setEmail( "test@example.com" ); } ); expect (result. current .emailErrorMessage).toBe( "" ); } ); it ( "Emailフォーマットエラー" , () => { const { result } = renderHook(() => useComponent(props)); act(() => { result. current .setEmail( "invalid-email-format" ); } ); expect (result. current .emailErrorMessage).toBe( "Invalid email address format." ); } ); it ( "パスワードが基準を満たす" , () => { const { result } = renderHook(() => useComponent(props)); act(() => { result. current .setPassword( "P@ssw0rd" ); } ); expect (result. current .passwordErrorMessage).toBe( "" ); } ); it ( "パスワードが基準を満たさない(長さ)" , () => { const { result } = renderHook(() => useComponent(props)); act(() => { result. current .setPassword( "P@ssw0r" ); } ); expect (result. current .passwordErrorMessage).toBe( "Password must be at least 8 characters, and contain upper-case and lower-case alphabet, and number." ); } ); it ( "パスワードが基準を満たさない(数字なし)" , () => { const { result } = renderHook(() => useComponent(props)); act(() => { result. current .setPassword( "SimpleLongPassword!" ); } ); expect (result. current .passwordErrorMessage).toBe( "Password must be at least 8 characters, and contain upper-case and lower-case alphabet, and number." ); } ); it ( "パスワードが基準を満たさない(使えない文字を含む)" , () => { const { result } = renderHook(() => useComponent(props)); act(() => { result. current .setPassword( "P@ss W0rd" ); } ); expect (result. current .passwordErrorMessage).toBe( "Password must be at least 8 characters, and contain upper-case and lower-case alphabet, and number." ); } ); この時点では、エラーメッセージが固定値なのでテストはもちろん通りません。 フックのロジックを修正して、メールアドレスの入力値がメールアドレス形式でない場合はエラーメッセージを表示するようにします。 たとえば以下のように実装してみました。 // ====== サンプルコードのため同一ファイルに記述 ====== function isValidPassword ( password : string ) { // !から~までの文字コードからなる8文字以上で、大文字、小文字、数字をそれぞれ1つ以上含む const conditions = [ /^[!-~]{8,}$/ , /[A-Z]/ , /[a-z]/ , /\d/ ] ; return conditions. every (( regex ) => regex. test (password)); } function isValidEmail ( email : string ) { return /^[^\s@]+@[^\s@]+\.[^\s@]+$/ . test (email); } // ====================================================== export type ComponentProps = { onSubmit : ( data : { email : string ; password : string } ) => void ; signUpErrorMessage ?: string ; } ; export function useComponent ( props : ComponentProps ) { const { onSubmit } = props; const [ email , setEmail ] = useState( "" ); const [ password , setPassword ] = useState( "" ); const [ passwordToConfirm , setPasswordToConfirm ] = useState( "" ); // メールアドレスのエラーメッセージ const emailErrorMessage = isValidEmail(email) ? "" : "Invalid email address format." ; // パスワードのエラーメッセージ const passwordErrorMessage = isValidPassword(password) ? "" : "Password must be at least 8 characters, and contain upper-case and lower-case alphabet, and number." ; const passwordToConfirmErrorMessage = password === passwordToConfirm ? "" : "Passwords do not match." ; const hasError = [ // 未入力チェック !email, !password, !passwordToConfirm, // エラーチェック emailErrorMessage, passwordErrorMessage, passwordToConfirmErrorMessage, ] . some (( b ) => b); const handleSubmit = ( e : FormEvent ) => { e. preventDefault (); onSubmit( { email , password } ); } ; return { email , setEmail , emailErrorMessage , password , setPassword , passwordErrorMessage , passwordToConfirm , setPasswordToConfirm , passwordToConfirmErrorMessage , hasError , handleSubmit , } ; } // ビューの描画関数は省略 これでテストが通るようになり、テスト駆動で機能追加ができました。 まとめ 本記事では、Reactのテスト駆動開発に再挑戦するための方針と、生成AIを活用した実践例を紹介しました。 生成AIを活用してテストコード作成の負担を軽減することでテスト駆動開発を導入するハードルが低くなり、 品質や保守性の高いプロダクトコードおよびテストコードを維持しやすくなることが期待できます。 まだ試行し始めたばかりですが、この方法でプロダクトリリースまで回してみたら、改めて振り返りの記事も書いてみたいと思います。

init_mathjax = function() { if (window.MathJax) { // MathJax loaded MathJax.Hub.Config({ TeX: { equationNumbers: { autoNumber: "AMS", useLabelIds: true } }, tex2jax: { inlineMath: [ ['$','$'], ["\\(","\\)"] ], displayMath: [ ['$$','$$'], ["\\[","\\]"] ], processEscapes: true, processEnvironments: true }, displayAlign: 'left', CommonHTML: { linebreaks: { automatic: true } } }); MathJax.Hub.Queue(["Typeset", MathJax.Hub]); } } init_mathjax(); addEventListener("DOMContentLoaded",function(){var a=document.getElementsByClassName("entry-content");if(a)for(var i=0;i はじめに Frank-Wolfe法とは 誘導されるスパース性 アルゴリズムの比較確認 問題設定 比較手法 結果 次元数$n = 10^{2}$の場合 次元数$n = 10^{3}$の場合 所感 まとめ 参考文献 参考：使用したコード （著者：分析チーム　hawai06） はじめに ビッグデータや機械学習の技術を活用したDX推進/分析プロジェクトでは、計算量が少なく、機械学習に特有な問題構造を上手く取り扱えるアルゴリズムが必要と考えられる。特に弊社が行なっているようなビジネス課題を解決するプロジェクトの場合は、成果物をビジネスへ活用しやすいよう解釈性に富んでいる方が良く、出力がスパースなアルゴリズムが望ましいと思われる。 　一方Frank-Wolfe法とは制約付き最適化問題を解くアルゴリズムであり、最適制御や均衡問題など幅広く用いられている。このアルゴリズムは計算量が少なく、さらに機械学習によく現れる制約条件を取り扱い易いため、近年では機械学習やデータサイエンスなどの分野にも適用されている。また出力される解がスパースになることが知られていることから、このアルゴリズムはビジネス課題の解決手法として候補たり得るものであると思われる。 　そこで本稿では、Frank-Wolfe法の詳細およびスパース性が誘導される理由を確認するとともに、実務での有用性を簡易な数値実験を通して確認することとする。 Frank-Wolfe法とは 　Frank-Wolfe法は、コンパクトな凸集合$\mathcal{C}$上で定義された、平滑で微分可能な関数$f$の最小値を求めるアルゴリズムである。 解の更新方法は適切なステップ幅を$a_k$を用いて として記述できる。ステップ幅は$f$の性質により決められる方法が異なり、連続微分可能であるならば直線探索や関数の曲率を用いて定めても良く、また凸であるならば$a_k = \frac{2}{k+2}$としても良い。 　$s_k$を求める際は制約付きの線形関数の最小化問題を解くことになるが、制約条件の構造を考慮することで効率良く解ける。例えば$C = \lbrace x | || x|| \le 1 \rbrace$であるならば、Danskin-Bertsekas's Theoremから双対ノルムの劣微分$\partial || \cdot ||_{*}$を用いて$s_k = - \partial || \nabla f(x_k) ||_{*}$となり、計算で求められる場合は簡易に導出できる。$s_k \in \mathcal{C}$より、$x_{k+1}$は常に実行可能解となる。 誘導されるスパース性 初期点$x_0 = 0 \in \mathcal{C}$、$\mathcal{C} \subset \mathbb{R}^n$を仮定すると、Frank-Wolfe法はその解の更新方法より、$x_k$が$\min \lbrace k, n+1 \rbrace$個のデータ点で記述できるため、$k \ll n$の場合はスパース性を持つと言える。このことから$x_k$の非ゼロ要素数はアルゴリズムの収束レートに関連することがわかる。 　スパースな解が得られる例として$\mathcal{C} = \lbrace x | || x ||_1 \le 1 \rbrace$を考えると、$\forall k \in \mathbb{N}$に対して$s_k = \text{sign} \left( \nabla f( x^{k-1} )_{i_{k-1}} \right) \cdot e_{i_{k-1}}$となる。よって$k \le n$の場合は$x_k$は非ゼロ要素数が$k$個となり、収束性が良いほどスパースな解が求まり得る。（ ただし、$i_{k-1} = \operatorname{argmax}_{i=1,\dots,n} \left| \nabla f( x^{k-1})_{i} \right|$、$e_i$は$i$番目の要素のみ$1$でそれ以外の要素は$0$のベクトル、$\nabla f( x^{k-1})_{i}$は$\nabla f( x^{k-1})$の$i$番目の要素を指す）。 　上記より収束性を向上させることでスパースな解を得られる様になるが、アルゴリズムを工夫することでもスパース性は達成され得る。例えば、Fully-Corrective Frank-Wolfe algorithm (以下、FCFW)は次のように解を更新することでFrank-Wolfe法よりもスパースな解が得られるとの報告がある。 初期値$\mathcal{S}_{0} = \lbrace x_0 \rbrace$とする。このアルゴリズムは、これまでの反復で選んだ頂点集合の凸包で最適化計算して解を更新するため、計算量が多くなるという課題がある。 アルゴリズムの比較確認 問題設定 　実務でのFrank-Wolfe法の活用を検討するにあたり、機械学習にてよく見られる$l1$-ballを定義域にした次の問題を題材にする。 $x^{*}$は定義域に含まれないよう、定義域の極点をランダムに選んだ$m$点の凸結合に対して$2$倍したものとした。本数値実験では$n$および$m$を適当に変えた場合の、計算時間、出力された解の非ゼロ要素数の個数および$x^{*}$との$l2$-normを確認し、スパース性および解としての適性を評価した。Frank-Wolfe法は解の更新回数により得られる解のスパース度合い変わりうるため、最大更新回数を$10^{6}$と十分多くした。 比較手法 Frank-Wolfe法（以下、FW）、FCFWのスパース性との比較手法として、射影勾配法（以下、PGD）および一般的な方法としてSLSQPを用いた。FWはステップ幅は$\frac{2}{k+2}$および直線探索を別に用いることにし、前者をFW-naive、後者をFW-lineと表記する。PGDは、高次元の問題設定にも適用できるよう、確率単体への射影を基にした射影方法を採用しており、 こちら に掲載されているコードをまま使用した。またSLSQPを適用するにあたり、$l1$-ballに対してスラック変数を導入して線形緩和した。これら全ての手法はpythonやそのライブラリを用いて実装している。 結果 次元数$n = 10^{2}$の場合 $x^{*}$の非ゼロ要素数$m$変化させた時の結果を下に示す。結果の傾向は$n = 10^{2}$と同様になった。計算時間はFCFWが最も長く、SLSQPが次に長いという結果になった。他手法は十分計算時間が短い。$|| x-x^{*} ||_2$はPGDとSLSQPが一致しており、それぞれ最適解に到達していると考えられる。厳密な直線探索をしているFW-lineはFW-naiveと比較して最適解に近い結果が得られた一方、FW-naiveは次元数を増やしても値が減少していない。アルゴリズムの出力解の非ゼロ要素数を確認すると、PGDとSLSQPは$|| x-x^{*} ||_{2}$と同様に一致している。PGDは$x^{*}$の非ゼロ要素数$m$が$1$の場合、本実験においては数値的に不安定になり、原点を出力していたことから$0$の値を示している。FW-naiveは$m \ge 20$以上の場合、出力される解の非ゼロ要素数が$1$となっている。 次元数$n = 10^{3}$の場合 先と同様に$m$変化させた時の結果を下に示す。計算時間は、$n = 10^{2}$とは逆にSLSQPが最も長く、FCFWが次に長いという結果となった。他手法は$m$を増加させてもほとんど変わらず、$10^{-3}$秒以下で計算が済んでいる。アルゴリズムの出力解の非ゼロ要素数の傾向は$n = 10^{2}$と同様の結果となったが、縦軸を対数スケールにしているため、上述した$m=1$の時のPGDの値$0$は特異な挙動を示している。 所感 本数値実験において、FCFWは$n \le 10^{3}$においても1秒程度で計算が終了しており、最適解に近く、比較的スパースな解が得られたため、有用な手法であると思われる。しかし、$n = 10^{6}$とした予備実験において$m=10^{2}$では計算時間が3.5時間を超え、$m$を大きくするごとに計算時間が増大していった。内部問題の求解ではできる限り解析的に実装したが、大規模な問題への適用の際はCythonで実装するなど更なる工夫が必要である。 　また、PGDとSLSQPは最適解が得られていると考えられる。その中でもPGDは計算時間がかなり短かった。予備実験においても、PGDは最も計算時間が短く$1$秒以内に解が得られた。そのため本問題を実務で取り扱う際は、活躍する可能性が非常に高いと思われる。 　FWについては、ステップ幅の決定方法により大きく異なる結果が得られた。FW-naiveは出力される解の非ゼロ要素数が$1$などであり、解の更新がほとんどなされていないことがわかる。最適解が定義域の境界の場合、FW-naiveは収束性が非常に悪くなることが知られており、今回の問題設定はこれに該当する。そのためコスト関数の改善が十分小さすぎるために、解の更新がなされないまま、計算の終了基準を満たしてしまったと考えられる。一方、FW-linearは出力される解の非ゼロ要素数はFW-naiveに次いで小さく、また$|| x-x^{*} ||_{2}$も他手法と比してそれほど大きい値ではない。$|| x-x^{*} ||_{2}$を小さくしたい場合は、スパース性が犠牲になるものの計算の終了基準を厳しくすれば良く、実務では柔軟に利用できると考えられる。 まとめ 　本稿では、Frank-Wolfe法は他の手法と比較して、得られる解がスパースになることを解の更新方法および数値実験を通して確認した。数値実験は$l2$ノルムを用いた$l1$-ballへの凸射影を題材にしており、厳密な直線探索を用いたFrank-Wolfe法は計算時間・最適解からの距離の観点から、実用的なスパース解が得られたと思われる。また本稿では実装について述べていないが、実装が比較的容易であった。これらのことから、ビッグデータを取り扱うような実務に際して、Frank-Wolfe法は採用しやすい最適化手法であると言える。 参考文献 Bertsekas, Dimitri P. Control of uncertain systems with a set-membership description of the uncertainty. Diss. Massachusetts Institute of Technology, 1971. Bomze, Immanuel M., Francesco Rinaldi, and Damiano Zeffiro. "Frank–Wolfe and friends: a journey into projection-free first-order optimization methods." 4OR 19 (2021): 313-345. Clarkson, Kenneth L. "Coresets, sparse greedy approximation, and the Frank-Wolfe algorithm." ACM Transactions on Algorithms (TALG) 6.4 (2010): 1-30. Combettes, Cyrille W., and Sebastian Pokutta. "Revisiting the approximate Carathéodory problem via the Frank-Wolfe algorithm." Mathematical Programming 197.1 (2023): 191-214. Duchi, John, et al. "Efficient projections onto the l 1-ball for learning in high dimensions." Proceedings of the 25th international conference on Machine learning. 2008. Jaggi, Martin. "Revisiting Frank-Wolfe: Projection-free sparse convex optimization." International conference on machine learning. PMLR, 2013. Lacoste-Julien, Simon. "Convergence rate of frank-wolfe for non-convex objectives." arXiv preprint arXiv:1607.00345 (2016). Pokutta, Sebastian. "The Frank-Wolfe algorithm: a short introduction." Jahresbericht der Deutschen Mathematiker-Vereinigung 126.1 (2024): 3-35. 参考：使用したコード 以下に本数値実験で使用したコードを掲載する。PGDは、先に述べたように こちら のコードを用いているため掲載は割愛する。 FW関連（optimization.py） import numpy as np def generate_problem (optimal_point : np.array): """ Function Explanation: 最適解を指定して、コスト関数とその勾配を生成する関数 Inputs: optimal_point : np.array 最適解 Returns: cost_function : callable コスト関数 grad_cost_function : callable コスト関数の勾配 """ def cost_function (x : np.array): """ Function Explanation: 二乗ノルムを用いたコスト関数 Inputs: x : np.array 点 Returns: (float.) 関数の値 """ return (np.linalg.norm(x - optimal_point, ord = 2 )** 2 )/ 2 def grad_cost_function (x : np.array): """ Function Explanation: 二乗ノルムを用いたコスト関数の勾配 Inputs: x : np.array 点 Returns: (np.array) 勾配 """ return x - optimal_point return cost_function, grad_cost_function def frank_wolfe (x0 : np.array, grad_f : callable , f : callable , step_size : str , max_iter : int = np.inf, tol : float = 1e-6 ): """ Function Exeplanetion: Frank-Wolfe法を用いて、最適化問題を解く関数。 Inputs: x0 : np.array 初期点 f : callable 目的関数 grad_f : callable 勾配関数 step_size : str 'diminish'： 2/2+iteration 'line search' : 直線探索 max_iter : int 最大反復回数 tol : float 収束判定の閾値 Returns: x : np.array 最適解 """ # 初期条件の設定 iteration = 1 x = x0 improve = np.inf f_list = [f(x0)] while (iteration < max_iter) and (improve > tol): # 点の設定 x_k = x old = f(x_k) # 更新方向 index = np.argmax(np.abs(grad_f(x))) s_k = np.zeros( len (x)) s_k[index] = -np.sign(grad_f(x)[index]) # ステップ幅 if step_size == 'diminish' : step_size = 2 /(iteration + 2 ) elif step_size == 'line search' : norm_s_k = np.linalg.norm(s_k - x, ord = 2 ) if norm_s_k == 0 : break else : step_size = \ -np.dot(s_k, grad_f(x)) / norm_s_k** 2 if step_size < 0 : step_size = 0 elif step_size > 1 : step_size = 1 # 更新 print (iteration) x = x_k + step_size * (s_k - x_k) iteration += 1 improve = 1 - (f(x) / old ) f_list.append(f(x)) return x #, f_list def find (s, S): for i in range ( len (S)): if np.all(S[i] == s): return True return False def FullyCorrectiveFrankWolfe (x0 : np.array, grad_f : callable , f : callable , optimal_point : np.array, max_iter : int = np.inf, tol : float = 1e-6 , inner_max_iter : int = np.inf, inner_tol : float = 1e-6 ): """ Function Explanation: Fully Corrective Frank-Wolfe法を用いて、最適化問題を解く関数。 Inputs: x0 : np.array 初期点 f : callable 目的関数 grad_f : callable 勾配関数 max_iter : int 最大反復回数 tol : float 収束判定の閾値 optimal_point : np.array 本数値実験の最適解 inner_max_iter : int 内部問題の最大反復回数 inner_tol : float 内部問題の収束判定の閾値 Returns: x : np.array 最適解 """ # 初期条件の設定 iteration = 1 x = x0 S = list () S.append(x) impove = np.inf f_list = [f(x0)] while (iteration < max_iter) and (impove > tol): # 点の設定 x_k = x old = f(x_k) # Sの集合を構築 ## 要素取得 index = np.argmax(np.abs(grad_f(x_k))) s_k = np.zeros( len (x_k)) s_k[index] = -np.sign(grad_f(x_k)[index]) ## 要素の追加 if find(s_k, S) == False : S.append(s_k) # 内部問題を解いて解の更新 inner_improve = np.inf inner_iteration = 1 while (inner_iteration < inner_max_iter) and (inner_improve > inner_tol): # ループ情報の設定 inner_old = f(x) inner_iteration += 1 # 内部問題の求解 inner_index = np.argmin(np.dot(np.array(S), grad_f(x))) norm_s_k = np.linalg.norm(S[inner_index] - x, ord = 2 ) if norm_s_k == 0 : break else : step_size = \ -np.dot(S[inner_index],grad_f(x)) / norm_s_k** 2 if step_size < 0 : step_size = 0 elif step_size > 1 : step_size = 1 x = x + step_size * (S[inner_index] - x) # ループ情報の更新 inner_improve = 1 - (f(x) / inner_old ) # ループ情報の更新 iteration += 1 improve = 1 - (f(x) / old ) f_list.append(f(x)) return x #, f_list if __name__ == "__main__" : # ライブラリの読み込み import os from problem_setting import generate_optimal_point # 最適解の生成 dimensions = 100 combination_num = 10 optimal_point = generate_optimal_point(dimensions, combination_num, in_range = 'out' , out_coef = 2 ) # 問題の生成 f, grad_f = generate_problem(optimal_point) #　最適化アルゴリズムの実行 initial_point = np.zeros(dimensions) print ( "FW" ) FW_solution = frank_wolfe(initial_point, grad_f, f, step_size = 'diminish' , max_iter = 10000 , tol = 1e-6 ) print ( "FC" ) FCFW_solution = FullyCorrectiveFrankWolfe( initial_point, grad_f, f, optimal_point, max_iter = 1000 , tol = 1e-6 , inner_max_iter = 1000 , inner_tol = 1e-6 ) SLSQP（slsqp.py） import numpy as np from problem_setting import generate_optimal_point from optimization import generate_problem from scipy.optimize import minimize import os import copy class SLSQP : def __init__ (self, optimal_point : np.array, dimensions : np.array, initial_point : np.array): self.dimensions = dimensions self.optimal_point = optimal_point self.initial_point = self._generate_initial_point_for_slack_var( initial_point ) def _generate_initial_point_for_slack_var (self, optimal_point : np.array): copy_optimal_point = np.copy(optimal_point) initial_point_for_slack_var = np.concatenate( [optimal_point, copy_optimal_point], 0 ) return initial_point_for_slack_var def _upper_bound_const (self, index): return { 'type' : 'ineq' , 'fun' : lambda x: x[index + self.dimensions] - x[index]} def _genrate_upper_bound_const (self): const_list = list () for index in range (self.dimensions): const_list.append(self._upper_bound_const(index)) return const_list def _lower_bound_const (self, index): return { 'type' : 'ineq' , 'fun' : lambda x: x[index] + x[index + self.dimensions]} def _genrate_lower_bound_const (self): const_list = list () for index in range (self.dimensions): const_list.append(self._lower_bound_const(index)) return const_list def _genrate_l1_bound_const (self): const_list = list () const_list.append( { 'type' : 'ineq' , 'fun' : lambda x: 1 - np.sum(x[self.dimensions:])} ) return const_list def _generate_cost_function (self): """ Function Explanation: 二乗ノルムを用いたコスト関数 Inputs: x : np.array 点 Returns: (float.) 関数の値 """ return lambda x: np.sum(x[self.dimensions:]** 2 )/ 2 - \ np.dot(x[:self.dimensions], self.optimal_point) + \ np.sum(self.optimal_point** 2 )/ 2 def solve (self): # 問題の生成 cost_function = self._generate_cost_function() # 制約条件の作成 ## l1-ball constraints = [] constraints.extend(self._genrate_upper_bound_const()) constraints.extend(self._genrate_lower_bound_const()) constraints.extend(self._genrate_l1_bound_const()) ## box_const bounds = [] bounds.extend([(- 1 , 1 ) for i in range (self.dimensions)]) bounds.extend([( 0 , 1 ) for i in range (self.dimensions)]) solution = minimize( cost_function, x0 = self.initial_point, method = 'SLSQP' , constraints = constraints, bounds = bounds, options = { 'maxiter' : 1000 , 'disp' : True }, tol = 1e-9 ) return solution def solution_arrange (self, solution, eps = 1e-6 ): solution_mask = np.abs( solution.x[:self.dimensions] ) > eps optimal_solution = np.empty(self.dimensions) optimal_solution[solution_mask] = solution.x[:self.dimensions][solution_mask] optimal_solution[~solution_mask] = np.zeros(self.dimensions)[~solution_mask] return optimal_solution if __name__ == "__main__" : # 最適解の生成 dimensions = 10 combination_num = 2 optimal_point = generate_optimal_point(dimensions, combination_num, in_range = 'in' , out_coef = 2 ) #optimal_point = np.random.randn(dimensions) #optimal_point = optimal_point / np.sum(np.abs(optimal_point)) initial_point = np.zeros(dimensions) # 問題の生成 func = SLSQP(optimal_point, dimensions, initial_point) func.initial_point.shape solution = func.solve() optimal_solution = func.solution_arrange(solution) print (optimal_solution) print (optimal_point) 最適解の生成（problem_setting.py） import numpy as np def generate_optimal_point (dimensions : int , combination_num : int , in_range : str , out_coef : float = 1.0 ): """ Function Explanation: l1-ball上の極点の凸結合として定義される、スパースな点を生成する関数。 'in_range'を変更することで、生成される点がl1-ballの内外のどちらになるかを指定できる。 Inputs: dimensions : int 初期点の次元数 combination_num : int 初期点の生成にあたり、利用する極点の数 （注意：combination_num <= dimensions） in_range : str 生成される点がl1-ballの内外のどちらになるかを指定するパラメータ 'in' : l1-ballの内部に生成される 'out' : l1-ballの外部に生成される out_coef : float 'in_range'が'out'の場合に、l1-ballの外部に生成される点の係数 Returns: coordinates : np.array 生成された点 """ # スパースな点が生成されるかの確認 if combination_num > dimensions: raise ValueError ( "'combination_num' must be less than or equal to 'dimensions'." ) # 初期点生成にあたり、関与する座標の決定 # 各要素が0からdimensions-1までの整数値のベクトル rng = np.random.default_rng() coordinates_list = rng.integers(low = 0 , high = dimensions, size= combination_num, dtype=np.int64, endpoint= True ) # 初期生成のための重み作成 weights = rng.uniform(low=- 1 , high= 1 , size=combination_num) weights = weights / np.sum(np.abs(weights)) # 初期点生成 coordinates = np.zeros(dimensions) for i, index in enumerate (coordinates_list): coordinates[index] += weights[i] # l1-ballの外部に生成される場合 if in_range == 'out' : coordinates = coordinates * out_coef elif in_range == 'in' : pass else : raise ValueError ( "in_range must be 'in' or 'out'." ) return coordinates 数値実験（experiment.py） import os import pickle import numpy as np import pandas as pd import matplotlib.pyplot as plt from time import time plt.rcParams[ 'font.family' ] = 'Hiragino Sans' plt.rcParams[ 'xtick.direction' ] = 'in' plt.rcParams[ 'ytick.direction' ] = 'in' # 問題設定のライブラリ from problem_setting import generate_optimal_point # frank-wolfe法のライブラリ from optimization import frank_wolfe, FullyCorrectiveFrankWolfe,generate_problem # SLSQPのライブラリ from slsqp import SLSQP # PGDのライブラリ from pgd import euclidean_proj_l1ball # 実験の初期点を保存関数（確率的にエラーが出るため、保存） ################################################## def save_optimal_point (dimensions : int , non_zero_nums : dict , in_range : str , out_coef : int , save_name : str ): # 格納箱 dim_optimal_dict = {num : None for num in non_zero_nums} # データ点の生成 for num in non_zero_nums: optimal_point = generate_optimal_point( dimensions, combination_num = num, in_range = in_range, out_coef = out_coef ) dim_optimal_dict[num] = optimal_point # データ保存 with open (save_name, "wb" ) as f: pickle.dump(dim_optimal_dict, f) return None ################################################## # 実験の初期設定の準備 ## 準備 problem_setting_dict = { 100 : { 'non_zero_nums' : [ 1 , 5 , 10 , 20 , 50 , 80 , 90 ], 'method_names' : [ 'FW - naive' , 'FW - line' , 'FCFW' , 'PGD' , 'SLSQP' ], 'save_name' : 'dim_100_optimal_dict.pkl' , 'solution_save_name' : 'dim_100_solution_dict.pkl' , 'time_save_name' : 'dim_100_time_dict.pkl' }, 10 ** 6 : { 'non_zero_nums' : [ 1 , 5 , 10 , 50 , 100 , 500 , 1000 , 10000 ], 'method_names' : [ 'FW - naive' , 'FW - line' , 'FCFW' , 'PGD' ], 'save_name' : 'dim_10**6_optimal_dict.pkl' , 'solution_save_name' : 'dim_10**6_solution_dict.pkl' , 'time_save_name' : 'dim_10**6_time_dict.pkl' }, 1000 : { 'non_zero_nums' : [ 1 , 5 , 10 , 25 , 50 , 75 , 100 , 250 , 500 , 750 ], 'method_names' : [ 'FW - naive' , 'FW - line' , 'FCFW' , 'PGD' , 'SLSQP' ], 'save_name' : 'dim_1000_optimal_dict.pkl' , 'solution_save_name' : 'dim_1000_solution_dict.pkl' , 'time_save_name' : 'dim_1000_time_dict.pkl' }, } ## データ点生成+保存 #dimensions = 100 #dimensions = 10**6 #dimensions = 1000 #save_optimal_point( # dimensions, # problem_setting_dict[dimensions]['non_zero_nums'], # in_range = 'out', # out_coef = 2, # save_name = problem_setting_dict[dimensions]['save_name'] # ) # 問題を解く ## 初期設定 dimensions = 1000 ## 問題の読み込み with open (problem_setting_dict[dimensions][ 'save_name' ], 'rb' ) as f: dim_optimal_dict = pickle.load(f) # 各手法の計算 ## 計算結果の格納箱 solution_dict = { method : {num : None for num in problem_setting_dict[dimensions][ 'non_zero_nums' ]} for method in problem_setting_dict[dimensions][ 'method_names' ] } time_dict = { method : {num : None for num in problem_setting_dict[dimensions][ 'non_zero_nums' ]} for method in problem_setting_dict[dimensions][ 'method_names' ] } ## 計算 for num in problem_setting_dict[dimensions][ 'non_zero_nums' ]: # 初期設定 ## 最適解 optimal_point = dim_optimal_dict[num] # FC、FCFW ## 問題、初期点の生成 f, grad_f = generate_problem(optimal_point) initial_point = np.zeros(dimensions) ## 実行 ### FW diminish print ( 'num：' , num, '　FW - naiveを開始' ) FW_naive_start = time() solution_dict[ 'FW - naive' ][num] = frank_wolfe( initial_point, grad_f, f,step_size = 'diminish' , max_iter = 10000 , tol = 1e-6 ) FW_naive_end = time() time_dict[ 'FW - naive' ][num] = FW_naive_end - FW_naive_start print ( 'num：' , num, '　FW - naiveの時間：' , time_dict[ 'FW - naive' ][num]) ### FW 直線探索 print ( 'num：' , num, 'FW - lineを開始' ) FW_line_start = time() solution_dict[ 'FW - line' ][num] = frank_wolfe( initial_point, grad_f, f,step_size = 'line search' , max_iter = 10000 , tol = 1e-6 ) FW_line_end = time() time_dict[ 'FW - line' ][num] = FW_line_end - FW_line_start print ( 'num：' , num, '　FW - lineの時間：' , time_dict[ 'FW - line' ][num]) ### FCFW print ( 'num：' , num, 'FCFWを開始' ) FCFW_start = time() solution_dict[ 'FCFW' ][num] = FullyCorrectiveFrankWolfe( initial_point, grad_f, f, optimal_point, max_iter = 10000 , tol = 1e-6 , inner_max_iter = 1000 , inner_tol = 1e-6 ) FCFW_end = time() time_dict[ 'FCFW' ][num] = FCFW_end - FCFW_start print ( 'num：' , num, '　FCFWの時間：' , time_dict[ 'FCFW' ][num]) # PGD print ( 'num：' , num, 'PGDを開始' ) PGD_start = time() solution_dict[ 'PGD' ][num] = euclidean_proj_l1ball( optimal_point, s= 1 ) PGD_end = time() time_dict[ 'PGD' ][num] = PGD_end - PGD_start print ( 'num：' , num, '　PGDの時間：' , time_dict[ 'PGD' ][num]) # SLSQP（次元数100、1000の時だけ実行） if (dimensions == 100 ) | (dimensions == 1000 ): print ( 'num：' , num, 'SLSQPを開始' ) SLSQP_start = time() # 初期設定 func = SLSQP(optimal_point, dimensions, initial_point) # 求解 slsqp_solution = func.solve() # 解の整形 solution_dict[ 'SLSQP' ][num] = func.solution_arrange(slsqp_solution) SLSQP_end = time() time_dict[ 'SLSQP' ][num] = SLSQP_end - SLSQP_start print ( 'num：' , num, '　SLSQPの時間：' , time_dict[ 'SLSQP' ][num]) # 結果の保存 with open (problem_setting_dict[dimensions][ 'solution_save_name' ], "wb" ) as f: pickle.dump(solution_dict, f) with open (problem_setting_dict[dimensions][ 'time_save_name' ], "wb" ) as f: pickle.dump(time_dict, f) # 結果を開く dimensions = 100 with open (problem_setting_dict[dimensions][ 'save_name' ], 'rb' ) as f: dim_optimal_dict = pickle.load(f) with open (problem_setting_dict[dimensions][ 'solution_save_name' ], 'rb' ) as f: solution_dict = pickle.load(f) with open (problem_setting_dict[dimensions][ 'time_save_name' ], 'rb' ) as f: time_dict = pickle.load(f) # 可視化 ################################################# plt.figure(figsize = ( 30 , 5 )) if dimensions == 100 : plt.suptitle( '$n=100$' ) elif dimensions == 1000 : plt.suptitle( '$n=1000$' ) plt.subplot( 1 , 3 , 1 ) for method in problem_setting_dict[dimensions][ 'method_names' ]: plt.plot(problem_setting_dict[dimensions][ 'non_zero_nums' ], [time_dict[method][num] for num in problem_setting_dict[dimensions][ 'non_zero_nums' ]], 'x--' , label = method) plt.xlabel( '$x^*$の非ゼロ要素数' ) plt.ylabel( '時間' ) if dimensions == 100 : plt.xlim([ 0 , 100 ]) plt.xticks([ 20 * i for i in range ( 6 )]) plt.ylim([ 1e-5 , 100 ]) plt.yscale( 'log' ) elif dimensions == 1000 : plt.xlim([ 0.9 , 1000 ]) plt.ylim([ 1e-5 , 10e3 ]) plt.xscale( 'log' ) plt.yscale( 'log' ) plt.subplot( 1 , 3 , 2 ) for method in problem_setting_dict[dimensions][ 'method_names' ]: plt.plot(problem_setting_dict[dimensions][ 'non_zero_nums' ], [np.sum(np.abs(solution_dict[method][num]) > 1e-6 ) for num in problem_setting_dict[dimensions][ 'non_zero_nums' ]], 'x--' , label = method) plt.xlabel( '$x^*$の非ゼロ要素数' ) plt.ylabel( '出力された解の非ゼロ要素数' ) if dimensions == 100 : plt.xlim([ 0 , 100 ]) plt.xticks([ 20 * i for i in range ( 6 )]) plt.ylim([ 0 , 50 ]) plt.yticks([ 10 * i for i in range ( 6 )]) elif dimensions == 1000 : plt.xlim([ 0.9 , 1000 ]) plt.ylim([ 0.1 , 1000 ]) plt.xscale( 'log' ) plt.yscale( 'log' ) plt.subplot( 1 , 3 , 3 ) for method in problem_setting_dict[dimensions][ 'method_names' ]: plt.plot(problem_setting_dict[dimensions][ 'non_zero_nums' ], [np.linalg.norm( solution_dict[method][num] - dim_optimal_dict[num], ord = 2 ) for num in problem_setting_dict[dimensions][ 'non_zero_nums' ]], 'x--' , label = method) plt.xlabel( '$x^*$の非ゼロ要素数' ) plt.ylabel( '$\| x -x^* \|_2$' ) plt.legend(loc= 'center left' , bbox_to_anchor=( 1 , 0.5 )) if dimensions == 100 : plt.xlim([ 0 , 100 ]) plt.xticks([ 20 * i for i in range ( 6 )]) plt.yscale( 'log' ) plt.ylim([ 0.01 , 10 ]) elif dimensions == 1000 : plt.xlim([ 0.9 , 1000 ]) plt.ylim([ 1e-2 , 10 ]) plt.xscale( 'log' ) plt.yscale( 'log' ) plt.show() #################################################

(with MIT Professional Education , and Global Alumni) At Insight Edge, many of our team members are involved in "extra-curricular activities": building our skills outside of our day jobs, and bringing that experience back home to IE. In a previous Tech Blog post, I shared about my experience working in collaboration with NASA and Google Cloud, as part of the "Frontier Development Lab" program (see A Data Scientist’s “Sabbatical”: Skill-building through external scientific collaboration ) Other members of IE supervise grad-student research projects, lecture at universities, or even tutor high-school students. Even of those jobs are not connected to IE projects directly, we believe our members benefit from gaining wide experience explaining technology and methods to folks outside of the Sumitomo Corp. network. Learning to teach effectively has a very healthy impact on our ability to engage with stakeholders, and explain the trade-offs of different DX implementations to professionals in SC and our many operating companies. Since September 2023, I have been acting as a "Learning Facilitator" for MIT Professional Education's " Applied Generative AI for Digital Transformation " online program: a kind of continuing education course, helping industry professionals from magazine writers to pharmaceutical executives update their skills and curiosity regarding Generative AI for Digital Transformation", which gives a mixed bag of GenAI nuts and bolts and best pracitces, as well as overall frameworks for thinking through larger business trends GenAI tools may bring about. As a Learning Facilitator, I host "Office Hours" with groups of 30-60 participants, taking their Q&A, and helping them digest all the different topics the course brings up. While its the faculty who give the lectures, its my role to go deeper and adapt to each participant's individual learning needs: via office hours, Q&A, written assignments feedback, and any other SOS or sanity check request. I've really loved this role as it meshes very well with what I often have to do at Insight Edge / Sumitomo Corp.: help our organizations many professionals resolve misconceptions surrounding advanced technology. Help them explore the complex trade-offs, and navigate the common pitfalls of new algorithm R&D and commercial implementation. "Can I use ChatGPT for the homework?" While this might seem a bit trivial, it comes up immediately with every cohort, and usually leads to some profound discussion! Naturally with a course about LLMs, students will be very eager to use them; or even guess that they are expected to use LLMs to generate their work. The trap that many fall into is copy-pasting the assignment instructions verbatim into ChatGPT, and then submitting verbatim response as their own work. Since these are working professionals rather than university students, my major concern is that folks are not then obtaining any added value from the tool: neither learning anything from it nor improving the quality of the result. This can have diasatrous consequences if scaled to their actual professional workloads, e.g. workplace memos, reports, or even consumer facing documents can end up reading extremely generically, and risk resembling content generated by competitors, etc. As a single user, many folks will find the output to look very good. But if we sample the output among many similar and generic prompts, the results tend to be very homogeneous. The general feedback I give folks here, is really quite similar to what many proactive university instructors are recommending: use LLM tools in a way that allows you to focus your effort on what you do best. Instead of having them write for you, use them to help you get started, to give structure, or to understand what a generic output would look like, so that you can avoid it. You can ask a chatbot for a list of common pros-cons on an issue, then go through that list one by one and respond with your own takes: sort of a way of coaching yourself or "gameifying" your task. After that, you don't even need to keep the text generated by the LLM. Sort of like temporary scaffolding. For more on the balance between empowering oneself and others with LLMs vs the potential risks of outsourcing thought or creativity to them, I've gathered a handful of papers I usually point students to: Impact of artificial intelligence on human loss in decision making, laziness and safety in education AI Art and its Impact on Artists "How could I be prompting this more effectively?" One of the most common questions folks ask is how to write effective prompts. Actually, that's not true: its actually one of the most chronically unasekd questions. Many students will cling to the most basic, minimal, or copy-pasted prompts --- because they work. Or at least, they appear to work well enough on the surface. And for folks whose primary motivation in using LLMs is simply to save time, they're typically so very impressed with the speed that the LLM will produce a pretty-looking e-mail that they won't look to improve. Thus I focus a lot on, not answering this question necessarily, but in getting students in the habit of asking themselves this question whenever they use an LLM --- especially when they are in a hurry, because that's where poor quality output tends to be overlooked. To help folks get in that habit, I make some very minimal suggestions for them to always use: Never use generic prompts: In other words, verbatim prompts copied from a prompt ``cheat sheet'', or any other widely-available source: while the overall structure of a prompt can be re-used -- and probably should be, so that you can experiment systematically --, copying a prompt exactly runs the risk that the response itself will be generic (and likely to resemble the work of others!) Structure the prompt with keys and values: While it may feel the most natural to prompt an LLM in conversational language, you might obtain better control over the result if you apply some more machine-like formatting. For example, when prompting for writing samples, you could choose a set of 3 keys, "task: , voice: , vocabulary level: ***" Remember that LLMs are trained not only on prose or conversational language, but also on a wide variety of data formats and programming languages. You can thus use some programming-like syntax in your request to try and remove some ambiguity. For students who code, I usually point them to JSON or YAML syntax. You can use such formats as templates for structuring a prompt, whether or not your request has anything to do with programming. For students who are less familiar with data and code, I usually just provide an example of key-values (typically ends up looking YAML-like), but tell them to keep it simple, and experiment. When in doubt, its always better to have clear structure to the prompt: that way you can easily revisit and tweak different parts of it, to hone in on the results you want. How can I use JSON to prompt more complex stories and tasks? Folks interested in prompting using JSON or other structured formats might have a look at the following Reddit thread: JSON as prompts : r/ChatGPT The thinking is that this makes the key context components more recognizable to the LLMs trained features, and takes some ambiguity out of the outputs. You could also try something simple to start with, maybe a quick JSON of 10 or so parameters for a software suite outline. Start the prompt off with something like “What follows is a JSON with parameters defining a desired brainstorming request. Please generate a response based on the parameters in the JSON”, then paste the JSON, and see what you can come up with. Based on that experience, you could also look into more systematic prompt-structuring tools like LangChain. How to Use LangChain, a Framework for Structured Responses from ChatGPT | by Prabhavith Reddy | Medium # Does RAG cure hallucinations? No! RAG is a great tool, but it's not a "set and forget" barrier against hallucinations or falsehoods. A lot of students are introduced to the idea of "Retrieval Augmented Generation" during this course or others, and are very excited about it. RAG is a very powerful technique for getting an LLM to stay relatively constrained to a particular set of documents. However it's not a subsitute for quality control. LLMs can still produce hallucinations even when connected to a RAG system. This is because the LLM model itself at the core of whatever such app you develop is not changed at all by the RAG system. Rather, its being carefully fed context in the form of chunks of your chosen "corpus", or document collection (Tom Yeh's "AI by Hand" seris contains a great guide for beginner's on how RAG works ) has produced a fantastic set of beginner's guides for AI topics. Have a look at These context clues then go into the LLM along with your prompt, strongly biasing the response towards that context. The LLM weights themselves are not changed, and we can still see false or misleading information appear in the output. RAG-enabled LLM apps are still going to be much more constrained to your task than a vanilla LLM implementation! So don't let this answer scare you. Just remember that whatever support system you use to filter, constrain, loop, or otherwise augment an LLM based system, you still have to be very careful to monitor the system for problematic outputs. For more on RAG and hallucinations, I typically point folks to references such as the following: [2311.04235] Can LLMs Follow Simple Rules? As for quality control approaches LLM-based apps and systems, Weight&Biases has put out several helpful resources: How to Evaluate, Compare, and Optimize LLM Systems Evaluating Large Language Models (LLMs) with Eleuther AI I find that students also benefit from a sense of caution about an LLMs adherence to "rules" we give them in our prompts. While our requests may be formatted in absolute terms, "Never use this word" or "You must use this pattern in every paragraph", there is no guarantee that the response will adhere to such terms. Often the results can be satisfactory or even well-above expectations, but LLMs should not be confused with something like a command line where variables and functions can be strictly defined. This follwoing article gives an interesting deep-dive into the ability of LLMs to adhere to rules set out in the prompts we provide them: * Can LLMs Follow Simple Rules? How restrictive are the guard rails on some of these AIs? They can be at the same time overly restrictive but also failing to prevent harmful uses. As folks have pointed out more and more biases, likely coming from poor training data curation and testing, the developers have resorted to more quick-and-dirty means of avoiding embarrassing outputs, e.g. simply filtering: this is applied both on the prompt itself, and again once the output has been generated. We have yet to see any sophisticated “constructive” guardrails, i.e. those that help the user understand what kind of responses are problematic, how to double-check them, and how to maintain quality overall. More recent methods have tried to add to this a kind of "intermediate" filtering, wherein the actual internal layers of the LLM are sampled for problematic features. If detected, this triggers the overall app serving the LLM from producing any output, whether or not the output itself explicitly contains any of the blacklisted words. Related References: Building Guardrails for Large Language Models What's the state of High privacy LLM tools and implementations? This is still a major challenge with LLM applications: currently, the most powerful models are closed-source, and require one to send requests via an API or web-interface to the developer’s external service. LLMs themselves are not inherently insecure, in the sense that just running “inference” (i.e. running an input through a trained model) does not require any data to actually be saved by the model. Sort of like running current through your house’s wiring doesn’t change anything about the wiring itself. The trouble is about how the LLM service provider’s overall web-app, and servers handle your data. If you are using such provider’s tools to “fine-tune”, or create “agents”, “assistants”, etc., the situation is completely different. This is because to create such customised or fine-tuned models, your data is being used to train the model. To what extent your training data is extractable from the assistant is still an active area of research. We have seen instances of “jail-breaking” (engineering prompts in specific ways such to bypass safety filters, or extract snippets of the original training data) wherein security researchers are able to cause such agents to “leak” sensitive data. Note: this in principle could happen whether you fine-tune using a third-party platform or on your own. As for training a model securely, the idea of “Federated Learning” has come up now and then: basically using a network of training nodes to collaboratively train a model; the data itself however never leaves its respective node. Let me share also some resources on data privacy of LLMs, and also on using LLMs themselves to mask sensitive data. Finally, a tool I’ve discovered recently that can be used to generate synthetic data that mimics sensitive data examples. [2307.08925] Federated Large Language Model: A Position Paper [2310.10049] FATE-LLM: A Industrial Grade Federated Learning Framework for Large Language Models Running Large Language Models Privately - privateGPT and Beyond | Weaviate - Vector Database Can a Model Be Differentially Private and Fair? Ai4Privacy ** ai4privacy/pii-masking-200k · Datasets at Hugging Face [2402.13659] Privacy-Preserving Instructions for Aligning Large Language Models LLM AI Cybersecurity & Governance Checklist Private LLMs: Data Protection Potential and Limitations - Skyflow Ethics vs. benchmarks for performance: testing as tools evolve, etc. The ethical concerns surrounding GenAI make the questions of benchmarks all the more important! Bias, security, quality control in general are very difficult to systematically measure without good benchmarks. My personal take is a tad different from the Faculty: while I understand they have their own personal experiences with OpenAI/ChatGPT, I don’t think an individual’s personal experiences with one tool or another are enough to make organisation-level decisions. On the other hand I agree with them in that I don’t think a single “Leaderbord”-style general accuracy benchmark is sufficient for such decisions: does a marginal % difference in accuracy score really mean one model is better for your specific needs than another? I recommend looking at a suite of benchmarks designed around specific domain applications, and even considering developing your own internal benchmarks and red-teaming. Let me share some examples of community-developed metrics for various domains. For more, have a look at the “Metrics” section of HuggingFace.co. Most of these are rather rudimentary statistical measures, but if you will also note a good number that are for evaluating language models for various tasks from “text simplification” and “information retrieval” to performance on standardized tests, etc. Example references The Open Medical-LLM Leaderboard: Benchmarking Large Language Models in Healthcare A Comprehensive Medical Benchmark in Chinese (2023) Open Portuguese LLM Leaderboard - a Hugging Face Space by eduagarcia Code Eval - a Hugging Face Space by evaluate-metric Competition MATH - a Hugging Face Space by evaluate-metric MATH Benchmark (Math Word Problem Solving) | Papers With Code Paper page - Prometheus 2: An Open Source Language Model Specialized in Evaluating Other Language Models Overcoming Hallucinations with the Trustworthy Language Model How have GenAI tools have changed in the past 6 months? When I first LF’d for the course back in September 2023, I felt the community was somewhat dismissive of things like: Potential of smaller LLMs Self Finetuning In-house (e.g. open source) model implementations. These approaches have been gaining more momentum recently. A lot more research has appeared in this time showing applications where smaller models might excel (constrained use-cases). Novel “multi-agent” architectures have also gained popularity, i.e. using multiple LLMs to parse tasks. Need for security and transparency of training data has also become louder: thus quieting some of the folks advocating for ChatGPT/OpenAPI as a one-stop-shopping solution. Open-source models have also made great strides in this time, most notably Meta’s “LLama”. At the same time, tools and instructional resources allowing folks to do their own fine-tuning, etc. have also become more common. Example References Understanding the Impact of AI Generated Content on Social Media: The Pixiv Case Model Collapse Demystified: The Case of Regression do smaller models hallucinate more HuggingChat Breakthrough: Zero-Weight LLM for Accurate Predictions and High-Performance Clustering - Machine Learning Techniques What's one major and direct worry about the current course of LLM evolution/propagation? I think the flood of generated content onto the internet would be a key issue to think about here. Not just how its being generated but how it affects the average user's perception of digital content. This preprint dives into that issue as it affects visual art on platforms like “Pixiv”: Understanding the Impact of AI Generated Content on Social Media: The Pixiv Case Please also consider the perceived challenge that some researchers are putting forward, wherein models become harder to train because the fraction of easily-scraped, genuine human-created examples on the internet may decrease. (see “Model Collapse”: Model Collapse Demystified: The Case of Regression ) Related References Best Practices from Students on Using ChatGPT in High School | by Jaya Ramchandani | We Learn, We Grow | Medium Best Practices in Generative AI Educational Prompts: A ChatGPT and Microsoft Prompt Analysis 404 Media Distributed AI Research Institute Mystery AI Hype Theater 3000 | DAIR How about those small models? This How-To by Intel gives a decent, objective break-down of model performance (in terms of hallucination rate) by parameter size (do smaller models hallucinate more) You’ll find tons of other blog posts on the subject, but many don’t actually provide hard statistics and/or are likely just advocating for their own offerings. (Granted, Intel is not exactly a “neutral observer” !) For more objective comparisons, you might consider taking a dive into ArXiv – just keep in mind that many papers there have not necessarily been peer-reviewed yet. Still, it can be a great source for understanding the latest R&D trends. As mentioned in the Office Hours, HuggingChat is a great platform for quickly comparing response quality for models of different sizes (HuggingFace.co/chat) Aside from the debate of large vs. small, I’ve found this novel approach gaining attention: Breakthrough: Zero-Weight LLM for Accurate Predictions and High-Performance Clustering - Machine Learning Techniques (the “zero-weight” description may be a bit of a misnomer) Which use-cases do we see most in organisations? Chat bots are the most visible ones! These can be consumer-facing, or for internal applications: e.g. HR policy search-bots, Data interaction. Also have a look at Sentiment Analysis. The biggest potential I’ve personally noted is however in the way individual contributors empower their workflows with GenAI tools via on-the-job learning and skills refining. FYI I found the following interview with the founder of “Writer” to be quite interesting: Leveraging Hugging Face for complex generative AI use cases. How is building GenAI applications/ products different from other SW applications/ products? I would say the biggest difference is in the quality control steps, lack of determinism in the outputs: it’s tricky to get LLMs to provide consistent QoS, and to have them adhere to strict rules -> rigorous testing becomes more of a “fuzzy” process. Otherwise the experimental nature of LLMs in their current state needs to be taken seriously. Developers are good at making these systems appear polished and professional, but we are only just beginning to map out the pitfalls of LLM-tech-at-scale. New model versions are being released much faster than the R&D community is able to assess and stably-integrate them, let alone for enterprses to fully comprehend how their customers will be impacted. This is not to scare folks away! Rather, just to remind us all not to confuse cutting-edge with well-vetted. Which roles and capabilities are needed in an LLM team? Of course new skills like “Prompt Engineering” are critical; not necessarily in the sense that you need to hire a “veteran”, but that your team needs to be accumulating knowledge and experiment results on the best ways to write prompts. But more than that I suppose not overlooking the traditionally required skills is critical! E.g. folks skilled in: Software testing, Scaleable cloud architectures, and system redundancy engineering (i.e. being able to swap in alternate models and providers in the case a major product (API) becomes unavailable – especially true for GenAI as the field is so fastly evolving!! And we are still very much in the “hype bubble”) I highly recommend following Eduardo Ordax (GenAI lead at AWS), and his thoughts on MLOps: basically, the hype of GenAI has distracted folks from MLOps and DevOps, but scaling GenAI is going to require us to get back to those.

はじめに Insight Edgeの社内部活 ボドゲ部創設者：JIMENEZさん 活動の様子 終わりに はじめに こんにちは！Insight Edgeの人事担当・合田です。 今回は当社メンバーが運営している社内部活についてご紹介します！ Insight Edgeの社内部活 Insight Edgeでは、Slackチャンネルで各メンバーが自主的に部活を作成し、 チャンネル内では関心のあるトピックについての情報共有や、部活内容によってはイベントの実施なども行っています。 2024年5月時点でどんな部活があるか列記してみましたが、この一覧を見るだけでInsight Edgeメンバーの趣味趣向が見えてきますね・・・！ 【代表的な部活】 eikaiwa（英会話） meal（レストラン情報） bodoge（ボドゲ） kosodate（子育て）※男女問わず、子育て中のメンバーが多い！ movie（映画） karaoke（カラオケ） baceball（野球） manga（漫画） golf（ゴルフ） competitions（ゲーム大会） mahjong（麻雀） sauna_37（サウナ） hokkaido（北海道） ※Insight Edgeは北海道出身者が多い！ tennis（テニス） cafe（コーヒー、カフェ情報） 本日はこの中から"ボドゲ部”の紹介をしたいと思います！ ボドゲ部創設者：JIMENEZさん ボドゲ部の発起人は、当社のLead Data ScientistのJIMENEZ（ヒメネス）さん！ 公式サイトのプロフィールに記載している通り、これまでに２つのボードゲームの出版実績のあるスペイン出身のメンバーです。 折角なので、JIMENEZさんとボードゲームのエピソードも少しご紹介。 高校時代に初めて日本に遊びに来た際、見た目の美しさに優れた”知恵の輪”と出会って衝撃を受け、そこからパズルのみならず、ボードゲームの面白さに徐々にハマっていったそうです（デザイン性へのこだわりは、後ほどご紹介するJIMENEZさんが作ったボードゲームにも引き継がれます）。 大学院のために来日し、修士課程の時代に、後に出版することになるボードゲームの初期版を作成し、友人と対戦しながら改善を重ねたエピソードもお伺いしました。 「いかに人に楽しんでもらえるか」を探究して、ボードゲームにさほど興味のない人の意見こそ積極的に取り入れているんだそうです。 「これはゲームにならないか？」と着想を得たら、100円ショップで材料を揃えてプロトタイプを作りアイデアを自分で形にしていくこともあるそうで、時期によっては週末のほとんどをボードゲーム作りや構想を練るのに使うこともあるんだとか！ 日本の過ごしやすさ（安全面、人との距離感）を気に入って、大学の博士課程を修了した後も日本に残って就職。 過去に働いた企業でランチタイムに人を集めてボードゲームをして盛り上がったこと、 それから「一緒に働く同僚のことをよく知っていた方が、仕事がうまく進むことがある」という社会人としての経験則から、 Insight Edgeに参画した際、「折角ハイブリッドの就業環境なら、みんなでボードゲームをする時間を作りたい」と思って部活を発足させたそうです。 Insight Edgeのデータサイエンティストとしての顔と、ボードゲームクリエイターの顔と、マルチに活躍するメンバーです！ 活動の様子 某日、就業終了後に希望者がそれぞれボードゲームを持ち寄ります。 最初に遊ぶのはJIMENEZさんが制作したボードゲームの１つ"Squadro（スクアドロ）”。 ルール説明をするJIMENEZさんと、対決するKoyanagiさん、Sugaさん。 ５つの自分のコマを進め、Uターンさせて先に４つのコマをスタート地点に戻した方が勝ち、という２人用のゲームです！ それだけ聞くと簡単ですが、 １度に進めるコマの移動数が往路と復路で変わる 相手のコマが自分のコマを飛び越えると自分のコマはスタート地点に戻らなくてはならない などなどルールが細かく決まっています。 「作った本人はやはり強いのか？」を確かめるためにJIMENEZさんと対決したのはKoyanagiさん。 先ほどまで和かに談話していたのに、一気に真剣な眼差しになります。 ２人の対決を隣で見ていて、序盤と終盤で全く戦況が変わるのがこのゲームの面白い所だと感じました。（ちなみに勝者は作ったご本人！） 対決後、JIMENEZさん直々に勝つための考え方や、勝率の高い攻め方、制作秘話（デザインにとてもこだわったらしく、インテリアとしても使えそうな素敵なボードゲームです！）などを教えてくださいました。 もう１つJIMENEZさんが作ったボードゲームを紹介。 こちらは”マルコポーロの地図”。 対象年齢は６歳からで、プログラミング的思考力やひらめき力が身につくとか！ 子供向けのゲームシリーズと言うことで、冒険家マルコポーロが旅した世界地図のような可愛いデザインにワクワクします。 このゲームは地図上のスタート地点からゴール地点まで、コンパスを模したピースを正しく配置する１人用のゲームです。 ピースによって進める数が違うので、方向と数に気をつけながら配置します。 私が挑戦しましたが、全４０問のうち難易度の問題の低い方の問題にもそれなりに時間がかかってしまいました。 「うーん・・・」と悩んでいると、JIMENEZさんから「考え方を変えてみたらどうでしょう？こういうこともできますよ！」とヒントがもらえます。 ご本人からレクチャーを受けながらゲームに取り組めると言う贅沢な時間でした。 他のメンバーがそれぞれ遊んでいる間もコツコツと知恵の輪を解くSugaさん。 こうして日々、業務時間中の圧倒的な集中力を鍛えているに違いない。 そして最後はせっかくなのでみんなで遊べるものを、とKoyanagiさんが持参したボードゲーム”コヨーテ”で遊ぶことに。 数字やとある条件が書かれたカードを自分のおでこの前に掲げ、自分のカードだけが見えない状況で、その場の全員のカードの合計数を予測するゲームです。 とある条件と言うのが曲者で、合計数を２倍にするものや様々な効力のあるカードが混ざっています。推理力、人の表情を読み取る洞察力、そしてどんな時でも堂々と強気で振る舞う仕草など、あらゆる要素が必要な心理戦となります。 私もゲームに混ぜてもらいましたが、予測分析が得意なデータサイエンティストに囲まれ、惨敗でした（単純に暗算が苦手という説も）。次回は心理戦で勝てるようにトレーニングを重ねたいと思います。 一通りのゲームで遊んだ所でお開きとなりました。 普段一緒に仕事をしているメンバーと、いつもとは違う形で頭を使う時間はとても楽しかったですし、何よりボードゲームクリエイター直々にいろいろ話を聞く事が出来るという、社内部活の域を超えた贅沢な時間でした（Insight Edgeに入社するとこんな特典もありますよ！） そして冒頭でも触れた通り、Insight Edgeにはこれ以外にも沢山の部活があります。 おすすめの映画やレストラン、カフェ情報を交換するような部活チャンネルもあり、メンバー同士の大切なコミュニケーションの場となっています。 終わりに 総合商社ビジネスのDX推進をするInsight Edgeでは、その豊富な産業ドメインに対応するために専門性やバックグラウンドの異なるメンバーが集まっています。 多彩なメンバー同士で交流できる環境はとても恵まれていると改めて感じました。 Insight Edgeでは一緒に働くメンバーも積極募集中です！ ご興味があればぜひ採用サイトにもお越しください。 recruit.insightedge.jp

こんにちは！Insight Edge で Developer をしている Kobori です。 本記事では、Liferay を使用したアプリ開発で得た知見について、使い方とノウハウを交えてを紹介します！ 関連記事が少なかったのも苦労した点の一つでもあるので、本記事が開発の助けになれば思いを込めて書きました。 ぜひ、最後までご覧いただけたらと思います。 この記事でわかること Liferay の概要 Liferay での実装方法 Liferay とは？ 社内ポータル等の Web システム構築を比較的短期間でできる統合 Web ポータルプラットフォームです。 ユーザーが必要とする機能部品の多くが用意されており、足りない部品や独自のセクションも自作することができます。 Liferay 公式サイト Liferay で開発することになった背景 今回使用することになった背景としては、元々存在するサイトをリプレイスすることになり、ポータル内の検索向上や更新作業の負担軽減を目的に、別途知見のあった Liferay で開発することにしました。 Liferay での開発方法 実際の開発の中で使用した機能の使い方や特徴を紹介していきたいと思います。 今回は、下記の機能を使用してサイトの構築を行いました。 Liferay の使用した機能 サイトページ ナビゲーション ドキュメントとメディア タグ ページフラグメント ウィジェットテンプレート サイトページの基本操作 基本的には、サイトの作成、ページの作成を行い、ドラッグ&ドロップ操作による要素の追加によって画面を作成していきます。 標準レイアウトも用意されているため、標準レイアウトに沿って作ると短時間でサイトの構築ができます。 サイト構築前のポイント 事前に標準レイアウトの使い方を知っておくことで、標準レイアウトを使用するのか？独自レイアウトを使用するのか？といった、初手での UI 設計と実現性の判断に役立ちます。 Liferay ナビゲーション 遷移先とページを紐づける役割を持ち、その設定を使ってメニューを構成できます。 設定方法は、下記のようになります。 また、サブメニューの配下にページを配置するとメニューの中に遷移先のリンクを用意できます。 Liferay ドキュメントとメディア 画面に表示したい画像ファイル等を格納する場所です。 用途ごとにフォルダ分けすることをおすすめします。 ドキュメントとメディアでの工夫点 タグを設定することで一覧表示のルール（表示条件）に使用することができるようになります。 アップロード時の一括設定でタグを設定するのがおすすめです。 Liferay ページフラグメント 基本コンポーネントで表現しきれない部分は、下記のように HTML,CSS,JS を用いてページフラグメントを実装します。 ページフラグメントでのつまずき Liferay で持つ情報（ドキュメントに格納したファイル等）を動的に表示できるようにする \<lfr-widget-asset-list\> 　等のタグの使い方を把握するのに苦労しました。 このタグを配置してページの編集画面にて表示される歯車アイコンを押下するとアセットパブリッシャー設定が行えるようになります。 アセットパブリッシャー設定画面 アセットパブリッシャー設定画面では、動的な情報のルール（表示条件）設定と表示形式の設定が行えます。 ルールは、カテゴリ/タグ/キーワードで絞ることができますが、キーワード検索でフォルダを指定すると余計なファイルも抽出されます。確実に抽出するには、付与したタグで絞ると良いと思います。 Liferay ウィジェットテンプレート 今回のアセットパブリッシャーのテンプレート実装では、FreeMarker 言語を選択して実装しました。 PHP のように<>で囲った部分に実装していきます。 if 文や list に entries を指定することでルールに基づいた情報を用いて、表示形式の設定ができます。 ウィジェットテンプレートでのつまずき ユーザーアイコンを取得する API の呼び出しが必要となったのですが、仕様がなかなか難しく把握するのに苦労しました。 今回の実装では、 serviceLocator.findService("com.liferay.portal.kernel.service.UserService") にて userService を取得し、getUserById で entry オブジェクトに持つ UserId を設定して user 情報を取得後、その user 情報の portraitURL を取得することでユーザーアイコンの URL を取得しました。 ユーザーアイコンの URL を img タグで使用することで画面上の任意の場所でアイコンが表示できます。 <#assign userService = serviceLocator.findService("com.liferay.portal.kernel.service.UserService")> <#assign user = userService.getUserById(curEntry.userId)> <#assign userPortraitURL = user.getPortraitURL(themeDisplay)> <img src="${userPortraitURL}" alt="UserIcon" /> Liferay を使ってみた感想 UI パーツが豊富にあるので縦横の標準セクションや部品を使うことで短時間でサイトの構築ができると感じました。 また、フッターなどの共通セクションを自作し利用するのは、とても有効であると感じました。 一方で 自作セクションを作成するには HTML, CSS, JS 等を用いた実装が必要なため、標準セクションと自作セクションの選択によって作成時間が大きく変わります。そのため、UI を考える際には、標準セクションでどこまで実現できるか意識すると良いと思います。

はじめまして！Insight Edge デザイナーの水上（ミズカミ）です。 2023年5月にジョインさせていただき、Insight Edgeが発信する様々なデザインを担当しております。 だんだん暖かくなってきて外を歩きたくなってしまい、どんどんテックブログ執筆が進まなくなってしまっています。（今日はちょっと我慢してPCに向き合っております😇） 今回は、昨年度からInsight Edgeとしての情報発信に力を入れている背景や、私がどんなアプローチでデザインを行なってきたかをご紹介いたします。 1.グループ内マーケティングの意義 2.実際に取り組んだこと ホワイトペーパー メールマガジン リアルイベント おまけ:採用サイト 3.半年(と少し)を振り返って 4.課題とチームの出会いをデザインする 5.これからはお店づくり 1.グループ内マーケティングの意義 住友商事にはグループ内だけでも約900社の企業を抱え、業界・事業フェーズも多岐にわたっていることもあり、Insight Edgeはこれまで多様なニーズに対応する技術専門集団としてプロジェクトに携わってきました。 また、住友商事のデジタル戦略推進部（DXセンター）やグループ会社の中でも圧倒的な社会的認知のあるシステム開発からあらゆるデジタル関連のサービスを提供している「SCSK」という強い協業パートナーの存在もあります。 まだまだポテンシャルのある案件が生まれる可能性と、”ChatGPT”という数多くの人々のワークスタイルに変化を与えるようなトレンドが来たことが、大きな機会を与えてくれました。 今までデータサイエンティストの分析やデジタル化による省力化・高度化がどんな影響を与えてくれるのか曖昧だった人たちにも、Insight Edgeが提供する価値への期待と組織の持つ知見を必要とする人達から多くの反応がありました。 Insight Edgeの行動指針である「みんなでやる」をもっと拡大解釈して「（住友商事）みんなでやる」の意気込みで、テクノロジーの専門集団として情報発信とコミュニケーションを図り、認知拡大、興味・関心のベクトルをInsight Edgeという組織に集める施策を仕掛けていきました。 2.実際に取り組んだこと まず取り組んだのは、マーケティング施策でのデザイン制作に向けたトンマナのチューニングです。 これまで、住友商事のグループ会社といえど、「Insight Edge」というエッジの立った個性を発揮しており、ブランドカラーは黒と白のみを使用していました。 ただ、マーケティングではある程度「注目を集める」ことや「親和性を感じる」ことも重要と考えたため、今まで使用してきたブランドカラーに住友商事の「浅葱色」を意識しながらデジタルのデバイスで鮮明に見えるようにチューニングしたグリーンをプライマリーカラーに追加しました。 また、Insight Edgeが向き合う部門数(2023年6月時点)に合わせたアクセントとして活用できるカラーパレットを揃えて、扱えるデザインの幅を広げていき、制作をスムーズに複数人で進められる準備を整えました。 ホワイトペーパー 過去経験してきたテクノロジー活用のケーススタディと技術者の目線でより活用の機会が広がるようなヒントをご紹介するお役立ち資料を制作しています。 Insight Edgeが取り扱う専門分野の知見をご紹介することで、現状のビジネスをよりテクノロジーの力で改善したいと思う方々とつながることができました。 ダウンロードは こちら 今年もこの活動を続けていく予定ですので、ぜひ次編もお楽しみにお待ちください🙏 メールマガジン 住友商事グループの方々に向けた社内で進行しているプロジェクトや、エンジニア・データサイエンティストがキャッチしているナレッジのご紹介をしています。 また、弊社の研修制度で国内外のイベントに参加したメンバーによるレポーティングも行っています。 バックナンバーをいくつかご紹介します。 リアルイベント 住友商事グループが活用できるコワーキングスペースを貸し切りリアルイベントを2023年2月下旬に開催しました。過去事例のモックアップを実際に触っていただいたり、弊社主要メンバーのトークセッションも催し、多種多様な事業と向き合われている方々にInsight Edgeの技術者が直接お話させていただくことで、一歩踏み込んだ技術活用の可能性を感じていただきました。 今までホワイトペーパーやメルマガを通して一方的な関係性の方々ともリアルイベントを通して直接コミュニケーションを取ることができました。 社内向けイベントということでイベント内での制作物や様子はなかなか見せられないのですが、約200名の方々にご参加いただきました。 足を運んでいただいた皆様、本当にありがとうございました。 おまけ:採用サイト マーケティグとは別軸にはなりますが、Insight Edgeの 採用サイト もリニューアルを行いデザインを刷新しています。社名に違わぬエッジのたった異能が集まる組織かつ、ブログや勉強会も通して学び合い共有し合うミクスチャー文化、組織が一枚岩となっているような様を表現できるようにモチーフやビジュアルを作成しデザインしました。 3.半年(と少し)を振り返って まだ1年経っていませんが、住友商事グループ内の方々にInsight Edgeのことを認知していただくきっかけとなるデザインを首尾一貫で見させていただけるのはなかなか自分にとってもない経験でした。 特にEdgeのたった専門家たちのこれまでの活躍を、イベント等を通してより多くの方々に知っていただける機会を広げられたのも達成感がありました。 4.課題とチームの出会いをデザインする 今までのプロジェクトをまとめながらデザインで落とし込む過程で、難しいと感じたのはシステムやサービス開発は世に出しても無形の資産であるということです。商品の物的な価値が明確でない分、それを受け取り、価値を感じるかどうかはお客様次第になることの方が多いです。 私たちのこれまで開発してきたソリューションやシステムに価値を感じていただける課題を持つ人々にお届けできるようにこれからも試行錯誤しないといけないと感じています。 また、市場的にも日進月歩新しい技術が生まれている分野でもあるとともに、チームのサイズも大きくなっているため、今ならまた違ったアプローチで解決できる課題も多くなっているかもしれません。 まずは、課題とチームのマッチングを生み出すために、これからもマーケティング活動は続けていきたいと考えています。 5.これからはお店づくり マーケティングを進める中で、今までのInsight Edgeの住友商事内の技術専門家集団という肩書きは総花的で、受け取り手にどんな存在なのか言語化するのを委ねるようなブランドになっているような気がしております。 主力となる商品やサービスの形が無くても、「うちにはこんな売り物がありまして…」「お客様にはこちらのソリューションがピッタリですね！」と言えるような、価値の定義が明確でぶれないモノも陳列し、お客様を迎えられるような存在を目指していきたいと考えている今日この頃です。 また今年度もイベントの出展やホワイトペーパーの更新も予定しているので、もし興味がある情報がありましたら、いつでもお問い合わせ下さい。 これからも社内外含めてブランドの発信に力を入れていきたいと思っています。

はじめに ししとうLTとは？ アウトプットと採用と育成 Insight Edge 猪子 (@iN0Ti) チームが進化し続けるための改善プロセス アスエネ 石坂 (@ishisak) クライアントワークのエンジニアリング 　フラー 韮澤 (@nirazo) 強みを伸ばすキャリアデザイン HRBrain 山口 (@yug1224) 雑談のすすめ IVRy 近藤 (@K0703K) 懇談会 最後に はじめに こんにちは！Insight Edgeの人事担当、合田です。 4/9(火)の夜に第１回「ししとうLT会」をオフラインで開催したので、今回はそのイベントレポートを書かせていただきます。 ししとうLTとは？ 「ししとう」は見た目とは裏腹に、一口食べると意外な辛さがあることがあります。 ししとうのような「意外性や挑戦」をテーマに、新しい発見や刺激を提供できるコミュニティになればと思い、この名前をつけました。 IVRy、アスエネ、Insight Edge、HRBrain、フラーの5社に所属するエンジニアたちが、それぞれの得意分野や興味のあるテーマについて発表する場で、主催企業（会場運営）を輪番で担当することに決まったのが2023年12月。平素業務の合間を縫いながら、少しずつ準備を進めてきました！ 記念すべき第一回の主催企業は当社Insight Edge！ということで早速レポートに入ります。 当日の全体司会はIVRyの堀田( @yuri_ivry )さん！（ありがとうございました） 当日のタイムテーブルはこの通り アウトプットと採用と育成 Insight Edge 猪子 ( @iN0Ti ) １人目の登壇者は当社CTO猪子さん。 “忙しい時ほどアウトプットを大事に！”というテーマでした。 転職潜在層へのアプローチ、選考中の候補者へのアトラクトに加え、在籍エンジニアの育成観点でのアウトプットの場として立ち上げたテックブログの運用が1年半を超え、今まで投稿した記事数は延べ70本にも！ 「継続的な投稿すごい！どうやって運用したんですか？」と来場者からの質問もいただきました。 Insight Edgeのテックブログの運用は、編集チームを立ち上げて、輪番制で指定している寄稿者に業務負荷がかかりすぎないよう、テーマ出しや校正のアドバイス、スケジュールリマインドなどを編集チームがしっかりサポートしています。 また選考面接官を務める猪子さん自身、採用候補者のテックブログに対する関心の高さを肌で感じているとのことでした。 ※ちなみにこのししとうLTも、「エンジニア達のアウトプットの場を作りたい」という気持ちで立ち上げたとの想いを語っていただきました。 チームが進化し続けるための改善プロセス アスエネ 石坂 ( @ishisak ) ２人目の登壇者は次世代サステナブル経営支援で５期目を迎えるアスエネのVPoE石坂さん！　 最近ではシンガポールやアメリカにも進出されているアスエネの”組織進化に向けたプロセス“についての発表です。 石坂さんが考える「強いチームに必要なこと＝強い文化」、という定義から始まり、「強い文化が暗黙的に浸透している状態」を実現するために行った施策を教えていただきました。 まずは週次ふりかえりをKPTで実践、ふりかえりで解決しきれない課題に関しては、ワーキンググループを立ち上げ、有志で集まったメンバーが解決まで推進してくれるそうです。 課題解決のために試した施策をまた振り返り、失敗だったなと感じればロールバックして前のバージョンに戻す。 つまり、効果的な改善フローはGitHub Flowに帰着する！という結論には会場内のエンジニア達も「ふむふむ」と聞き入っていました。 「物事を決める時に強いリーダーは必要？」という会場内からの質問に対しては「ルールを決めるための強いリーダーは不要で、ルールを決めた後に物事が浸透するまで言い続ける、体現し続けるリーダーは必要だと思う」との回答。 クライアントワークのエンジニアリング 　フラー 韮澤 ( @nirazo ) ３人目の登壇者は、「全ての企業のデジタルパートナー」を目指すフラーの統括マネージャーの韮澤さん。 多岐にわたる事業領域の会社へのデジタル支援を行う上で大事にしている２つのことを発表していただきました。 １つは“開発しているプロダクトを自分ごと化”すること。実際にプロダクトを体験する、その体験をプロダクトに落とし込み、実際にその機能の有用性を確認する・・・徹底してパートナー企業に伴走する姿勢が素晴らしいです。 もう１つは攻守のバランスをとること。 様々な事業会社の支援を行うため、扱う事業領域が多岐に渡る。必然的にドメイン知識の理解や技術調査に多くの時間を使うことが多くなってしまうそう。 そんな中で、技術面のスイッチングコストはなるべく下げ（守）、SwiftUIなどメリットの大きい技術を見定めて導入するコストは掛ける（攻）、とのこと。 新潟県出身の韮澤さん。新潟に本社を構えるフラーが開発を行った長岡花火公式アプリを、実際に花火大会会場でユーザーが使っている様子を見たときは心から感動したというエピソードが印象的でした。 強みを伸ばすキャリアデザイン HRBrain 山口 ( @yug1224 ) ４人目の登壇者は、「人と企業の持続的成長を支える」、を企業理念として８つのプロダクトを開発しているHRBrainのエンジニアリングマネージャー山口さん。 フロントエンドエンジニアからスタートした山口さん、様々なチーム規模や組織で開発を行う中で、節目節目でクリフトンストレングス（旧：ストレングス・ファインダー）を活用してご自身の動き方を考えていたそうです。 ストレングスファインダーの結果は、時が経つと若干変わってくる所もありつつ、山口さんがずっと変わらなかった要素は「最上思考、戦略性」だったそうです。 「振り返ってみて、フロントエンド×マネジメントという希少性の高いキャリアを築くことができたことを自負している」と語る姿、流石“戦略家”！　 最近はピープルマネジメントにもストレングスファインダーを活用し、部下に対して納得感のあるフィードバックや評価を落とせるようにしているとのことでした！ 山口さんのLTを聞いて、 クリフトンストレングス（旧：ストレングス・ファインダー）の書籍購入のリクエストが早速Insight Edge内で上がっていました！ 雑談のすすめ IVRy 近藤 ( @K0703K ) 最後は、あらゆる電話業務の自動化、効率化で多くの導入実績のあるIVRyのVPoE近藤さん。 忙しい日々を送る中で、どうしても生産性やスピード重視になってしまう中、IVRyが積極的に取り入れている雑談の効果についての発表でした。 IVRyではスケジュールに強制的に雑談の時間を設定してしまったり、オフィスに導入したコーヒーマシーンで豆を挽く音が聞こえたら雑談タイム、というルールを作ったり、思いついた時にキャッチボールが出来るようにと、メンバーの方がグローブとボールをオフィスに持ち込まれたそうです。 オフィスに行かなくとも働けるからこそ、自主的にオフィスに行きたくなる仕掛けは見習いたいもの。 ちなみに、直近では何かあった時に叩く用でドラを導入したとのこと（笑）。 雑談関連で盛り上がったという近藤さんの話すエピソードの数々こそ、IVRyの掲げる We make “Work is Fun”from nowを体現しているようなLTでした。 懇談会 各社のLTが終わったら、最後は飲食を交えながらの懇親会です。 今回のLTは、参加企業5社以外の方でも自由にご参加いただけるようにしました。 実際に外部から参加した方に、なぜ参加しようと思ったのか聞いてみたところ「フリーランスエンジニアで、本当は人と話すのが好きだけれど、中々そういう場がないので参加しました」という声や 「最近昇格して部下を持つようになったばかり。今回のLT登壇者はマネジメント経験者が多かったので、先輩として色々聞いてみたかった」との声を聞きました！ 最後に ししとうLTは今後も継続的に開催する予定で、次回以降は登壇者も一般公募します。 アウトプットの場として活用してみたい、というエンジニアの方、ぜひご応募ください！ （#2のLT枠は既に埋まってしまいましたが、ぜひ#3以降のご応募お待ちしています！） 4410.connpass.com ご登壇いただいた方のご厚意で、資料共有をいただいております。振り返り等にご活用ください！ ▼connpass資料共有スペース 4410.connpass.com ※共有いただいた皆様ありがとうございます！ レポートは以上です。 （おまけ）Insight Edgeでは一緒に働くエンジニアも積極募集中です！ 少しでもご興味をお持ちいただけましたら、ぜひご連絡ください。 recruit.insightedge.jp

こんにちは！Lead Engineerの筒井です。 このテックブログでも何度かテーマに上がっていますが、住友商事グループでは生成AI活用の取り組みが進んでおり、Insight Edgeもその推進を技術面から強く支援しています。 様々な取り組みがありますが、LLMの使われ方として基本的にはRAGを用いて回答を行うような、単発の特定タスクを解くというものが多いです。 今後はLLMに様々なツールを与えておき、より多様なタスクを状況に応じて自律的にこなしてもらうような、エージェント的な利用も模索していきたいと考えています。 そこで、今回は簡単な自律型のエージェントを、Prompt flowとFunction callingを用いて作成してみました。 もくじ Prompt flowについて 自律型エージェントの概要 Prompt flowによる自律型エージェントの作成 format_inputノードの処理 agentノードの処理 functionノードの処理 作成したフローの実行 まとめ Prompt flowについて Prompt flowは、Microsoftによりメンテナンスされている、LLMアプリケーション開発のためのOSSです。 詳細は割愛しますが、特にAzure AI Studioとの統合により、LLMアプリケーションのライフサイクルにおける開発の効率化や、評価・改善を継続的に行うための基盤として利用ができるというところに強みを持っています。LLMアプリケーションの評価については、最終の出力のみでなく、例えばRAGであればユーザー入力から生成した検索フレーズ、検索結果から得られた参照ドキュメントなど、中間出力についても精度を検証していくことが重要となります。Prompt flowでは各処理をノードとして扱い、各ノードの出力を評価対象とすることができるため、処理ごとの評価・改善を効率的に実施することができます。 自律型エージェントの概要 今回作成する自律型エージェントには、以下のようなタスクを行わせたいと思います。 すでに用意されたFAQから答えられるものはそのFAQをベースに回答を返し、それ以外の質問についてはドキュメントから回答に合う部分を探して回答を返す、RAGをベースとした構成です。 RAGの実現方法は様々あると思いますが、ここではいずれもベクトル検索を用いて回答を返すこととします。 さて、これをPrompt flowでどのように構成するかですが、この構成は考えてみると不定な長さの繰り返し処理を含んでいます。 一方、Prompt flowはDAG（有向非巡回グラフ）でフローを構成する仕組みのため、繰り返し処理を含むフローを表現することができません（NodeCircularDependencyエラーが発生します）。 Pythonコードで書くならば、while文を使って繰り返し処理を行うことができますが、その場合は単一ノードで全ての処理を行うことになってしまい、上述したようなPrompt flowのメリットを活かすことができません。 というわけで結論としては今回取ろうとしているような自律型エージェントの構成をPrompt flowで実現するのは向いていないということになるのですが、 それでブログ記事が終わるとちょっと寂しいので、固定超の繰り返し処理を含むフローでやれるところまでやってみようと思います。 構成を以下のように変更します。 また、具体的に扱うデータとして、個人情報保護法のQ&Aとガイドラインを利用します。 Prompt flowによる自律型エージェントの作成 この構成をPrompt flowで以下のように作成しました。 せっかくなので、LLMの呼び出しにはLLMノードを使っています。 今回はベクトルDBとしてAI Searchを利用しているため、ベクトル検索もIndex Lookupノードを利用できるのですが、そもそも向いていない処理を無理やりやらせていることもあり、フローが複雑になりすぎるので、今回はPythonコード中で処理をしています。 また、Prompt flowでは同じコード（pyファイル）やプロンプト（jinja2ファイル）を複数のノードに割り当てることができるので、同じ処理を繰り返し実行するという元の構成の意図を残し、各ノードに個別の実装をするのではなく共通の実装を各ノードに割り当てるようにしています。 format_inputノードの処理 format_inputは、各ステップをまたいで状態を維持するためのオプジェクトデータを作成する処理です。 各ステップで適切な処理を行うことができるように、以下の状態を持つようにします。 finished 回答の生成が完了したかどうか。元の構成では回答が終了した場合にループを抜けますが、Prompt flowではそのような処理ができないため、各ノードでの処理をスキップするために使用します query ユーザーからの質問文 function_results 各ステップで実行したFunction callingの結果。使った関数の名前と引数、戻り値をリストにして保持します agentノードの処理 agentは3つのノードがありますが、先述の通りすべて同じプロンプト設定を持っており、上述の finished の値が True の場合は処理をスキップするように設定しています。 具体的なプロンプトは以下の通りです。ここで、 input は先述の状態オブジェクトです。 # system: Function callは必要に応じて利用してください。 あなたは個人情報保護法に関する質問に回答するアシスタントです。事前に用意されたQ&A資料やガイドライン資料を参照して、ユーザーからの質問に回答してください。 Q&A資料を参照して回答の根拠が見つからなかった場合、ガイドライン資料を参照してください。 回答を述べる際は、その根拠となる資料中の文章を引用して回答に含めてください。 {% for result in input .function_results %} # assistant: Function generation requested, function = {{result.name}}, args = {{result.arguments}} # function: ## name: {{result.name}} ## content: {{result.content}} {% endfor %} # user: {{ input .query}} プロンプトの記載方法は、こちら 1 を参考にしました。 # system や # assistant などはそれぞれOpenAIのAPI呼び出し時に、roleに変換されるようです。 2 執筆時点でサポート済みの記載が見つけられませんでしたが、 # function 内も特定の書き方をしないとエラーになるため、変換に対応しているようです。 各ノードには別途Function calling用の関数が指定してあり、内容は次のfunctionsノードの処理で説明します。 functionノードの処理 こちらも先述の通り3箇所すべてに同じ関数定義がされています。 agentノードがFunction callingを選択した場合はその処理を行い、agentノードが回答の出力を選択した場合はそれをそのまま次の処理に流します。 内部で呼び出しているsearch関数は質問のベクトル化とAI Searchでのベクトル検索を実行する関数ですが、ほぼ公式ドキュメントのSDKサンプル 3 を参考にしているので、ここでは省略します。 また、Function calling部分の実装はこちら[^1]を参考にしています。 def qanda_search (query): return search( "qanda" , query) def guideline_search (query): return search( "guideline" , query) @ tool def run_function (inputs: dict , agent_message: dict ) -> dict : # 直前のagentノードが実行されていない=すでに回答生成済みの場合 # 現在の回答をそのまま格納する if agent_message is None : return { "finished" : True , "content" : inputs[ "content" ] } # 直前のagentノードが実行され、回答が生成された場合 # 状態を回答済みとし、生成した回答を格納する if agent_message[ "function_call" ] is None : return { "finished" : True , "content" : agent_message.get( "content" , "" ) } # 直前のagentノードが実行され、Function callingが呼び出された場合 # 指定された関数を実行し、実行結果をリストの末尾に追加する function_call = agent_message.get( "function_call" , None ) function_name = function_call[ "name" ] function_args = json.loads(function_call[ "arguments" ]) result = globals ()[function_name](**function_args) function_results = inputs[ "function_results" ] + [{ "name" : function_name, "arguments" : function_args, "content" : [result] }] return { "finished" : False , "query" : inputs[ "query" ], "function_results" : function_results } agentノードでのFunction callingの設定は以下のようにしました。 Q&A資料が質問にうまくマッチする場合はその方が精度が高いというユースケースを想定し、先に参照するように指示しています。 [ { " name ": " qanda_search ", " description ": " Q&A資料を参照する時に利用します。すでに一度呼び出している場合は呼び出さないでください。検索用のクエリを指定して検索をします。 ", " parameters ": { " type ": " object ", " properties ": { " query ": { " type ": " string ", " description ": " 検索用のクエリ。基本的にはユーザーの質問そのものを使いますが、必要に応じてタイポの修正やベクトル類似度による検索に適した形への修正をしても構いません " } } , " required ": [ " query " ] } } , { " name ": " guideline_search ", " description ": " ガイドライン資料を参照するときに利用します。Q&A資料を参照して適切な回答がない場合はこちらを呼び出してください。検索用のクエリを指定して検索をします。 ", " parameters ": { " type ": " object ", " properties ": { " query ": { " type ": " string ", " description ": " 検索用のクエリ。基本的にはユーザーの質問そのものを使いますが、必要に応じてタイポの修正やベクトル類似度による検索に適した形への修正をしても構いません " } } , " required ": [ " query " ] } } ] 作成したフローの実行 今回作成したベクトルDBには、個人情報保護委員会が公開している個人情報保護法のQ&Aと、個人情報保護法のガイドラインが登録されています。 4 ガイドラインについては、「個人情報の保護に関する法律についてのガイドライン（通則編）」のPDFのみを利用し、Q&Aについては、同じく「ガイドライン（通則編）」に対応するQ&Aのうち、一部のみを登録しました。そうすることで、未登録の質問についてはQ&Aのみだと回答が見つからない状態にしています。 フローを実行すると、以下のような結果が得られました。まずは、Q&Aに存在するのと同じ質問を入力した場合です。 先に参照したQ&Aの内容で回答可能と判断してガイドラインの参照をスキップし、Q&Aの内容を引用して回答を返しています。 次に、Q&Aのみでは見つからない質問をしてみます。先に参照したQ&Aの内容では回答が見つからないため、さらにガイドラインも参照して回答を返しています。 今回作成したフローでは、プロンプトを含むRAGの精度については十分に精査していないため、必ずしもこれらのように適切な動作をするわけではないものの、少なくとも想定したような動作ができることは確認できました。 フローの評価方法についてはここでは詳細を割愛しますが、上記の通り各ノードごとに個別の入力と出力を取得できるため、単にユーザーの質問と最終出力のみでなく、各ステップごとの処理まで深掘りして評価することができます。 また、Azure AI Studio上でバルク実行をすることで、複数の質問に対して一括で回答を生成し、まとめて評価を行うことも可能です。 まとめ 今回はPrompt flowを使って、固定長の処理を行う自律型エージェントを作成してみました。 Prompt flowは事前に定義されたノードやツール、Azure AI Studioとの統合による評価の容易さなど、様々なメリットがある一方で、繰り返し処理が必要となる自律型のエージェントの作成には向いていなさそうです。 既にクローズされたIssue 5 にも言及がある通り、DAGという性質上の難しさはあると思いますが、なんらかの機能サポートに期待しつつ、他の方法での実現も模索していきたいと思います。 microsoft/promptflow ↩ LLM — Prompt flow documentation ↩ Python のサンプル - Azure AI Search | Microsoft Learn ↩ 法令･ガイドライン等 ｜個人情報保護委員会 ↩ [Feature Request] Achieve dynamic flow connections with logic conditions · Issue #386 · microsoft/promptflow ↩

はじめに はじめまして、InsightEdge 分析チームの中野です。 今回は自然言語からCypherクエリを生成する手法について、LLM（大規模言語モデル）を用いたアプローチを紹介します。 最近、RAG（Retrieval-Augmented Generation）という手法が注目されています。これは、LLMが外部の知識ベースを検索し、その情報を基に回答を生成するプロセスです。また、外部知識にナレッジグラフを利用することでデータを構造化し、より関連性の高い情報を抽出することも注目されています。 ナレッジグラフを使用するにはneo4jのようなグラフデータベースを使用することが一般的です。 しかし、このRAGプロセスではテキストからグラフクエリ言語であるCypherクエリを生成する必要があります。 この記事では、このRAGプロセスでCypherクエリを生成する際の課題と、Chain-of-Thought（CoT）を使用して精度向上を試みた結果について紹介します。 はじめに text-to-cypherの課題 対策と検証 Chain-of-Thought Promptingの実装 テストデータ 評価指標 結果 まとめ 参考文献 text-to-cypherの課題 ナレッジグラフを使用したRAGプロセスでは、テキストからCypherクエリを生成するステップが必要となります。 しかし質問文ではクエリの構成を具体的に指定しないため、必ずしも適切なクエリを生成できないという問題があります。 例として Twitchのソーシャルネットワーク を使い、簡単なクエリの生成を試みます。 このTwitchのネットワークは、ユーザーやゲームのノードで構成されており、どのユーザーがどのゲームをプレイしたか、誰が誰にコメントしたかといった情報が含まれています。 このグラフデータベースに対して「人気のゲームのタイトルを教えてください。」というテキストから、Cypherクエリを生成させてみます。 「人気のゲームのタイトルを教えてください。」という問いに対し、gpt-3.5-turboを用いた生成結果ではプレイされたゲームを一覧表示するクエリが生成されました。しかし、これは配信者がプレイしたゲームすべてを列挙するため出力が数万から数百万件に及ぶ可能性があり、適切なクエリとは言えません。 -- gpt-3.5-turboを使用して「人気のゲームのタイトルを教えてください。」から生成したクエリ -- NG:応答が多すぎて、適切なクエリではない。 MATCH (s:Stream)-[:PLAYS]->(g:Game) RETURN g.name 一方、gpt-4を用いた場合は配信者がプレイしたゲームを列挙した後、ゲーム名ごとにプレイ回数を集計し、人気のゲームを上位10件表示するクエリが生成されました。このクエリは、人気のゲームを知りたいならば、ゲームごとにプレイした人数を調べればよいという意図を反映した、適切なクエリと言えます。 -- gpt-4を使用して「人気のゲームのタイトルを教えてください。」から生成したクエリ -- OK:ゲームごとにプレイした人数が調べられているため、適切なクエリである。 MATCH (s:Stream)-[:PLAYS]->(g:Game) RETURN g.name AS Game_Title, COUNT (*) AS Popularity ORDER BY Popularity DESC LIMIT 10 このようにgpt-3.5-turboでは簡単な集計を必要とするクエリですら満足に生成することはできません。gpt-4では適切にクエリを生成できているもののコストがgpt-3.5-turboの約20倍、速度が10分の1️と非常に低速です。そのためエージェントなど何度もグラフに問い合わせを必要とする用途では、なんとかしてgpt-3.5-turboのような軽量なLLMに回答を作成させたいところです。 対策と検証 精度向上のために、今回はChain-of-Thought（CoT）を試します。CoTは、入力から出力に至るまでの中間過程を明示することで、複雑な問題にも対応できる手法です。 この手法を用いることで、軽量なLLMでも高精度な出力を実現できる可能性があります。 改善施策の効果を検証するために、10個程度の質問文とクエリのペアを手作業で作成し、gpt-3.5-turbo、gpt-4、それにCoTを加えたバージョンの4つについて、生成されたクエリとその応答結果を比較します。 クエリの精度はJaro-Winkler距離で、応答結果の精度はJaccard係数で測定します。 Chain-of-Thought Promptingの実装 実装はLangChain(0.1.0)を使用します。 まず通常のcypherクエリだけを出力するChainを以下のように定義します。 # Chain-of-Thought Promptingを使用しない class CypherResponse (BaseModel): query : str = Field(title= "Cypher Query" ) def get_cypher_chain (graph, model): parser = PydanticOutputParser(pydantic_object=CypherResponse) prompt = PromptTemplate( template= """Based on the Neo4j graph schema below, write a Cypher query that would answer the user's question: {format_instructions} {schema} Question:{question} JSON OUT:""" , input_variables=[ "question" ], partial_variables={ "schema" :graph.schema, "format_instructions" : parser.get_format_instructions() } ) chain = prompt | model | parser return chain 次にChain-of-Thoughtを使用する場合は以下のように定義します。queryの他に思考過程も出力させます。 # Chain-of-Thought Promptingを使用する class ChainOfThougthCypherResponse (BaseModel): chain_of_thought : str = Field(title= "Thought process in the process of generating a cypher query" ) query : str = Field(title= "Cypher Query" ) def get_cot_cypher_chain (graph, model): parser = PydanticOutputParser(pydantic_object=ChainOfThougthCypherResponse) prompt = PromptTemplate( template= """Based on the Neo4j graph schema below, write a Cypher query that would answer the user's question: {format_instructions} {schema} Question:{question} Lets think step by step. JSON OUT:""" , input_variables=[ "question" ], partial_variables={ "schema" :graph.schema, "format_instructions" : parser.get_format_instructions() } ) chain = prompt | model | parser return chain テストデータ テストデータとして質問文とCypherクエリのペアを10組程度作成しました。 data = [ { "question" : "韓国語(ko)を使用するストリーマを調べて。" , "cypher" : "MATCH (s:Stream)-[:HAS_LANGUAGE]->(l:Language) WHERE l.name = 'ko' RETURN s.name AS Streamer " }, { "question" : "人気のゲームのタイトルを5つ教えてください。" , "cypher" : "MATCH (g:Game)<-[:PLAYS]-(s:Stream) RETURN g.name AS game, COUNT(*) AS streamCount ORDER BY streamCount DESC LIMIT 5" }, ... ] 評価指標 評価方法については こちらのブログ を参考としました。 生成されたクエリの精度はJaro-Winkler距離を使用して測定し、応答結果はJaccard係数を使用して測定します。 Jaro-Winkler距離 は、2つの文字列の類似性を測定するための手法です。生成したクエリと正解のクエリがどれだけ似ているかを測定するために使用します。完全に一致する場合は1になり、完全に異なる場合は0となります。 Jaccard係数 は、2つの集合の類似性を測定するための手法です。生成したクエリを使い検索されたデータと正解のデータにどれだけ一致しているかを測定するために使用します。完全に一致する場合は1になり、完全に異なる場合は0となります。 結果 gpt-3.5-turbo、gpt-4、gpt-3.5-turbo+CoT、gpt-4+CoTに対して、生成されたクエリとクエリの応答結果を比較します。CoTを使用することでクエリの応答結果の精度が向上することを確認できました。 まとめ 本記事では、Chain-of-Thoughtを使用して、gpt-3.5-turboのような軽量なLLMでもgpt-4のような高精度な出力を実現できることを示しました。 今後は、Chain-of-Thoughtを活用して、テキストからCypherクエリを生成する手法をさらに精度向上させていきたいと考えています。 参考文献 https://towardsdatascience.com/evaluating-llms-in-cypher-statement-generation-c570884089b3

こんにちは。12月からInsight Edgeに参画したData Scientistのカイオと申します。 入社してから早速、ChatGPT案件やデータサイエンス案件をいくつか担当しています。 今回は、とある案件で使用したMLパイプライン管理ツール「Kedro」について紹介したいと思います。 目次 Kedroとは なぜKedroを選んだか メリット デメリット 他のツールとの違い まとめ Kedroとは まず、Kedroとは何かの説明から始めましょう。 パイプラインを表示する機能もあります（引用元： https://docs.kedro.org/en/0.17.7/03_tutorial/05_visualise_pipeline.html ） Kedroとは、データサイエンスのパイプラインを管理するツールです。データ収集、変換やモデル学習、ハイパーパラメータ調整の管理から精度評価までまとめて簡単にしてくれます。 パイプライン中の処理の中間成果物やモデルを簡単にアクセスできるようにしてくれます。 なぜKedroを選んだか 今担当している案件では、事前処理の段階で色々な関数を実行しています。datetime⇨datetime + timezoneに変換したり、ダミー変数を作成したりしています。 複雑な処理がたくさんある中で、途中の成果物を常に確認する必要があります。 例えば： before_preprocessing.csv ⇨ after_preprocessing.csv ⇨ train.csv, test.csv, validation.csv それぞれのステップの時点でファイルの中身を確認したいですね。毎回 .to_csv() を実行するのは面倒だし、フォーマットは簡単に変えられない。 Kedroを使うと自動で生成されるだけではなくて簡単にフォーマットを変えられます。もちろん、csvからPickleまで幅広いフォーマットをサポートしているだけでなく、バージョン管理やリモートアクセスもできます。変数名をcatalog.ymlに記入すると変数として使えるだけでなくファイルとして保存されます。 それがKedroを選んだ1つの理由です。以下はそのcatalog.ymlの一例です。 もちろん、products_rawなどもそのままパイプライン内で変数として使われます。 products_raw : type : pandas.CSVDataset filepath : data/01_raw/products_raw.csv products_preprocessed : type : pandas.CSVDataset filepath : data/02_intermediate/products_preprocessed.csv lgb_model : type : pickle.PickleDataset filepath : data/06_models/final_model.pkl results : type : pandas.ParquetDataset filepath : s3://customer_bucket/results.pq もう1つの理由は、プロジェクトの構成を決めてくれる機能です。 kedro new を実行すると自動でテストや、データ格納ディレクトリまで作ってくれます。 複数人で同じプロジェクトを開発するとき、個人のディレクトリ構成のばらつきを気にする必要がなくなります。 最後の理由は、それぞれのパイプラインを単独で実行できるところです。 何かパラメータを変えた時、 kedro run --pipeline=training というふうに実行でき、一部を簡単に飛ばせます。 他のツールとの比較 よく比較されるツールの中で、私の使ったことがあるのはOptunaとMLflowなので、Kedroと比較してみます。 MLflow MLflowは実験を管理するツールです。モデルやデータセットのバージョン管理ができて精度などの可視化ができる Kedroでcatalog機能を使えばデータセットやモデルのバージョン管理はできるが可視化やmetrics測定はそこまで得意ではありません Optuna Optunaはハイパーパラメータ調整フレームワークです。Kedroでも同じようなことができるが、そこまで向いていない気もします。ただし、2つを組み合わせることによってよりパワーフルなパイプラインを作ることができる（実際にその使い方をしている案件があります） SageMaker Pipelines（おまけ） SageMakerはAWSの機械学習向けのサービスです。クラウドのサービスと比較するのは少し無理がありますが、共通点が多いのも事実です S3にデータのバージョン管理ができるところはKedroのカタログ機能に似ていて同じようにパイプラインを設計できます メリット 中間成果物が自動で保存される（個人的にこれが一番大きい） プロジェクトごとによる構成の差分が少なくなる パイプラインの一部だけ実行できる（例：評価部分だけ実行したい） デメリット パイプライン実行中にエラーが発生した際、Tracebackが長く問題箇所まで辿りづらい 中間成果物のフォーマットによって、忠告なしに情報が失われる 例：PandasのDataframeをcsvとして保存したら、csvがサポートしていない型の変数は勝手に変換されて情報が消える Poetryとの相性が悪い 共存できるという方もいますが個人的にやってみたら色々難航して結局pip-compileでいきました 早いプロトタイピングには向いていない 簡単な使い捨てプログラムなどの場合はJupyterのほうがいい まとめ Insight Edgeに入社してから初めてKedroというツールを知りました。今まで数年間、機械学習関連の案件をやってきたのに、Kedroの存在を知らなかったのは少し恥ずかしいです。 色んな背景の方々や幅広い専門知識を持っている優秀なエンジニアが周りにいて毎日新しい知識を身に付けられるのは当社の素晴らしいところだと思います。これからも新しい技術やツールを学ぶとともにソフトなスキルを磨いて、周囲のエンジニアと切磋琢磨していき、プロジェクトで活用していきたいです！

はじめまして、今年の1月にInsight Edgeへ参画したData Scientistの山科です。 まだ加入して数ヶ月ですが、画像を用いた異常検知や予兆保全、オペレーションの最適化、生成AI用いたDX案件など、幅広い技術・分野に携わらせてもらっており、日々、調査にデータ分析の試行錯誤と四苦八苦しながら業務に取り組んでいます。 今回は、画像を用いた異常検知に関する案件でPatchCoreという手法を用いたのですが、使い勝手が良く様々なことに使えそうだなと感じましたので、間違い探しを題材にパラメータのケーススタディをした結果を評価し、どういったことに使えるかを考察していきたいと思います。 目次 画像に対する異常検知手法 AIで間違い探しを解く! 考察 画像に対する異常検知手法 画像認識技術を用いた異常検知の重要性については、 藤村さんの記事 でも紹介されている通りで、製造業や農業など幅広い分野で省力化・効率化のため用いられています。 画像に対する異常検知技術としては、近年、ディープラーニングベースのものが主流となっており、そのなかでもハイブリットモデルと呼ばれる、事前学習済みのニューラルネットワークモデルと異常検知として長く用いられているkNNを組み合わせた手法がSOTAを達成しています。ハイブリットモデルとしても、SPADE、PaDiM、PatchCore、といった手法が提案されていますが、今回は PatchCore を選択しました。 PatchCoreでは、学習済みモデル用いて正常画像から抽出した特徴量をMemory Bankに保存しておき、判定したい画像の特徴量との距離から正常/異常を判定します。この時、学習済みモデルを特徴量抽出器として用いているためニューラルネットワークの再学習が不要な点、学習済みモデルの最終層ではなく中間層から特徴量を取得するようにしたことで画像の位置情報も保持することで、局所的な異常（ピクセル単位での異常）を見つけやすくしている点が特徴となっています。 今回は、 ind_knn_ad で実装されているPatchCoreを用いて検証して行きます。 AIで間違い探しを解く! 間違い探しはよく似た絵から異なる箇所を探すパズルですが、異常検知も検証したい画像が正常な画像と比べてどこが似ているか、異なっているかを探すタスクですので異常検知と同様に考えられます。間違い探しの題材としましては、春といえばさくら、ということで下図の間違い探しに取り組んで行きたいと思います。画像サイズはそれぞれ、950✕1450となっており、間違い箇所は5箇所です。（私は2コしか見つけれませんでした。。。） Fig.1 間違い探し（左：正しい画像、右：間違い画像） まず、デフォルトの設定値で間違い箇所を検知した結果を下図に示します。左から学習画像（正しい画像）、検証画像（間違い画像）、検証画像＋異常度を示しています。異常度の結果を見ると全体的に赤くなっており、異常度が高い、つまりほとんどの箇所で間違っていると出力してしまっています。また、Fig.1と比べると正方形に修正（リサイズ）されており、右側や左側に関しては異常検知できていないことがわかります。 Fig.2 デフォルト設定値での結果 リサイズされていることに関して、プログラムを見てみると画像の前処理として高さを256に（アスペクト比を維持して）リサイズしたあとに、CenterCropで224✕224のサイズで抽出していることがわかりました。これにより、周りの画像が切り取られてしまいますので（中心に検知対象が写っており、周りは背景になっているような画像を想定しているのだと思います。実際に製造現場ではそういった画像を扱うことが多いです。）、この前処理部分の修正として、CenterCropの処理をコメントアウトしていきます。 # 学習データの読み込み部 size= 224 class MVTecTrainDataset (ImageFolder): def __init__ (self, cls : str , size : int ): super ().__init__( root=DATASETS_PATH / cls / "train" ,◊ transform=transforms.Compose([ transforms.Resize( 256 , interpolation=transforms.InterpolationMode.BICUBIC), transforms.CenterCrop(size), transforms.ToTensor(), transforms.Normalize(IMAGENET_MEAN, IMAGENET_STD), ]) ) self.cls = cls self.size = size CenterCropの処理をコメントアウトした結果を以下に示します。画像全体に対して異常検知できるようになりましたが、相変わらず赤い箇所が多いままとなっています。 Fig.3 CenterCropの処理をコメントアウトした結果 これは、特徴数のサンプリングの割合（Memory Bankに保存するピクセルの割合）がデフォルトでは1%となっており、正常と学習しているピクセルのパターンが少ないため正しく判定できなかったと考えられます。このためサンプリングの割合を10%、50%、70%と変えて評価したいと思います。各ケースで異常度を算出した結果を下図に示します。これよりサンプリングの割合を増やすことで、部分的に異常度が高く（図中では赤く）なることが確認できます。サンプリングの割合を増やすことで画像中のピクセルを満遍なく学習でき、誤検知を減らすことができていると考えられます。 50%や70%のときの結果を見ると、①真ん中右より、②右側の桜の木の後ろ側、の2箇所で異常度が高くなっていることが確認できます。実際に、①さくらの木が無くなっている、②鹿が増えている、ので間違いを見つけることができました。 Fig.4 サンプリング割合を変えた場合の結果 さくらの木や鹿は比較的大きいので、他3箇所はもう少し小さい変化の可能性があります。ですので、次は前処理で行っているリサイズの割合をデフォルトの25%（正確には256/950=26.95%）から、50%、75%、100%に変更して評価します。サンプリング割合は50%としました。 リサイズの割合を変えた結果を以下に示します。これより、75%以上でより局所的に異常度が増加していますが、いずれのケースでも③間違いケースではなくなっているさくらの木の下側の通路沿い、④石階段の中断右側、で異常度が増加していることが確認できます。実際に、③では通路沿いに石が増えている、④階段に石が増えている、ので新たに間違いを②つ見つけることができました。あと1つですね。 [ ] Fig.5 画像解像度を変えた変えた場合の結果 次に、特徴量抽出器であるバックボーンのアルゴリズムを変えてることで間違いを見つけられるか確認していこうと思います。デフォルトでのバックボーンはEfficientNet-b0となっていますので、以下のアルゴリズムを検証しました（各アルゴリズムの詳細は割愛させていただきます）。分析条件は、サンプリング割合：50%、前処理：CenterCrop無し、リサイズ75%としています。 EfficientNet-b7（tf_efficientnet_b7） Efficientnet-v2-s（tf_efficientnetv2_s） Mobilenet-v3-large（tf_mobilenetv3_large_100） wide_resnet50_2 いずれのケースでもEfficientNet-b0と同様に、これまでに見つけた4箇所で異常度が増加していることがわかります。Efficientnet-v2-sでは局所的に異常度が増加している箇所が何箇所が増えています。 Fig.6 特徴量抽出器を変更した結果 これらの特徴量抽出器アルゴリズムの結果を眺めるて見ると、いずれも左側の桜の木の中段右横でわずかに異常度が増加していることがわかります。この部分を拡大して見てみると、確かに、花びらが1枚なくなっています！！！ これにて、なんとか5コ全ての間違いを見つけることができました。 Fig.7 左側桜の木を拡大 ロバスト性評価 間違い探しの場合は、厳密に位置合わせができていますが、製造現場などの実際のユースシーンでは撮影時の角度や明るさといった撮像環境が学習時と検証時とで異なるケースのほうが多いかと思います。ここでは、ランダムに平行移動した画像を学習画像とした場合に、間違いを検知できるか確認したいと思います。 学習させた画像例は以下の通り。 Fig.8 ロバスト性検証用学習画像 評価条件としては、サンプリング割合：50%、特徴量抽出器：EfficientNet-b7（Fig.6~9の中では、誤検知が少ないため）、前処理：CenterCrop無し、リサイズ75%）としました。間違い以外の箇所でも異常度が増加していますが、5箇所の間違い箇所でも異常度が増加しており、位置ズレに対してもロバストに検知できることがわかりました! Fig.9 位置ズレ検証結果 技術の価値と今後の可能性 今回、間違い探しを例題に、画像の異常検知技術であるPatchCoreを試し、各パラメータを調整した際の影響を評価しました。結果として5箇所全ての間違いを見つけることができましたが、パラメータの調整やパラメータを変えたモデルのアンサンブル適用などが必要でした。 試してみて、PatchCoreの特徴として、次のことがわかりました。 特徴量抽出器に学習済みモデルを活用できるので、異常検知には少量の画像でも精度が出せ、モデルの学習にも時間を要しない ピクセル単位での異常検知が可能 位置ズレに関してもロバストに検知可能で、実問題にも適用しやすい このことから、適用先として以下のようなタスクの対しても適用できると考えられます。 どういった状態で流れてくるかわからない製造ラインでの異常検知 形・色等が様々な農業での品質管理など 製品組み立て後の配線などの確認 カメラ画像を用いた、特定箇所での位置判定 一方で、画像を用いる際の異常検知の課題として、以下が残っていますので、引続き技術動向を調査して行きたいと思います。 画像に映らない箇所に対しては、検知のしようが無いので、複数のカメラでもれなく撮影する必要がある 位置に関するロバスト性は確認できたが、明るさといった違いにも過敏に反応することもあったので、ご検知を減らすためには室内で撮像環境を一定とする必要がある

初めまして、2023年11月にInsight Edgeにジョインしたデータサイエンティストの ヒメネス（Jiménez） です！スペイン出身です。 入社から数ヶ月しか経っていませんが、この短い期間の中で生成AIの案件に携わるうえ、海外案件でDSコンサルタントとしても活動しています。 元々数学者ですが、プログラミングが大好きで、得意とするアルゴリズム構築を仕事にしました。コンサルティング企業にもしばらく参画した結果、ビジネスも少しずつ理解できるようになり、自分の視野や能力が広がりました。 この機会にWeb scrapingについて紹介したいと思います。Web scraping（スクレイピング）は、Webサイトから自動的にデータを収集する技術であり、研究者、マーケター、データアナリストなどにとって貴重な情報源となっています。 この記事では、Web scrapingの基本から、Seleniumを使用した高度なテクニックまでを紹介し、特に知られざるコツとスクレイピングの倫理に焦点を当てます。私たちの目的は、読者がWeb上のデータを効率的かつ倫理的に収集する方法を理解し、実践できるようになることです。このプロセスを通じて、あらゆるレベルの技術者がWeb scrapingの力を最大限に引き出し、新たな知見を得る手助けをすることを目指しています。 目次 Web scrapingとは Web scrapingの倫理 Seleniumの紹介 導入 ブラウザ起動 Webページに移動 基本操作（入力・クリック） 中級 待機 人間らしい入力 ヘッドレス 上級 タブ移動 JavaScript実行 HTML取得 マルチスレッディング おまけ: Selenium + Kaggle API 前提条件 Kaggle APIの準備 SeleniumとKaggle APIの組み合わせ 活用例: Squadroのプレイ歴収集 まとめ Web scrapingとは Web scraping（スクレイピング）またはweb crawling（クローリング）とは、プログラムを用いてWebサイトからデータを抽出する技術です。このプロセスには、HTTPリクエストを送信してWebページを取得し、必要な情報を解析・抽出するためのコードが含まれます。スクレイピングは、ネット上に転がっている大量のデータを迅速に収集する必要がある研究、マーケティング分析、競合他社の価格監視など、さまざまな用途で利用されます。 Web scrapingの倫理 スクレイピングは便利な技術である一方で、倫理的な懸念も伴います。Webサイトの利用規約に違反すること、サーバーへの過度な負荷、個人情報の不適切な取得といった問題が発生する可能性があります。そのため、スクレイピングを行う際は、対象サイトの利用規約を確認し、必要に応じてサイトの管理者から許可を得ることが重要です。また、アクセス頻度を制限してサーバーへの負担を軽減するよう配慮する必要があります。 Seleniumの紹介 Seleniumは、Webアプリケーションのテスト自動化のためのフレームワークですが、web scrapingにも広く使用されています。ブラウザを自動操作することで、JavaScriptで動的に生成されたコンテンツを含むページからもデータを取得できます。 まず、Seleniumをインストールしましょう。 pip install selenium そして、 webdriver-manager もインストールしましょう。 webdriver-manager は、Selenium WebDriverのドライバを簡単に管理するためのライブラリです。このライブラリを使用することで、ブラウザドライバ（ChromeDriverやGeckoDriverなど）の自動ダウンロードと更新が可能になり、Seleniumを使ったテストやスクレイピングをスムーズに実行できます。 pip install webdriver-manager この手順により、SeleniumでWebブラウザを自動操作する準備が整います。 ブラウザを手動でダウンロードして使用を指定したい場合、次のリンクよりChromeとFirefoxの最新版がダウンロードできます： ChromeDriver （Chrome）、 GeckoDriver （Firefox）。 導入 まずは、Seleniumの世界へようこそと言うことから始めます。初心者でもスムーズに取り組めるよう、ブラウザの起動からWebページへの移動、そして基本操作（テキスト入力やクリック動作）まで、丁寧に解説していきます。ここをマスターすることで、あなたもWebサイトからの簡単なデータ抽出が可能になります。 1. ブラウザ起動 まずはSeleniumを使ってブラウザを立ち上げます。このコード例では、 webdriver_manager ライブラリを使って、適切なChromeDriverを自動的にダウンロードし、インストールします。 from selenium import webdriver from selenium.webdriver.chrome.service import Service from webdriver_manager.chrome import ChromeDriverManager driver = webdriver.Chrome(service=Service(ChromeDriverManager().install())) これにより、Seleniumは常に最新のChromeDriverを使用してブラウザを操作できるようになります。 ブラウザが規定のサイズで立ち上がりますが、以下のコマンドでウィンドウの最大化が可能です。 browser.maximize_window() 2. Webページに移動 ブラウザが立ち上がったら、 duckduckgo.com に移動させます。コマンドが順序良く実行されるため、基本的には前のコマンド（この場合だと、ブラウザ起動）が完了するまで次のコマンドは待機します。 driver.get( 'https://duckduckgo.com/' ) 3. 基本操作 ここからは実際のweb scrapingが始まります。そのために、まずは今立ち上がっているブラウザのエレメント（ボタン、入力など）のないところを右クリックし、最後の選択肢「検証」を選びます。右側に今閲覧しているページのHTMLコードが見えます。（エラーメッセージも下部に表示されているかもしれませんが無視しても大丈夫です） テキスト入力: send_keys DuckDuckGoの真ん中にある検索バーにテキストを入力するために、検索バーの中で右クリックし、「検証」をクリックします。 すると、右側の検証画面に青でハイライトされるエレメントが見えます。ハイライトの部分をマウスでホバーすると逆に検索バーがハイライトされます。これで操作したいエレメントがちゃんと選択できているか確認できます。 検索バーの XPath を取得する必要がありますので、右側にハイライトされているエレメントにもう一度右クリックし、「Copy」>「Copy XPath」を選択します。 Seleniumでそのエレメントにテキストを入力するために以下のように書きます。 driver.find_element( 'xpath' , '//*[@id="searchbox_input"]' ).send_keys( 'insight edge 会社' ) テキストクリア: clear 時々テキストエレメントに既にテキストが記入されています（多くの場合記入例として）。その場合 send_keys を使うと入力するテキストが元々のテキストに上書きされず追加されます。内容を消して書き直すためには clear コマンドを使います。 driver.find_element( 'xpath' , '//*[@id="searchbox_input"]' ).clear() driver.find_element( 'xpath' , '//*[@id="searchbox_input"]' ).send_keys( 'insight edge 会社' ) ボタンクリック: click 検索ボタン（青い🔍）の XPath を上記同様に取得し、今度クリックの命令を書きます。 driver.find_element( 'xpath' , '//*[@id="searchbox_homepage"]/div[1]/div/button[2]' ).click() テキスト取得: text 表示された検索結果の一番上にInsight Edgeのホームページが現れます。「insight edge 会社」のテキストを取得しましょう。いつも同様に XPath をコピーします。 driver.find_element( 'xpath' , '//*[@id="r1-0"]/div[2]/h2/a/span' ).text ところで、「insight edge 会社」のエレメントはクリックできるエレメントにもなっていますので、前のステップと同様にクリックすることも可能です。ただし、指導のためリンク先のアドレスを取得してからページに移動しましょう。右側のエレメントで「insight edge 会社」のエレメントは h3 のラベルがありますが、その一層上のラベル a のもの（リンク）の XPath を取得します。 link_url = driver.find_element( 'xpath' , '//*[@id="r1-0"]/div[2]/h2/a' ).get_attribute( 'href' ) driver.get(link_url) Insight EdgeのWebサイトに着いたでしょうか？ ブラウザを閉じる: quit 作業した後に必ずブラウザを閉じましょう。そうしないとメモリが解放されないままお化けのブラウザが生き続けます。 quit でブラウザを終了します。 driver.quit() これはSeleniumの基礎です。次のセクションでもうちょっと高度なテクニックを共有します。 中級 次のステップでは、Seleniumの使いこなし方を一段階引き上げます。ページの読み込み待機処理、人間のような入力を模倣する方法、そしてヘッドレスブラウザの活用法を学び、より効率的かつ正確にデータを収集する技術を習得します。中級レベルをクリアすることで、あなたのスクレイピングはより洗練されたものへと進化します。 1. 待機 Webページが時々ロードするのに時間がかかります。エレメントがロードされる前にアクセスしようとすると「エレメントが存在しない」エラーが挙がります。エレメントが現れるまで待つには以下のメソッドを使います。先にメソッドをインポートします。 from selenium.webdriver.common.by import By from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC そしてもう一度上記の処理を実行します。ただし、今回は待機機能を追加します。 driver.get( 'https://duckduckgo.com/' ) driver.find_element( 'xpath' , '//*[@id="searchbox_input"]' ).send_keys( 'insight edge 会社' ) driver.find_element( 'xpath' , '//*[@id="searchbox_homepage"]/div[1]/div/button[2]' ).click() # 待機。指定したXPathが現れなければ10秒までしか待たないように指定しています。その場合Exceptionを拾うべきです。 element = WebDriverWait(driver, 10 ).until(EC.visibility_of_element_located((By.XPATH, '//*[@id="r1-0"]/div[2]/h2/a/span' ))) element.click() ※ visibility_of_element_located （対象エレメントの表示）の他、 presence_of_element_located （対象エレメントの存在）や element_to_be_clickable （対象エレメントのクリック可能性）など、ご自身のニーズに合ったメソッドを使うことができます。 2. 人間らしい入力 スクレイピングを悪用する人がいるため、Webサイトによっては機械らしい行為に対してアクセスをブロックすることがあります。しかし、我々のような良い使い方をする人にとっては不公平なハードルとして感じられるかもしれません。その場合、人間らしい入力を再現するとてもシンプルな関数を用いてハードルを超えることができます。 def fill_slowly (driver, xpath, keys): import time, random for key in keys: driver.find_element( 'xpath' , xpath).send_keys(key) time.sleep(random.uniform( 0.2 , 1 )) # 平均0.2秒の正規分布に従う休憩時間を寝かせます driver.get( 'https://duckduckgo.com/' ) fill_slowly(driver, '//*[@id="searchbox_input"]' , 'insight edge 会社' ) driver.find_element( 'xpath' , '//*[@id="searchbox_homepage"]/div[1]/div/button[2]' ).click() 人間らしい入力イメージ： 3. ヘッドレス 自動化を高速化するために、一度実装したコードをヘッドレス（非表示）モードにします。例えば、テキスト取得に使ったコードを再利用しますが、今回はブラウザを非表示にし、結果を print で出力します。ブラウザ表示の場合とブラウザ非表示の場合の速さを比較します。 from selenium import webdriver from selenium.webdriver.chrome.service import Service from selenium.webdriver.chrome.options import Options import time def compare_speed (headless= False ): options = Options() if headless: options.add_argument( '--headless' ) driver = webdriver.Chrome(service=Service(), options=options) driver.get( 'https://duckduckgo.com/' ) driver.find_element( 'xpath' , '//*[@id="searchbox_input"]' ).send_keys( 'insight edge 会社' ) driver.find_element( 'xpath' , '//*[@id="searchbox_homepage"]/div[1]/div/button[2]' ).click() text = driver.find_element( 'xpath' , '//*[@id="r1-0"]/div[2]/h2/a/span' ).text driver.quit() return text # 表示 start_time = time.time() text = compare_speed(headless= False ) print (f '取得したテキスト: {text}' ) print (f '経過時間: {time.time() - start_time:.2f} 秒' ) # 非表示 start_time = time.time() text = compare_speed(headless= True ) print (f '取得したテキスト: {text}' ) print (f '経過時間: {time.time() - start_time:.2f} 秒' ) ヘッドレスモードの方が速かったでしょうか？ 上級 この章では、複雑なWebページからのデータ抽出に挑むための、高度なテクニックを学びます。タブの操作からJavaScriptの実行、HTMLの直接取得に至るまで、さらにはマルチスレッディングを駆使した高速化テクニックまで、上級者向けの知識とスキルを身につけ、より深いスクレイピングの世界を探求します。 1. タブ移動 場合によって、クリックする際に新しいタブが開かれます。タブを移動することも可能です。 driver.get( 'https://dirdam.github.io/apps.html#squadro' ) driver.find_element( 'xpath' , '//*[@id="squadro_description"]/a' ).click() driver.switch_to.window(driver.window_handles[ 1 ]) element = WebDriverWait(driver, 30 ).until(EC.presence_of_element_located((By.XPATH, '//*[@id="welcome_bga_text"]' ))) print (element.text) driver.window_handles がタブを管理するリストになりますので、最初のタブの番号は 0 で、新しく開かれたタブの番号は 1 です。 タブを閉じる: close driver.quit() を使うとブラウザ自体が閉じてしまいます。タブだけを閉じるのに driver.close() を使います。 注意しなければならないことは、タブを閉じると再びアクセスできないので、引き続きスクレイピング作業をする場合、開いているタブに切り替える必要があります。例えば、規定のタブに戻るのに 0 番目のタブに戻ります。 driver.close() driver.switch_to.window(driver.window_handles[ 0 ]) 2. JavaScript実行 Webサイトに直接JavaScriptを投げることが可能です。便利な使用例がいくつか考えられます。 新規タブを開く（そのまま） ブラウザ上で新しいタブを開きます。（内容は空です） driver.execute_script( "window.open('','_blank');" ) 新規タブを開く（特定のURL） ブラウザ上で新しいタブを開きます。（内容は特定したURL） driver.execute_script( "window.open('https://duckduckgo.com');" ) メタデータ取得 例えば、ページタイトルの取得。 driver.execute_script( 'return document.title;' ) 3. HTML取得 全HTML取得 Webページのソースコード（HTML）を取得することも可能です。ページ全体のソースコードを取得するには以下のコードを使用します。 page_source = driver.page_source print (page_source) 一部HTML取得 一方、特定のXPathのエレメント配下のHTMLのみ抽出したい場合、 excute_script メソッドを活用して以下のコードで取得可能です。 driver.get( 'https://duckduckgo.com/' ) parent_element = driver.find_element( 'xpath' , '//*[@id="__next"]/main/article/div[1]/div[1]/div/section[2]' ) html_code = driver.execute_script( "return arguments[0].outerHTML;" , parent_element) 読み込んだHTMLを保存したい場合、HTMLファイルとして保存（再生）できます。 with open ( "temp.html" , "w" , encoding= "utf-8" ) as file : file .write(html_code) また、そのファイルを開いて、そのHTMLに対して改めてSelenium経由でスクレイピングすることも可能です。URLではなく、ローカルHTMLを開くのに以下使います。 import os driver.get( "file://" + os.path.abspath( "temp.html" )) 4. マルチスレッディング 異なるURLから何度もデータを取得する場合、一つ一つ順番に処理を行う方法もありますが、効率を考えるとマルチスレッディングを使用することがより効果的です。マルチスレッディングを使うことで、複数の処理を並行して実行できるため、全体の処理時間を大幅に短縮することが可能になります。 例えば、Wikipediaの複数のオリンピックの記事から、それぞれの参加人数の情報を取得したい場合、以下のようなコードで取得することができます。まずはオリンピック記事から参加人数を抽出する関数を用意します。 def find_participants (url): driver = webdriver.Chrome(service=Service()) driver.get(url) for i in range ( 1 , 2 + 1 ): # テーブル番号は1か2のどちらか for j in range ( 6 , 7 + 1 ): # 行番号は6から7のどちらか try : element = driver.find_element( 'xpath' , f '//*[@id="mw-content-text"]/div[1]/table[{i}]/tbody/tr[{j}]/th' ) if element.text == '参加人数' : # 参加人数の行を見つけたら、隣の列のテキストを返す participants = driver.find_element( 'xpath' , f '//*[@id="mw-content-text"]/div[1]/table[{i}]/tbody/tr[{j}]/td' ).text driver.quit() return participants except : continue return '見つかりませんでした' 以下のコードで情報を順番に取得します。 titles = [ '2020年東京オリンピック' , '2016年リオデジャネイロオリンピック' , '2012年ロンドンオリンピック' , '2008年北京オリンピック' ] participants = {} start_time = time.time() for title in titles: participants[title] = find_participants(driver, f 'https://ja.wikipedia.org/wiki/{title}' ) print (f '経過時間: {time.time() - start_time:.2f} 秒' ) print (participants) ただし、それぞれの記事へのアクセスは独立しているので、それぞれのデータを並行して取得するようにします。 from multiprocessing.pool import ThreadPool start_time = time.time() titles = [ '2020年東京オリンピック' , '2016年リオデジャネイロオリンピック' , '2012年ロンドンオリンピック' , '2008年北京オリンピック' ] participants = {} pool = ThreadPool(processes= len (titles)) # 同時に実行するスレッド数を指定 threads = [] # スレッドとタイトルの対応を保存するリスト for title in titles: t = pool.apply_async(find_participants, (f 'https://ja.wikipedia.org/wiki/{title}' ,)) threads.append((title, t)) pool.close() # プールを閉じる。これ以降新しいスレッドは作成しない pool.join() # 全てのスレッドが終了するまで待つ for title, thread in threads: try : participants[title] = thread.get() # コールの結果を取得 except Exception as e: print (f 'エラー: {e}' ) print (f '経過時間: {time.time() - start_time:.2f} 秒' ) print (participants) 私の実験環境で順番に処理すると処理が約30秒かかり、マルチスレッディングだと10秒以内に終了します。 ご覧の通り、節約できる実行時間がとても大きいです。取得する情報が多ければ多いほど、このようなアプローチがもっと大事になってきます。並行して実行するブラウザが多ければ多いほどメモリも使いますのでそれとの兼ね合いで調整する必要があります。 おまけ: Selenium + Kaggle API 最後に、SeleniumとKaggle APIを組み合わせて、自動的にデータセットをKaggleにアップロード（更新）する方法について説明します。下記で習うことを活かして、記者がオンラインボードゲームサイトのSquadroというゲームの各々のプレイの情報をスクレイピング経由で収集してデータセットとしてKaggleにアップロードしています。Kaggleは、データサイエンスと機械学習のコミュニティで広く使用されており、自分のデータセットを公開して他の研究者と共有することが可能です。 ※ データセットを作成する場合、手動で初回のアップロードを行なってください。こちらで見せるコードはデータセットの自動更新用のコードです。 1. 前提条件 Kaggleアカウントが必要です。まだお持ちでない場合は、 Kaggle でアカウントを作成してください。 Kaggle APIのトークンを取得します。Kaggleのアカウント設定ページから「Create New API Token」をクリックしてダウンロードします。ダウンロードした kaggle.json ファイルは、安全な場所に保存してください。 2. Kaggle APIの準備 Kaggle APIを使用するためには、まず kaggle パッケージをインストールする必要があります。 pip install kaggle 次に、ダウンロードした kaggle.json ファイルを、Kaggle APIの設定ファイルが読み込まれるディレクトリに配置します。通常、このディレクトリは ~/.kaggle です（LinuxおよびMacOSの場合）。Windowsの場合は、 C:\Users\<Windows-username>\.kaggle\ になります。 mkdir ~/.kaggle cp path/to/kaggle.json ~/.kaggle/kaggle.json chmod 600 ~/.kaggle/kaggle.json 3. SeleniumとKaggle APIの組み合わせ Seleniumを使ってスクレイピングを行います。毎日更新される情報を集めるのに便利です。スクレイピングしたデータを dataset_path 配下に保存します。 # スクレイピング df = scraping_call() # 適当にデータを収集する関数 # データ保存 dataset_path = '/path/to/your/dataset' # データセットのローカルディレクトリを指定 dataset_name = 'my_data.csv' # データファイル名 df.to_csv(f '{dataset_path}/{dataset_name}' ) # 保存関数 Kaggle APIを呼び出すのに必要なライブラリをインポートします。そして、Kaggle APIに認証します。 from kaggle.api.kaggle_api_extended import KaggleApi api = KaggleApi() api.authenticate() Kaggle APIを使用して、データセットをアップロード（更新）します。 # データセットの新しいバージョンを作成 api.dataset_create_version(folder=f '{dataset_path}/' , version_notes= "メモ" ) このプロセスを使用することで、データセットの管理と更新を効率的に行うことができます。Seleniumを介して追加のWeb操作を自動化することと組み合わせることで、完全に自動化されたデータアップロードのワークフローを構築することが可能です。 重要なのは、自動化プロセスを利用する際にスクレイピングの倫理的な実装を行うこととKaggleの利用規約に違反しないようにすることです。 4. 活用例: Squadroのプレイ歴収集 このセクションの冒頭で述べた通り、上記を実装し、記者が Squadro というボードゲームの デジタル版 でプレイされるゲームの情報を2日に1回ぐらい集めて自動的に こちらのデータセット を更新しています。更に、そのデータセットを自動でダウンロードし、読み込んでデータを可視化する Streamlitアプリ も開発しました。 まとめ この記事では、スクレイピングの基本から応用まで幅広くカバーしました。スクレイピングは、Webサイトからデータを抽出するための強力な技術であり、研究、マーケティング分析、競合他社の価格監視など様々な用途で利用されています。しかし、スクレイピングを行う際には、Webサイトの利用規約に違反しないよう注意し、サーバーへの負荷を最小限に抑える必要があります。 スクレイピングは、適切に行えばデータ収集の効率を大幅に向上させることができますが、技術的な面だけでなく、倫理的な観点からも慎重に取り組む必要があることを忘れてはいけません。皆さんも是非良いスクレイピングを実装してみてください！

目次 はじめに クリーンアーキテクチャとは 例として考えるアプリケーション 生成AIアプリにおける難しさ 実際に作ってみる 実装を差し替えてみる まとめ はじめに こんにちは、InsightEdgeの開発チームに参画させていただいています伊藤です。 InsightEdgeでは現在、LLM/生成AIを用いたアプリ開発を多く手掛けています。 私もOpenAI等の生成AIを使ったアプリケーションの実装に関わることが増えてきており、 ある程度理解が進んできたところで、改めてアーキテクチャを洗練させたいと思うようになりました。 この記事では生成AIを組み込んだアプリを構築する際の、クリーンアーキテクチャを考えていきたいと思います。 クリーンアーキテクチャとは まずは、クリーンアーキテクチャについて軽く振り返りましょう。 クリーンアーキテクチャではソフトウェアの理解・開発・デプロイ・運用・保守を容易にするために、フレームワークやDB・UI・外部サービスなどへの依存を最小にします。 この時の下記のような多層構造に分割し、それぞれの層に役割に合わせたクラスを配置していきます。 The Clean Architecture より抜粋 ここで登場する層はそれぞれ下記のような役割を持っています Entities この層にはビジネスルールやビジネス上の概念を表すクラスを格納します。 ドメイン駆動開発(DDD)やオニオンアーキテクチャ的にいうとドメインモデル/ドメインサービスのレイヤに該当します。 Use Cases アプリケーション固有のビジネスが含まれます。 Use Case層のクラスはEntity層のクラスを使ってアプリケーションの処理フローを実行します。 Controllers/Presenters Controllerは入力をUse Caseに合わせた形に変換した上で、Use Caseを実行します。 PresenterはUse CaseがUIへの出力をする時に呼び出されるクラスになります。 Gateways GatewayはEntity層/Use Case層で扱うクラスをDBや外部サービスに合わせた形に変換し、永続化やAPIコールなどを行います。 その外側 DBそのものやUI、外部のサービスなどはすべてControler/Presenter/Gatewayを通じてやり取りするものになります。 これらの各層に含まれるコードは、必ずより内側の層のコードだけに依存するようにすることで、 サービス/ビジネスの本質的なロジック部分を表現するコードが、フレームワークやUIといった部分の変更に 影響を受けないように構成します。 詳細についてはオリジナルのWebサイトや書籍のほか、いろいろが出ていますのでここでは割愛します。 参考 The Clean Architecture 書籍：Clean Architecture 達人に学ぶソフトウェアの構造と設計 例として考えるアプリケーション アーキテクチャを考える上での想定アプリケーションとして、ここではRAGを加えたChatGPTのようなアプリケーションを作るものとします。 ユーザはブラウザでアクセスする 自然言語で質問を入力すると、自然言語で回答が表示される 回答作成時には、それまでのやり取りなどの文脈が考慮される 回答作成時には、あらかじめシステムに登録しておいた関連情報が加味される 回答は生成完了してから一度に表示されるのではなく、生成された文字から逐次表示される 生成AIアプリにおける難しさ 前述のようなアプリをクリーンアーキテクチャで作成しようとした際に、特に下記の点は検討が必要でした。 どの要素がEntityになるのか ストリーミング形式のアウトプットはクリーンアーキテクチャで実現できるのか それぞれ、どんな課題に対して、どのように考えていったのかを説明していきたいと思います。 どの要素がEntityになるのか 論点 クリーンアーキテクチャのEntity層にはアプリの核となるビジネスロジックが置かれます。 一方で生成AIアプリ開発の中心となるのは、どうやってGPT等の生成AIに望むクオリティのアウトプットを生成してもらうかだと思います。 しかし、生成AIそのものはAPI経由で呼び出すのでアプリ外にあり、これはクリーンアーキテクチャで言うところのGatewayの先の部分のはずです。 では、どんな部分をEntityとして依存関係の中心に置くべきなのでしょうか。 考え方 今回想定しているアプリが提供する機能は「質問を受けて、今の文脈に合わせて、関連情報を使って、回答を生成する」です。 ここから考えるとEntityとして表現するべき概念は 質問 ・ 文脈 ・ 関連情報 ・ 回答 であるはずです。 ここにはプロンプトなどの生成AI的な要素は出てきませんが、そもそもAIは実装/実現手段の詳細なので、 適切な回答を返してくれるのであれば、背後にあるのはGPTでもGeminiでも、ただのデータベースでも良いということです。 これまで開発のたびに色々と工夫してきたプロンプトは本質的な部分ではないのかと一瞬ショックを受けましたが よく考えるとパフォーマンス重視のサービスでSQL部分のチューニングをしているようなものですね。 どんなにチューニングが大切なアプリであってもSQLそのものがアーキの中心とはならない、というのと同じです。 ストリーミング形式のアウトプットはクリーンアーキテクチャで実現できるのか 論点 GPTを使ったアプリケーションでは、UX向上のためにGPTからの回答を逐次画面に表示するUIが一般的だと思います。 これを行うためにはアプリのフロントエンドとバックエンドがHTTPストリーミングのような形で通信しなければなりません。 このとき、GPTの出力からアプリのフロントエンドまでの間の、 回答 に関連するすべてのクラスがストリーミング形式のデータに対応できている必要があります。 しかし、UIがストリーミング出力だからといって、そこに合わせてUse Case層の仕様を変更することはクリーンアーキテクチャの重視している依存関係が逆転してしまっている気がします。 クリーンアーキテクチャの考え方に沿ったままストリーミング型のUIに対応するにはどうしたらよいのでしょうか。 考え方 上記について考えている中で、自分の捉え方に思い込みがあることに気づきました。 変数の値が決まってから返却するのが「普通」で、ストリーミング出力は「UIに合わせた特殊な形」だと考えていたのです。 pythonは言語自体にGeneratorやPromise等の「後で値が決まる仕様」の型を持っています。 使うプログラミング言語で表現できるのであれば 回答 を「逐次生成されるもの」として定義してしまってもよいのではないでしょうか。 回答 という概念が、そもそも逐次生成される性質を持っている、という捉え方です。 今回は回答(Answer)というEntityをGeneratorの一種として定義しました。 Answer: TypeAlias = Generator[ str , None , None ] この書き方もEntityを Generator[str, None, None] 型なんかにしてしまってよいのかという違和感があったのですが、 list[str] 等で表現するのと違いはないはず、と思い納得することにしました。 回答 の持つ性質をコードとして表現した時に、たまたま Generator という型が一番適切だったのだと解釈します。 実際に作ってみる 上記を踏まえ、実装をしてみます。 Entity・Use Case・Gateway・Controller/Presenterそれぞれを見ていきましょう。 全体の構成は以下のようになっています。 ドメイン駆動開発(DDD)をする場合だと domain や repository といった表現の方がよく使われるかもしれませんが、 今回はクリーンアーキテクチャとの対応がわかりやすいように entity や gateway といった表現に統一しています。 src ├── entity: エンティティ層 │   ├── answer: 回答モデル │   ├── context: 文脈モデル │   ├── knowledge: 背景知識モデル │   └── question: 質問モデル ├── usecase: ユースケース層 │   ├── knowledge: 背景知識モデル │ └── chat: 質問回答ユースケース ├── adapter: アダプタ層 │   ├── controller: Use Caseを起動するためのController実装 │   ├── gateway: 各種Gateway/Repositoryの実装 │   │   ├── answer: AnswerGateway実装 │   │   ├── context: ContextGateway実装 │   │   └── knowledge: KnowledgeGateway実装 │   └── presenter: 出力をハンドリングするPresenter実装 └── main_*.py: 起動のためのエントリポイント Entity定義 まずコアとなるEntitiy層には、前述した下記の4要素と、その取得を担当するGatewayの抽象クラスを作成します。 質問(Question) 文脈(Context) 背景知識(Knowledge) 回答(Answer) 質問(Question)関連 question.py Question: TypeAlias = str """ 質問文を表す型。ただの文字列 """ 文脈(Context)関連 context.py ContextId: TypeAlias = int """ これまで文脈を取得するためのキーにする値を表す型。今回は整数として定義する。 実際はユーザやセッションに関する値をキーする想定。 """ Context: TypeAlias = str """ 文脈を表す型。今回はただの文字列として定義する。 実際は過去の会話の履歴などを含むことが考えられる。 "" context_gateway.py class ContextGateway (metaclass=ABCMeta): """文脈(Context)を取得するためのGateway""" @ abstractmethod def get_context (self, context_id: ContextId) -> Context: """ContextIdに基づくContextを取得する""" pass 背景知識(Knowledge)関連 knowledge.py Knowledge: TypeAlias = str """ 背景知識１つを表す型。今回はただの文字列として定義する。 実際は参照先や、関連度のスコアなどを含むクラスにすることが考えられる。 """ Knowledges: TypeAlias = list [Knowledge] """ 複数の背景知識を表す型 """ knowledge_gateway.py class KnowledgeGateway (metaclass=ABCMeta): """背景知識(Knowledge)を取得するためのGateway""" @ abstractmethod def find_knowledges (self, question: Question) -> Knowledges: """Questionに関連する背景知識(Knowledge)を取得する""" pass 回答(Answer)関連 answer.py Answer: TypeAlias = Generator[ str , None , None ] """ 回答を表す型。文字列が逐次生成されるものとして定義する。 """ answer_gateway.py class AnswerGateway (metaclass=ABCMeta): """回答(Answer)を取得するためのGateway""" @ abstractmethod def get_answer ( self, question: Question, context: Context, knowledges: Knowledges ) -> Answer: """Question/Context/Knowledgeに基づくAnswerを取得する""" pass Gateway実装 (ダミー版) まずは動作確認するためにダミー版のGateway実装を作成します。 それぞれ固定値を返すようになっています。 今回は以下の例でダミー文を作成しました。 文脈: 「組織のデータを活用するためのOpenAIアプリの開発で困っている」 背景知識： 「InsightEdge社はOpenAIを使ったアプリ開発ができる」 「InsightEdge社にはデータサイエンスの専門家がいる」 回答: 「InsightEdgeを検討してみてはいかがでしょうか？」 dummy_context_gateway.py class DummyContextGateway (ContextGateway): """ ダミーの文脈情報を返すContextGateway """ def get_context (self, context_id: ContextId) -> str : return Context( "組織のデータを活用するためのOpenAIアプリの開発で困っている" ) dummy_knowledge_gateway.py class DummyKnowledgeGateway (KnowledgeGateway): """ ダミーの背景知識を返すKnowledgeGatway """ def find_knowledges (self, question: Question) -> Knowledges: return [ Knowledge( "InsightEdge社はOpenAIを使ったアプリ開発ができる" ), Knowledge( "InsightEdge社にはデータサイエンスの専門家がいる" ), ] dummy_answer_gateway.py class DummyAnswerGateway (AnswerGateway): """ ダミーの回答を返すAnswerGateway """ def get_answer ( self, question: Question, context: Context, knowledges: Knowledges ) -> Generator[ str , None , None ]: yield f "「{context}」という文脈において、 \n " sleep( 1 ) yield f "「{question}」という質問に対して、 \n " sleep( 1 ) for knowledge in knowledges: yield f "「{knowledge}」" sleep( 1 ) yield "という背景知識をもとに、 \n " sleep( 1 ) yield "ダミーの回答をします。 \n " sleep( 1 ) yield "InsightEdgeを検討してみてはいかがでしょうか？ \n " get_answer() の戻り値は Generator である Answer として親クラスで定義されていますが、こちらの実装は str 型を yield することで定義を満たしています。 なお、今回はストリーミングの動きがわかるように sleep() を挟んでいます。 Use Case/Port実装 続いて、Use Case層を作ります。 ここではEntityを使用してアプリとしての処理フローを定義するUse Caseと、 その出力の仕方を定義するOutputPortを作成します。 後ほど出てくるControllerはこのUse Caseを呼び出す形となり、 PresenterはOutputPortを継承したクラスとして、Use Case層の定義に従って実装することになります。 これはクリーンアーキテクチャの図では右下の部分で表現されている部分となります。 図ではUseCaseの親となるInput Portも記載されていますが、今回は省略します。 図に厳密に従ってUse Case Input Portを作成しControllerからの依存がそちらに向かう構造にすることで、 Use Caseの変更をした場合にControllerに影響しにくくできますが、 把握しておくクラス/依存関係を減らすことの方がメリットが高いと考えており 自分の場合はInput Portは作らない、という選択をすることが多いです。 では、実装の中身です。 まずは「質問を受けて回答を生成する」というユースケースを実現するためのクラスを作ります。 chat_usecase.py class ChatUsecase : """ 質問に対する回答を返すユースケース """ def __init__ ( self, context_gateway: ContextGateway, knowledge_gateway: KnowledgeGateway, answer_generator: AnswerGateway, ) -> None : """ 使用するGatewayをセットする """ self.context_gateway = context_gateway self.knowledge_gateway = knowledge_gateway self.answer_generator = answer_generator def execute ( self, question: Question, context_id: ContextId, output_port: ChatUsecaseOutputPort, ) -> None : """ ユースケースを実行する """ # 文脈を把握する context: Context = self.context_gateway.get_context(context_id) # 背景知識を取得する knowledges: Knowledges = self.knowledge_gateway.find_knowledges(question) # 回答を作成する answer = self.answer_generator.get_answer(question, context, knowledges) # 回答を出力する output_port.emit(answer) そしてUse Caseのアウトプットを受け取るOutput Portを定義します。 このOutputPortを実装したPresenterであれば、アウトプットの仕方はなんでも良いということになります。 chat_usecase_output_port.py class ChatUsecaseOutputPort (metaclass=ABCMeta): """ ChatUsecaseの出力口の定義""" @ abstractmethod def emit (self, answer: Answer) -> None : """Answerを出力用に受け取る""" pass Presenter/Controller（コマンドライン実行用） 最後にPresenterとControllerを作成します。 まずはシンプルにコマンドラインで呼び出す想定で作ってみます。 Controllerは標準入力から質問を受け付け、Entityである Question 型に変換してから、ユースケースを起動します。 cli_chat_controller.py class CliChatController : # CLI上で質問を受け取り、ユースケースを実行するコントローラ def __init__ (self, usecase: ChatUsecase, presenter: ChatUsecaseOutputPort): # 実行するユースケース self.usecase = usecase # ユースケースのOutputPortの実装 self.presenter = presenter def handle (self): # コンテクストIDを取得する（今回はサンプルなので固定） contextId = 1 # 質問文を受け取る question_str = input ( "質問を入力してください: " ) question: Question = Question(question_str) # ユースケースを実行する self.usecase.execute(question, contextId, self.presenter) # 出力はPresenterが担当するので、ここでは何もしない 続いてPresenterを作ります。 CLIでの操作を想定し標準出力への表示をするものを用意します。 ChatUsecaseOutputPort の実装(の1つ)になります。 stdout_chat_presenter.py class StdoutChatPresenter (ChatUsecaseOutputPort): """標準出力にAnswerを出力するPresenter""" def emit (self, answer: str ) -> None : """Answerを出力用に受け取る""" # Answerの内容を逐次出力する for answer_chunk in answer: sys.stdout.write(answer_chunk) sys.stdout.flush() 実行 さてここまでの実装を繋げて動かしてみます。 エントリポイント エントリポイントとして、手動でDependency Injection(以下DI)した上で、コントローラを呼び出す処理を作ります。 main_cli.py """ CLI上で実行するためのエントリーポイント """ # DI済みのUse Caseを作成する context_gateway = DummyContextGateway() knowledge_gateway = DummyKnowledgeGateway() answer_gateway = DummyAnswerGateway() usecase = ChatUsecase(context_gateway, knowledge_gateway, answer_gateway) # DI済みのコントローラを作成する presenter = StdoutChatPresenter() controller = CliChatController(usecase, presenter) # コントローラを呼び出す controller.handle() 実行結果 上記のエントリポイントからアプリを動かすとこのようになります。 DummyAnswerGateway によって生成された結果が、標準出力に逐次出力されています。 さて、これでアプリの全体像は完成しました。 いわゆる生成AIアプリであっても、アーキテクチャの観点ではAIそのものからは切り離されているということが改めて確認できたと思います。 実装を差し替えてみる ここからはGateway/Controller/Presenterの「詳細」を変えていきましょう。 クリーンアーキテクチャを目指したことで変更に強いものになっているでしょうか。 AnswerGatewayをOpenAI利用版にしてみる まずは回答の生成を実際にAzure OpenAIを使って行うようにしてみます。 DummyAnswerGateway を置き換えるための別クラスを作ります。 親クラスは AnswerGateway です。 openai_answer_gateway.py class OpenAIAnswerGateway (AnswerGateway): """ OpenAIを用いて回答を生成するAnswerGateway""" def __init__ (self): api_key = os.getenv( "AZURE_OPENAI_API_KEY" , "" ) api_base = os.getenv( "AZURE_OPENAI_API_BASE" , "" ) api_version = os.getenv( "AZURE_OPENAI_API_VERSION" , "" ) self.deployment_name = os.getenv( "AZURE_OPENAI_DEPLOYMENT_NAME" , "" ) # AzureOpenAIクライアントを用意する self.client = AzureOpenAI( api_key=api_key, api_version=api_version, azure_endpoint=api_base, ) def get_answer ( self, question: Question, context: Context, knowledges: Knowledges ) -> Answer: # OpenAIに質問を投げて回答を取得する response = self.client.chat.completions.create( model=self.deployment_name, messages=[ { "role" : "user" , "content" : [ { "type" : "text" , "text" : f "{context}という文脈において、" + f "{knowledges}という背景知識をもとに、" + f "{question}という質問に対して回答してください。" , } ], }, ], stream= True , ) # OpenAIからの回答を逐次返す for chunk in response: choices = chunk.choices if choices and choices[ 0 ].delta and choices[ 0 ].delta.content is not None : yield str (chunk.choices[ 0 ].delta.content) # strをyieldすることで、Answer型つまりGenerator[str, None, None]型を満たす こちらの get_answer() も DummyAnswerGateway の時と同じく str 型を yield しているので、戻り値の型 Answer 型に合致しています。 エントリーポイント エントリーポイントは、 先ほどのCLI入力/表示用の実装から、 DummyAnswerGateway の代わりに上記の OpenAIAnswerGateway を使って実行するよう、DIしている1行だけを変更します。 今回は簡易化のため ContextGateway と KnowledgeGateway はダミーのままとします。 実際にRAGを行う場合は KnowledgeGateway の部分にEmbeddingやVectorStoreを実装することになると思います。 main_cli_openai.py """ CLI上で実行するためのエントリーポイント """ # DI済みのUseCaseを作成する context_gateway = DummyContextGateway() knowledge_gateway = DummyKnowledgeGateway() answer_gateway = OpenAIAnswerGateway() # <= OpenAIAnswerGatewayを使う usecase = ChatUsecase(context_gateway, knowledge_gateway, answer_gateway) # DI済みのコントローラを作成する presenter = StdoutChatPresenter() controller = CliChatController(usecase, presenter) # コントローラを呼び出す controller.handle() 実行結果 上記のエントリポイントから実行してみます。 はい、これだけで実際にAzure OpenAIを組み込んだアプリに変わりました。 以下のポイントのおかげで修正箇所が非常に限定されています。 各Gatewayの実装はEntity層で定義した抽象Gatewayに従うようになっている Use Caseも抽象のGatewayの定義に依存している 実際にどの実装を使うかはDIによって決まる Presenter/ControllerをHTTPストリーム版にしてみる 次はControllerとPresenterを差し替えて、APIとして動作する形にしてみましょう。 ControllerはFastAPIを使ってHTTPリクエストを受け取るものを作成します。 http_chat_controller.py class HttpChatController : # Httpリクエストで質問を受け取り、ユースケースを実行するコントローラ def __init__ (self, usecase: ChatUsecase, presenter: AbstractHttpChatPresenter): # 実行するユースケース self.usecase = usecase # ユースケースのOutputPortの実装 self.presenter = presenter # FastAPIのルーター設定 self.router = APIRouter() self.router.add_api_route( "/{context_id}" , self.handle, methods=[ "GET" ]) def handle (self, context_id: int , q: str ) -> Response: # 質問文を取得する question = Question(q) # ユースケースを実行する self.usecase.execute(question, context_id, self.presenter) # レスポンスを返す return self.presenter.get_response() CliChatController とほぼ一緒ですね。 Presenterとしては ChatUsecaseOutputPort を継承しつつ Response の形で取り出すための get_response() を持たせたいので、 その点を表現した抽象クラスをもう一段階挟みます。 class AbstractHttpChatPresenter (ChatUsecaseOutputPort): """HTTP経由でAnswerを出力するPresenterの抽象クラス""" @ abstractmethod def emit (self, answer: Answer) -> None : """Answerを出力用に受け取る""" pass @ abstractmethod def get_response (self) -> Response: """HTTPレスポンスの形で回答を返す""" pass Presenterの実装は emit() で設定された Answer を HttpStream で返却するものを用意します。 http_stream_chat_presenter.py class HttpStreamChatPresenter (AbstractHttpChatPresenter): """HTTPストリーミングでAnswerを出力するPresenter""" def emit (self, answer: Answer) -> None : """Answerを出力用に受け取る""" self.answer = answer def get_response (self) -> Response: """HTTPストリームの形で回答を返す""" response = StreamingResponse(self.answer, media_type= "text/event-stream" ) return response こちらはFastAPIの定義する StreamingResponse を使っています。 Entity層で定義した Answer が Generator 型なので、簡単にストリーミング対応ができます。 エントリーポイント 上記のControllerをFastAPIで実行するようなエントリポイントを用意します。 変更箇所は、Controler/Presenterの差し替えとサーバの起動処理の追加です。 main_http_openai.py """ Httpサーバ上で実行するためのエントリーポイント """ # DI済みのUseCaseを作成する context_gateway = DummyContextGateway() knowledge_gateway = DummyKnowledgeGateway() answer_gateway = OpenAIAnswerGateway() # OpenAIを使って回答を行うAnswerGateway usecase = ChatUsecase(context_gateway, knowledge_gateway, answer_gateway) # DI済みのコントローラを作成する presenter = HttpStreamChatPresenter() controller = HttpChatController(usecase, presenter) # コントローラをサーバ上で呼び出し待ち状態にする app = FastAPI() app.include_router(controller.router) uvicorn.run(app, host= "127.0.0.1" , port= 8000 ) 実行結果 上記を起動した上で、ブラウザでアクセスしてみます。 無事にAPI化もできました。 アプリの処理そのものはUse Case層がEntity層のクラスを用いて行う Controller/PresenterはUse Case層のクラスに従う この2点のおかげで、入出力をCLIからHTTP形式の変更する際に、Use Case層/Entity層に影響を与えることなく行えています。 ストリーミングではないHTTPレスポンスにしたい場合はどうするのか ここまでは内部のEntityも出力のPresenterも回答を逐次処理するようにしていました。 では「やっぱりストリーミングではなく一度のHTTPレスポンスで回答を返却したくなった」という場合はどのような影響があるでしょうか。 出力形式が変わるので、新たにPresenterを用意します。 HTTP Responseを返す get_response() を持っていて欲しいので、 AbstractHttpChatPresenter の子クラスとして作成します。 http_response_chat_presenter.py class HttpResponseChatPresenter (AbstractHttpChatPresenter): """HTTPレスポンスでAnswerを出力するPresenter""" def emit (self, answer: Answer) -> None : """Answerを出力用に受け取る""" self.answer = answer def get_response (self) -> Response: """HTTPレスポンスの形で回答を返す""" result = "" for chunk in self.answer: result += chunk print (result) response = Response(content=result, media_type= "text/plain" ) return response Entity層の Answer は Generater 型のまま、生成される回答をすべてPresenter内で受け取ったあとに1回のHTTPレスポンスを返すようにしています。 エントリーポイント 呼び出しはHTTP経由で変わらないので、 HttpChatController のまま、PresenterだけDIで変更します。 """ Httpサーバ上で実行するためのエントリーポイント """ # DI済みのUseCaseを作成する context_gateway = DummyContextGateway() knowledge_gateway = DummyKnowledgeGateway() answer_gateway = OpenAIAnswerGateway() usecase = ChatUsecase(context_gateway, knowledge_gateway, answer_gateway) # DI済みのコントローラを作成する presenter = HttpResponseChatPresenter() # <= 通常レスポンスを返すPresenterに変更 controller = HttpChatController(usecase, presenter) # コントローラをサーバ上で呼び出し待ち状態にする app = FastAPI() app.include_router(controller.router) uvicorn.run(app, host= "127.0.0.1" , port= 8000 ) これでストリーミングではなく、一括で回答が返却される形になりました。 Entityである Answer が Generater として定義されていても、Presenterが適切に処理することで 外からはただの str であるかのように表示に使うことができます。 余談 今回は実施しませんでしたが、バッチ処理で回答を生成して何かに格納したい場合も、 バッチ処理用のControllerとPresenterを用意することで対応できるはずです。 ただしその場合には、Use Caseとして表現するべきものが本当にユーザ操作とバッチ処理で同じなのかを検討する必要があります。 まとめ 今回は生成AIアプリの内部をクリーンアーキテクチャで構成する方法について検討しました。 生成AIを使ったアプリであっても、クリーンアーキテクチャの考え方に沿って層を分け、 アプリが扱う要素/概念を生成AI自体の使い方と切り離して捉えて抽象化し、 依存関係が一方向に向かうように構成することで 回答生成方法の変更 アプリ起動方法の変更 出力形式の変更 などを、影響範囲を最小にした上で実施できることが確認できました。 また 回答(Answer) を Generator としての性質を持ったものとしてモデル化するという工夫をすることで、 生成AIアプリケーションでよく使う逐次表示形式と、Request/Response形式の両方の出力に対応できることが分かりました。 感想 今回クリーンアーキテクチャを目指す設計をしたことで 生成AIアプリケーションについて自分が持っていたメンタルモデルが、よりシンプルなものに更新されたと感じます。 新たにアプリを作るときよりも、既存のアプリの方が概念やフローが分かっていて検討しやすいと思いますので 既存のアプリについてクリーンアーキテクチャで作ったらこうなるのでは、というのを一度考えてみるのも面白いかもしれません。