こんにちは！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アプリケーションについて自分が持っていたメンタルモデルが、よりシンプルなものに更新されたと感じます。 新たにアプリを作るときよりも、既存のアプリの方が概念やフローが分かっていて検討しやすいと思いますので 既存のアプリについてクリーンアーキテクチャで作ったらこうなるのでは、というのを一度考えてみるのも面白いかもしれません。

はじめに 実施背景 概要 事例展示 トークセッション 相談窓口 その他 当日の様子 最後に はじめに こんにちは！ 昨年10月にInsight Edgeへコンサルタントとして参画した、楠です。 今回は、2月21日(水)に実施いたしましたInsight Edge初のオフラインイベントについてご報告いたします。 是非最後までお読みいただけますと幸いです。 実施背景 Insight Edgeは、2019年7月の設立以来、アジャイル開発・データ分析・AIモデル開発を内製エンジニアで実現する組織として、住友商事及び住友商事グループの事業会社の事業価値向上に寄与するべく、数々のDX案件に取り組んできました。 この度、間もなく設立5年を迎えるというタイミングで、これまでの足跡やInsight EdgeのCapabilityについて紹介し、課題解決のヒントを得ていただくためのオフラインイベントを企画・実施しました。 イベントの実施概要は以下の通りです。 開催日時： 2024年2月21日（水）11:00-17:30 場所： MIRAI LAB PALETTE HUB 対象：住友商事及び住友商事グループ事業会社 全役職員 MIRAI LAB PALETTE HUBを貸し切って実施しました。 イベントのキービジュアル。住友商事グループの「Digital Level UP」をテーマとしました。 概要 イベントでは、大きく以下3つのコンテンツを企画・実施しました。 事例展示 Insight Edgeが過去に取り組んだ案件のうち9つの案件について、売上向上・業務高度化といった多様な現場課題に対するDXソリューションを分かりやすく展示しました。 各案件の説明は実際に案件を担当したエンジニアが行い、いくつかの案件については実際に触っていただけるデモアプリも紹介し、来場者に臨場感をもって体感頂きました。 トークセッション 弊社CEO小坂らで住友商事グループ内外のDXについて語るオープニングセッションを皮切りに、4つのトークセッションを実施しました。 内2つのセッションでは、住友商事のユーザ部署やグループ事業会社の担当者にも登壇いただき、実際のエピソードを交えて、生成AI活用やDX内製力強化等のInsight Edgeとの協業案件について振り返っていただきました。 それ以外にも、データ活用のよくある事例や相談について弊社データサイエンティストのリーダー陣が語るセッションも実施しました。 相談窓口 DX 推進に必要なAIやデータ分析、開発など、様々な課題に関して気軽に相談可能な窓口を設置しました。 その他 Insight Edgeのロゴやイベントキービジュアルをあしらったノベルティや、美味しいドーナツで来場してくださった方々をおもてなしました！ ノベルティのボールペン。Insight Edgeとして初めて作成しました。 ご来場者全員にイベントのキービジュアルを掲載したチョコレートを配布しました。 ご来場者向けにはドーナツやコーヒーを準備しました。 当日の様子 当日は合計で約200人の方にご来場いただき、DXに関する関心の高さを伺うことができました。また、トークセッションについても、用意したスペースがほぼ満席となったほか、会場質問も多数いただくことができ、非常に盛況となりました。 特にオープニングセッションでは、弊社CEOの小坂からInsight Edgeの位置づけやイベントの目的についてご説明した後、マネージャーの猪子・森から「内製化集団が果たす役割」や「技術進展を取り込むこと・技術のリスクを見極め正しく使うことの重要性」についてプレゼンを行いました。会場からはDXの推進方法や運用方法のノウハウ、弊社の取り組みが住友商事グループのDXに及ぼした影響など様々な質問が飛び交い、来場者の高い温度感や具体的な課題感をイベント開始すぐに感じられました。 会場にPCを配置し、ご来場者にデモ機を触っていただきました。 事例展示スペースの様子。（写真を一部加工しています。） オープニングセッションには弊社CEOの小坂も登壇しました。 最後に Insight Edgeは、「技術の力で世界をRe-Designする」をMissionとして、今後も住友商事グループのDX推進を加速して参ります。各職種について採用を強化しておりますので、是非 採用ページ もご覧ください！（2025年度については新卒採用も実施予定です。） ここまでお読みいただき、ありがとうございました！

はじめに こんにちは！昨年9月からInsight Edgeの開発チームに参画した広松です。Insight Edgeでは生成AI案件を担当しています。 参画してからまだ間もないですが、技術選定や顧客との調整を含む多くの業務を裁量を持って自由にできるところが良いと感じています。また、Insight Edgeでは業務時間の10%を勉強会などの自己啓発に充てることが奨励されています。この文化のおかげで、LangChainの勉強会を運営したりTech Blogに記事を寄稿したりと、いろいろな事に挑戦できてとても良い環境だなと感じています。 さて、最近私が担当する案件で、 生成AIに定性的な分析だけでなく定量的な分析もさせたい という要望がありました。そこで今回は、生成AIにデータ分析をさせる手法を検証してみました。具体的には、生成AIのAgentにKaggleのチュートリアルとして有名なタイタニック号の乗客のデータセットを分析させ、分析結果を評価したので紹介しようと思います。 目次 はじめに 目次 概要 ※補足 案件で構築するシステムの概要 事前知識 自律エージェントとは ReAct(Reasoning and Acting)とは LangChainとは ※補足 Code InterpreterではなくAgentで実装する理由 技術選定 LangChainのAgent関連のコンポーネントについて 選定理由 事前準備 実装内容 実行結果 考察 分析結果 分析過程 Agentによる自律的なエラー解決 まとめ 検証結果 Code Interpreterとの比較 今後に向けて 感想 概要 私が担当している案件で、生成AIに定量的な分析をさせたいという要望がありました。しかし、生成AIは 確率的にデータを生成するため、数学のような論理的思考や数値計算が苦手 です。 そこでどのように生成AIにデータ分析をさせるのか技術調査をしました。生成AIに計算やデータ分析をさせる場合、 Agent を使ってPythonのコードを生成・実行させる手法 が一般的です。 今回は、生成AIのAgentにKaggleのチュートリアルとして有名なタイタニック号の乗客のデータセットを分析させ、分析結果を評価しました。 ※補足 案件で構築するシステムの概要 今回の検証とはあまり関係がないので、興味が無い方は読み飛ばしてください。 分析テーマの入力 : ユーザが分析したいテーマを入力 定性的な分析の実施 : 生成AIが入力されたテーマに関連する情報をElastic Searchのハイブリッド検索機能を用いたRAGで収集し、その情報に基づいて定性的な分析を実施 定量的な分析の実施 : 生成AIのAgentが定性的な分析結果を元に社内データの分析をすることで定量的な分析も実施（※ここが今回の技術検証に関連する部分です。） 最終的なレポートの生成 : システムが 定性的と定量的な視点を融合させた 最終的な分析レポートを生成 事前知識 自律エージェント、ReAct、LangChainについての簡単な説明です。ご存知の方は 技術選定 まで読み飛ばしてください。 自律エージェントとは Agentという単語が出てきましたが、あまり馴染みのない方もいると思うので簡単に説明します。生成AIやLLMの文脈で出てくるAgent=自律エージェントと思っていただいて構いません。 自律エージェントは、与えられた最終目的に対して、自ら思考して計画をし、実際に行動をして最終目的を達成しようとするシステムです。 この行動の際に、 自律エージェントはツールを使って現実世界のシステムに干渉 できます。 この説明だと抽象度が高く、よく分からないと思うので今回の検証を例に説明します。 自律エージェントには、「タイタニック号の乗客のデータセットを分析する」という最終目的だけを与えます。 すると自律エージェントは、最初に思考してどのように分析するか計画を立てます。次に、計画に従いインターネット検索をするツールやPythonコード生成・実行ツールを使ってデータ分析を実施して最終目的を達成しようとします。 生成AIが内部で考えているだけでなく、インターネット検索ツールやPythonコード生成・実行ツールを使って、現実世界のシステムとやりとりをしているところが、通常の生成AIの利用と大きく異なります 。 今回はReActという手法でAgentを動作させているので、詳細な仕組みは次の ReAct(Reasoning and Acting)とは で説明します。 自律エージェントについて詳細を確認したい方は、 Autonomous Agents & Agent Simulations を参照してください。 ReAct(Reasoning and Acting)とは ReAct(Reasoning and Acting)は生成AIに論理的な思考をさせるPrompt Engineeringの技法の1つです。生成AIに推論と行動を繰り返させることで論理的思考を促すもので、次の三段階のプロセスを繰り返します。 思考(Thought) : 目的を理解し、行動計画・タスクの詳細化を行い、具体的な解決策を考案する。観察(Observation)からフィードバックを受け取り、適宜行動計画を修正する。 行動(Action) : 思考(Thought)段階で考案された解決策を実行する。 観察(Observation) : 行動(Action)の結果を観察し、次の思考(Thought)へフィードバックする。 LangChainのAgentは、この 行動(Action)の部分にツールを使用 できます。SerpApi等の検索ツールやPythonREPL等のPythonコード生成・実行ツールを使用します。利用可能なツールの説明を理解し、目的達成に必要なものをAgent自ら選択します。 つまり、 与えられた最終目的に対して自ら思考して計画を立て、適切なツールを選択して行動し、結果の観察とフィードバックのループを目的達成まで繰り返す自律エージェント が作成されます。 ReActについて詳細を確認したい方は、ReActが提唱された論文 ReAct: Synergizing Reasoning and Acting in Language Models を参照してください。 LangChainとは LangChainとは大規模言語モデル(LLM)を用いたアプリケーションを開発するためのフレームワークです。 様々なエコシステムと連携しやすくなっています。 LangChainにはモジュールが6つあるので簡単に紹介します。今回は主にAgentsのモジュールに関係があります。 モジュール 概要 Model I/O LLMに対するプロンプト入力、呼び出し、結果の受け取りの実装を簡単にする。 Retrieval LLMに未知の情報にアクセスする機能を提供する、Retrieval-Augmented Generation(RAG)を扱うモジュール。外部の検索エンジンやデータベースと連携して、LLMに事前学習していない情報に対応させる機能を簡単に実装できるようにする。 Memory 過去の会話履歴をデータベースに保存したり、呼び出す機能を簡単に実装できるようにする。 Chains 複数のモジュールの組み合わせを簡単に実装できるようにする。 Agents 自律的に思考し、外部に干渉する自律エージェントの構築を簡単にする。 Callbacks 様々なイベント発生時の処理の実装を簡単にする。ログの実装などに用いる。 LangChainについて詳細を確認したい方は、 LangChain公式ドキュメント を参照してください。 ※補足 Code InterpreterではなくAgentで実装する理由 こちらも今回の検証とは直接関係がないので、興味が無い方は読み飛ばしてください。 技術検証するのは生成AIのAgentにデータ分析をさせる部分です。OpenAIのCode Interpreterと似た機能ですが、Code Interpreterは外部環境（インターネット等）にアクセスできない等の制約があります。 一方、Agentであれば不明点や解決できないエラーが発生した際に、検索ツールを使って検索する等、他のツールを使った行動を取ることもできます。そのためAgentで実装した方が顧客の要望に柔軟に対応できます。 また担当する案件は、 案件で構築するシステムの概要 のように複雑で今後も拡張されそうな要件です。 Agentであれば行動やツールについて自由にカスタマイズができる ためAgentで実装しました。 技術選定 生成AIにデータ分析をさせる部分を検証します。 検証はLangChainで実装しました。 LangChainのAgent関連のコンポーネントについて 選定理由を話す前に、LangChainのAgent関連のコンポーネントの説明をしておきます。ご存知の方は読み飛ばしてください。 コンポーネント 説明 AgentExecutor AgentExecutorは、Agentの実行を管理するコンポーネントで、Agentが実行するタスクを制御し、結果を処理する。 Agent Agentは、特定のタスクやプロセスを自動化するためのエンティティで、一連のToolsを使用する。ツールのDescriptionを読んで適切なツールを選択する。 Tools Toolsは、Agentがタスクを実行する際に使用する具体的な機能やサービスの集合。Toolsには外部のAPI呼び出しを可能にするツール、Google検索などを可能にする検索ツール、Pythonのコード生成・実行を可能にするツールなどがある。 ※LangChainで利用可能なTools一覧は こちら 。 また、独自のToolsの作成も簡単にできる。独自のRetrieverを定義しておけば独自実装したRAGを組み込んだAgentを作ることができる。 Toolkit Toolkitは、複数のToolsを組み合わせて構成されるセットで、特定のタスクを効率的に実行するために最適化されている。 Pythonのコード生成・実行に特化したToolkitなどもある。 ※LangChainで利用可能なToolkit一覧は こちら 。 選定理由 技術要素 選定理由 LLM: GPT-4 Turbo 精度とコストを重視したため。 フレームワーク: LangChain 生成AIのAgentを容易に実装・管理できるフレームワークであり、デファクトスタンダードになりつつあるため。 Tools: PythonREPL Pythonのコード生成・実行を可能にするツール。データ分析タスクにおいて、Pythonを使用して分析をするため Tools: DuckDuckGoSearch インターネット検索を可能にするツール。不明点や解決できないエラーが発生した場合に検索して対処するため。 今回はツールとして独自定義した。 Agent: ReAct Agentの汎用性と論理的な思考能力を評価するため ReAct を採用。案件で構築するシステムがチャット形式のため、LangChainのAgentTypeはCHAT_ZERO_SHOT_REACT_DESCRIPTION を採用。 事前準備 事前にタイタニック号の乗客のデータセットをダウンロードし、S3などのダウンロード可能な場所に配置してください。タイタニック号の乗客のデータセットはKaggleからダウンロードできます。 データセットはKaggleにユーザ登録をし、 Kaggleのタイタニックデータセットのページ からダウンロードできます。 また、OpenAIのAPIキーは環境変数に事前に登録しておいてください。 OPEN_API_KEY="ご自身の保有しているAPIキーを記載してください" 実装内容 下記のコードで、タイタニック号の乗客データセットをダウンロードし、タイタニック号で生存に寄与した乗客の属性を分析させます。 コードの内容は 選定理由 に記載した通りなので詳細な説明は割愛します。 案件では再現性の高い分析が求められているため、LLMのtemperatureを0に設定しました。 Agentに与える指示は以下にしています。 タイタニック号の乗客のデータセットを分析してください。生存に寄与した属性をランキングで表示し、影響度を数値で表示してください。データセットは、https://xxxxxxxxxxxx/train.csv を使用してください。 データセットをインターネットからダウンロードするよう指示したのは、OpenAIのCode Interpreterができない外部環境へのアクセスが可能か検証するためです。コードを実行する場合は、 事前準備 にあるようにダウンロード可能なURLに書き換えてください。 from langchain.agents import AgentType, initialize_agent, load_tools, Tool from langchain.chat_models import ChatOpenAI from langchain.tools import DuckDuckGoSearchRun chat = ChatOpenAI( temperature= 0 , # 再現性を重視するため、temperatureを0に設定 model= "gpt-4-turbo-preview" ) tools = load_tools( # Agentが使用可能なツールの配列を読み込む（複数指定可能、Agentがツールのdescriptionを読み適切なツールを選択する） [ "python_repl" #　Pythonのコードを実行するためのTool ] ) search = DuckDuckGoSearchRun() # 不明点やエラーの解決策を検索するためDuckDuckGoSearchを追加 tools.append( # 追加したDuckDuckGoSearchをtoolsに追加 Tool( # ツールとして検索ツールを独自定義 name= "duckduckgo-search" , func=search.run, description= "This tool is used for conducting internet searches to address uncertainties or unresolved errors that arise during tasks or development processes." # Agentが選択できるようにツールの説明を記載 ) ) agent = initialize_agent( tools=tools, # Agentが使用することができるツールの配列を指定 llm=chat, # Agentが使用する言語モデルを指定 agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, #ReActを実行するAgentを指定 verbose= True # 実行中の詳細なログを表示する ) result = agent.run( "タイタニック号の乗客のデータセットを分析してください。生存に寄与した属性をランキングで表示し、影響度を数値で表示してください。データセットは、https://xxxxxxxxxxxx/train.csv を使用してください。" ) print (f "実行結果: {result}" ) 実行結果 実行すると、論理的に推論と行動を繰り返し、最終的にランキングを出力できました。 出力結果 parch : 0.6250 sex : 0.5365 sibsp : 0.5110 pclass : 0.3639 fare_quantile : 0.3567 age_group : 0.1178 この分析結果では、parch（同乗している家族（親子）の人数）、sex（性別）、sibsp（同乗している兄弟姉妹、配偶者の数）、pclass（客室等級）、fare_group（運賃）、age_group（年齢）の順に生存への影響が強い属性だったようですね。 実行結果を見てみましょう。（※実行結果中のデータセットのダウンロードURLは書き換えています。) 実行結果全文（非常に長いので詳細を確認したい方のみ、この文章をクリックして展開してください。） > Entering new AgentExecutor chain... Question: Analyze the Titanic passengers dataset to determine which attributes had an impact on survival. Provide the analysis results in a ranking with numerical values indicating the degree of impact on survival. Download the dataset using Python from the provided URL ( https://xxxxxxxxx/train.csv ) . Thought: To analyze the Titanic dataset, I will first need to download the data using Python. After downloading, I will load the data into a pandas DataFrame and perform exploratory data analysis ( EDA ) to determine which attributes had the most significant impact on survival. Action: { " action " : " Python_REPL " , " action_input " : " import pandas as pd \n df = pd.read_csv('https://xxxxxxxxx/train.csv') \n print(df.head()) " } Python REPL can execute arbitrary code. Use with caution. Observation: pclass survived name sex age sibsp parch ticket fare cabin embarked boat body home.dest 0 1 1 Allen, Miss. Elisabeth Walton female 29 . 0000 0 0 24160 211 . 3375 B5 S 2 NaN St Louis, MO 1 1 1 Allison, Master. Hudson Trevor male 0 . 9167 1 2 113781 151 . 5500 C22 C26 S 11 NaN Montreal, PQ / Chesterville, ON 2 1 0 Allison, Miss. Helen Loraine female 2 . 0000 1 2 113781 151 . 5500 C22 C26 S NaN NaN Montreal, PQ / Chesterville, ON 3 1 0 Allison, Mr. Hudson Joshua Creighton male 30 . 0000 1 2 113781 151 . 5500 C22 C26 S NaN 135 . 0 Montreal, PQ / Chesterville, ON 4 1 0 Allison, Mrs. Hudson J C ( Bessie Waldo Daniels ) female 25 . 0000 1 2 113781 151 . 5500 C22 C26 S NaN NaN Montreal, PQ / Chesterville, ON Thought:The dataset has been successfully loaded into a pandas DataFrame. The next step is to perform exploratory data analysis ( EDA ) to determine which attributes had the most significant impact on survival. I will start by checking for missing values in the dataset, as this can affect the analysis. Then, I will proceed to calculate the survival rates based on different attributes such as ' pclass ' , ' sex ' , ' age ' , ' sibsp ' , ' parch ' , ' fare ' , and ' embarked ' . Action: { " action " : " Python_REPL " , " action_input " : " print(df.isnull().sum()) " } Observation: pclass 0 survived 0 name 0 sex 0 age 263 sibsp 0 parch 0 ticket 0 fare 1 cabin 1014 embarked 2 boat 823 body 1188 home.dest 564 dtype: int64 Thought:The dataset contains a significant number of missing values in the ' age ' , ' cabin ' , ' boat ' , ' body ' , and ' home.dest ' columns. The ' boat ' and ' body ' columns are not typically used for survival analysis, as they relate to post-accident events ( lifeboats and body recovery ) . The ' cabin ' data is also largely missing, which may limit its usefulness in the analysis. However, ' age ' and ' embarked ' are important factors that are often considered in survival analysis. The missing value in ' fare ' is negligible as it is only one entry. The next step is to analyze the impact of various attributes on survival. I will calculate survival rates based on ' pclass ' , ' sex ' , ' age ' , ' sibsp ' , ' parch ' , and ' fare ' . Since ' age ' has missing values, I will need to decide how to handle them, either by imputing a value or by excluding those rows from certain parts of the analysis. For the initial analysis, I will focus on the attributes with complete data. I will start by calculating the survival rates for ' pclass ' and ' sex ' , as these are commonly known to have had a significant impact on survival. Then I will proceed with ' sibsp ' , ' parch ' , and ' fare ' . For ' age ' , I will consider how to handle the missing values before proceeding. Action: { " action " : " Python_REPL " , " action_input " : " survival_rates = {} \n for column in ['pclass', 'sex', 'sibsp', 'parch']: \n survival_rates[column] = df.groupby(column)['survived'].mean() \n print(survival_rates) " } Observation: { ' pclass ' : pclass 1 0 . 619195 2 0 . 429603 3 0 . 255289 Name: survived, dtype: float64, ' sex ' : sex female 0 . 727468 male 0 . 190985 Name: survived, dtype: float64, ' sibsp ' : sibsp 0 0 . 346801 1 0 . 510972 2 0 . 452381 3 0 . 300000 4 0 . 136364 5 0 . 000000 8 0 . 000000 Name: survived, dtype: float64, ' parch ' : parch 0 0 . 335329 1 0 . 588235 2 0 . 504425 3 0 . 625000 4 0 . 166667 5 0 . 166667 6 0 . 000000 9 0 . 000000 Name: survived, dtype: float64 } Thought:The survival rates based on ' pclass ' , ' sex ' , ' sibsp ' , and ' parch ' show clear trends. Higher class passengers ( pclass 1 ) had a higher survival rate than those in lower classes. Females had a much higher survival rate than males. The number of siblings/spouses ( sibsp ) and parents/children ( parch ) aboard also had varying impacts on survival rates, with some numbers showing higher survival rates than others. To provide a more comprehensive analysis, I will now calculate the survival rate for ' fare ' by categorizing it into quantiles, which will help to understand if higher fares ( which could correlate with higher socio-economic status or cabin location ) had an impact on survival. I will also handle the missing ' age ' data by filling in the missing values with the median age, and then categorizing age into groups to see if there is a trend in survival rates across different age groups. First, I will handle the ' fare ' attribute by categorizing it into quantiles. Action: { " action " : " Python_REPL " , " action_input " : " df['fare_quantile'] = pd.qcut(df['fare'], 4, labels=False) \n survival_rates['fare_quantile'] = df.groupby('fare_quantile')['survived'].mean() \n print(survival_rates['fare_quantile']) " } Observation: fare_quantile 0 . 0 0 . 228487 1 . 0 0 . 284375 2 . 0 0 . 435976 3 . 0 0 . 585139 Name: survived, dtype: float64 Thought:The survival rates for the ' fare_quantile ' show a positive correlation between fare price and survival, with passengers who paid higher fares having a higher survival rate. This suggests that socio-economic status , which could be inferred from the fare paid, had an impact on survival. Next, I will address the missing ' age ' data. Since age is an important factor and cannot be ignored, I will impute the missing values with the median age. After imputing the missing values, I will categorize the ' age ' into groups and calculate the survival rates for each group to see if there is a trend in survival rates across different age groups. Action: { " action " : " Python_REPL " , " action_input " : " median_age = df['age'].median() \n df['age'].fillna(median_age, inplace=True) \n df['age_group'] = pd.qcut(df['age'], 4, labels=False) \n survival_rates['age_group'] = df.groupby('age_group')['survived'].mean() \n print(survival_rates['age_group']) " } Observation: age_group 0 0 . 435435 1 0 . 317597 2 0 . 425532 3 0 . 394410 Name: survived, dtype: float64 Thought:The survival rates for the ' age_group ' show that the youngest and older age groups had slightly higher survival rates than the middle age groups, although the differences are not as pronounced as with other attributes like ' sex ' and ' pclass ' . Now that I have calculated the survival rates for ' pclass ' , ' sex ' , ' sibsp ' , ' parch ' , ' fare_quantile ' , and ' age_group ' , I can rank these attributes by their impact on survival. To do this, I will calculate the difference in survival rates between the highest and lowest groups within each attribute to determine the range of impact. Then I will rank the attributes based on these ranges. Action: { " action " : " Python_REPL " , " action_input " : " impact_ranges = {} \n for attribute, rates in survival_rates.items(): \n impact_ranges[attribute] = rates.max() - rates.min() \n impact_ranking = sorted(impact_ranges.items(), key=lambda x: x[1], reverse=True) \n for rank in impact_ranking: \n print(f'{rank[0]}: {rank[1]:.4f}') " } Observation: parch: 0 . 6250 sex: 0 . 5365 sibsp: 0 . 5110 pclass: 0 . 3639 fare_quantile: 0 . 3567 age_group: 0 . 1178 Thought:The ranking of attributes based on their impact on survival, with the numerical values indicating the degree of impact, is as follows: 1 . `parch` ( number of parents/children aboard ) : 0 . 6250 2 . `sex` : 0 . 5365 3 . `sibsp` ( number of siblings/spouses aboard ) : 0 . 5110 4 . `pclass` ( passenger class ) : 0 . 3639 5 . `fare_quantile` ( fare price category ) : 0 . 3567 6 . `age_group` : 0 . 1178 It is important to note that the `parch` attribute shows the largest range of impact, which might be surprising as it is not typically considered the most significant factor. However, this could be due to the way the survival rates are calculated across different numbers of parents/children aboard, which might not be linear and could be influenced by small sample sizes for certain values. The `sex` attribute has the second-highest impact, which aligns with historical accounts that women were given priority during the lifeboat boarding process. The `sibsp` attribute is third, suggesting that having siblings or a spouse aboard had a significant impact on survival, potentially due to the support system or prioritization of families during evacuation. The `pclass` attribute is fourth, indicating that passenger class was a significant factor, with first-class passengers having a higher survival rate. The `fare_quantile` is fifth, which is related to socio-economic status and potentially cabin location, with higher fares correlating with higher survival rates. Lastly, the `age_group` has the smallest range of impact, suggesting that age was a less significant factor compared to the others, although there was still some variation in survival rates across age groups. Final Answer: The ranking of attributes by impact on survival, from highest to lowest, is as follows: 1 . `parch` : 0 . 6250 2 . `sex` : 0 . 5365 3 . `sibsp` : 0 . 5110 4 . `pclass` : 0 . 3639 5 . `fare_quantile` : 0 . 3567 6 . `age_group` : 0 . 1178 > Finished chain. 実行結果: The ranking of attributes by impact on survival, from highest to lowest, is as follows: 1 . `parch` : 0 . 6250 2 . `sex` : 0 . 5365 3 . `sibsp` : 0 . 5110 4 . `pclass` : 0 . 3639 5 . `fare_quantile` : 0 . 3567 6 . `age_group` : 0 . 1178 中身を見てみましょう。はじめにQuestionで最終目的を定義しています。 Question: Analyze the Titanic passengers dataset to determine which attributes had an impact on survival. Provide the analysis results in a ranking with numerical values indicating the degree of impact on survival. Download the dataset using Python from the provided URL ( https://xxxxxxxxx/train.csv ) . きちんと指示通りに、生存に寄与した属性をランキング形式で表示するタスクを理解していますね。 その後は、以下6ステップに分けて実行しているようです。 データセットのダウンロードと読み込み : 指定されたURLからタイタニックのデータセットをダウンロードし、PandasのDataFrameに読み込みます。読み込んだデータの先頭部分を表示して、データが正しく読み込まれたことを確認します。 欠損値の確認 : データセットに含まれる欠損値の数を確認します。特に「年齢(age)」、「キャビン(cabin)」、「乗船した港(embarked)」などのカラムで欠損値が多いことが分かります。これらの欠損値は分析に影響を与えるため、適切に処理する必要があります。 生存率の計算 : 生存に影響を与えた可能性のある属性（「客室等級(pclass)」、「性別(sex)」、「兄弟姉妹や配偶者の数(sibsp)」、「親や子どもの数(parch)」）について、グループごとに生存率を計算します。 料金(fare)に基づく生存率の計算 : 乗船料金を四分位数で分割し、料金のカテゴリーごとに生存率を計算します。料金が生存率にどのように影響したかを分析します。 年齢(age)に基づく生存率の計算 : 年齢データの欠損値を中央値で補完し、年齢をグループに分けて生存率を計算します。年齢が生存率にどのように影響したかを分析します。 属性の影響度のランキングの表示 : 最後に、各属性に基づいて計算された生存率の差を用いて、生存に最も影響を与えた属性をランキング形式で表示します。ランキングは、各属性が生存に与えた影響の度合いを数値で示しています。 考察 分析結果 Agentによる分析と人による分析を比較して妥当性を確認します。 Kaggleで今回のデータセットの分析をされているこちらの投稿 を見ても、生存に影響を与えている属性が同じですね。人が行った分析と比較しても、今回のAgentの行った分析は妥当と言えます。タイタニック号の史実と照らし合わせても客室等級、性別、子供を連れた家族などの属性が生存に影響したという分析は妥当と言えます。 分析過程 今回の検証では分析結果よりも分析過程自体の考察が重要です。 生存に寄与した属性をランキング表示するという大目標のみを与えていましたが、 Agentは目的達成のために自律的に思考し自ら詳細なタスクを作り出して実行 していました。特にデータを確認して自らの判断で欠損値を確認して補完したり、生存率を計算した後、関連のありそうな属性を詳細に分析するタスクを自ら作り出して実行している点は非常に興味深いです。 今回のデータセットを分析している記事をいくつか拝見しましたが、 欠損値を埋める等の指示をしていないタスクも人と同様の手順 で実行できていました。 このような論理的な思考ができる理由は ReAct の推論フレームワークを使用したからだと考えられます。 該当箇所抜粋 Thought:The dataset has been successfully loaded into a pandas DataFrame. The next step is to perform exploratory data analysis ( EDA ) to determine which attributes had the most significant impact on survival. I will start by checking for missing values in the dataset, as this can affect the analysis. Then, I will proceed to calculate the survival rates based on different attributes such as ' pclass ' , ' sex ' , ' age ' , ' sibsp ' , ' parch ' , ' fare ' , and ' embarked ' . Action: { " action " : " Python_REPL " , " action_input " : " print(df.isnull().sum()) " } Observation: pclass 0 survived 0 name 0 sex 0 age 263 sibsp 0 parch 0 ticket 0 fare 1 cabin 1014 embarked 2 boat 823 body 1188 home.dest 564 dtype: int64 Thought:The dataset contains a significant number of missing values in the ' age ' , ' cabin ' , ' boat ' , ' body ' , and ' home.dest ' columns. The ' boat ' and ' body ' columns are not typically used for survival analysis, as they relate to post-accident events ( lifeboats and body recovery ) . The ' cabin ' data is also largely missing, which may limit its usefulness in the analysis. However, ' age ' and ' embarked ' are important factors that are often considered in survival analysis. The missing value in ' fare ' is negligible as it is only one entry. The next step is to analyze the impact of various attributes on survival. I will calculate survival rates based on ' pclass ' , ' sex ' , ' age ' , ' sibsp ' , ' parch ' , and ' fare ' . Since ' age ' has missing values, I will need to decide how to handle them, either by imputing a value or by excluding those rows from certain parts of the analysis. For the initial analysis, I will focus on the attributes with complete data. Agentによる自律的なエラー解決 何度か検証をしていると、Agentが生成したPythonのコードが実行時にエラーを吐くことがありました。エラーが発生した際にAgentは、 ReAct の推論フレームワークに沿って、エラーを自律的に解決していました。具体的には発生したエラーの解決策を検索ツールで検索して解決していました。 自律的なエラー解決のプロセス 観察(Observation) : 前回の行動(Action)の結果、エラーの発生を確認する。 思考(Thought) : 解決策を探すために、適切なツールの使用する。「不明点やエラーの解決策を検索するためのツール」という説明の検索ツールを見つけ、解決策をインターネット検索することを計画する。 行動(Action) : 検索ツールを用いて解決策を検索する。 観察(Observation) : 検索結果から有益な情報を抽出する。 思考(Thought) : 抽出された情報から具体的なアクションを考案する。 行動(Action) : Pythonコード生成・実行ツールで解決策を実行する。 このように 予期せぬ事態に遭遇しても、推論と行動を繰り返すReActのAgentは柔軟に対応 できます。状況に合わせて臨機応変に計画を変更し、ツールを使い分け、目的達成に向けてタスクを継続できる点がReActで動作するAgentの強みです。 下記の事例は、seabornというモジュールがインストールできないエラーが発生し、解決策を検索ツールで検索しています。結局インストールできないという問題は解決できませんでしたが、他のモジュールを使うことでエラーを回避して分析を進めていました。 Agentが発生したエラーの解決策を検索したり、回避策を探して分析を続けている事例 Action: { " action " : " Python_REPL " , " action_input " : " !pip install seaborn " } Observation: SyntaxError ( ' invalid syntax ' , ( ' <string> ' , 1 , 1 , ' !pip install seaborn\n ' , 1 , 2 )) Thought:It seems that I made the same mistake again. I need to use the duckduckgo-search tool to search for the correct way to install the seaborn module. Action: { " action " : " duckduckgo-search " , " action_input " : " install seaborn module in Python using pip " } Observation: Latest version Jan 25 , 2024 Project description seaborn: statistical data visualization Seaborn is a Python visualization library based on matplotlib. It provides a high-level interface for drawing attractive statistical graphics. Documentation Online documentation is available at seaborn.pydata.org. We can install the seaborn package by running the below command . pip install seaborn Kindly ensure that you have pip installed on your device before running this command . For Python 3 , we can use the pip3 command instead of pip. We can also specify the required version of the module we wish to install, as shown below. pip3 install seaborn = = 0 . 9 . 0 The pip show seaborn command will either state that the package is not installed or show a bunch of information about the package, including the location where the package is installed. # Make sure your IDE is using the correct Python version If the package is not installed, make sure your IDE is using the correct version of Python. How can I Install a Python module within code? Ask Question Asked 11 years, 5 months ago Modified 8 months ago Viewed 552k times 503 I need to install a package from PyPI straight within my script. Getting Started First of all, let us install Seaborn. Seaborn can be installed using the pip. Type the below command in the terminal. pip install seaborn In the terminal, it will look like this - After the installation is completed you will get a successfully installed message at the end of the terminal as shown below. Thought:Based on the search results, the correct way to install the seaborn module is by using the pip command . I will now install seaborn using the pip command . Action: { " action " : " Python_REPL " , " action_input " : " !pip install seaborn " } Observation: SyntaxError ( ' invalid syntax ' , ( ' <string> ' , 1 , 1 , ' !pip install seaborn\n ' , 1 , 2 )) Thought:I apologize for the repeated mistake. It seems that I am unable to install the seaborn module using the pip command in this environment. However, I can still analyze the dataset using other available tools and libraries. I will proceed with analyzing the dataset without using seaborn. まとめ 検証結果 生成AIは一般に確率的にデータを生成するため、論理的な思考やデータ分析のような数値計算は苦手です。 しかし、今回検証したように生成AIのAgentに ReAct のような推論フレームワークとPythonコード生成・実行をするツールを組み合わせることで、論理的思考や数値計算が必要なデータ分析等のタスクも実行できる ようになります。Agentによる分析も人による分析と比較しても妥当性の高いものでした。 また、生成したPythonのコードでエラーが発生した際に検索のツールを使って、エラーの解決策を検索しに行くなど臨機応変な対応をしていました。 想定外の事態が起きても、計画を変更しツールを使い分けて対応できる点も、推論と行動を繰り返すReActのAgentの強み と言えます。 Code Interpreterとの比較 OpenAIのCode Interpreterではこれほど推論と行動を繰り返してタスクを実行することはありません。エラー解決のためにインターネットで検索するなどの臨機応変な対応もできません。そもそもインターネット等の外部環境にアクセスができません。上記の点からも今回のようなAgentの実装に優位性があります。 逆にいうとAgentは行動を予測しづらく、行動回数が増えて返答まで時間がかかったり、GPT-4 Turboの呼び出し回数も増加して高コストになる可能性があります。要件に応じて最大行動回数を設定する等の対策をすると良いと思います。 今後に向けて 案件では、生成AIでRAGを用いてプライベートデータの定性的な分析をし、得られた定性的な分析を元に定量的な分析をします。今回の検証よりも複雑で高い精度を求められるので今後も改良が必要です。今回は単一のAgentで実装しましたが、今後は複数のAgentを使った構成も試したいと思います。マルチエージェントと呼ばれる、複数の異なる役割を持ったエージェントが協力するシステムや、 BabyAGI などの高度な自律エージェントを検証し、高精度でより複雑なタスクへ可能なシステムを実装しようと思います。 感想 生成AIのAgentを使ったデータ分析をしてみましたが、 ReAct の論理的思考には驚かされました。特に、Agentが生成したPythonのコードでエラーが発生した際に検索を始めた時には、こんなことができるのかと非常に驚きました。 最近では、複数の異なる役割を持ったエージェントが協力するマルチエージェント等、複雑なタスクに対応できるアーキテクチャも流行っています。また、最近のLLMはマルチモーダル（テキストだけでなく、画像、音声、動画など様々なデータ形式に対応したモデル）にもなってきています。 マルチモーダルとマルチエージェントを組み合わせるとかなり幅広いタスクができるようになる のではないかと思います。 限界を越えて進化し続ける生成AIは、非常に面白いので今後も積極的に関わっていこうと思います！ 本記事がどなたかの役に立てば幸いです！

初めまして、去年の11月にInsight Edgeへ参画したEngineerの田島です。 現在の業務では生成AI用いたDX案件や住友商事グループ事業のソフトウェア開発に携わっています。 まだ加入してから数ヶ月ですが、Insight Edgeの特徴として「小回りの良さと技術選定の幅の広さ」を強く感じています。 出島組織なので開発を柔軟に進めていくことが可能であり、 幅広いビジネスをしている総合商社ならではの様々な課題に対応すべく、 幅の広い技術選定が求められるように感じます。 また、エンジニア・データサイエンティスト・コンサルタントが互いにリスペクトし、プロフェッショナルとして働いてるので、成長の場としても適しているかと思います。 本記事ではComputer Visionのシステムを題材に、生成AIの活用で注目が集まっているAzureを用いたMLOpsの実現について紹介したいと思います。 概要 想定ケース ビジネスシーンとして、各カメラから取得される人流情報を防犯や空調の最適化に活かすことを想定します。 想定ケース 複数のカメラを用いたシステムの課題 カメラシステムを実際に運用する上で、設置条件は個体毎に異なります。 これにより、カメラ毎の認識精度がばらつくと想定されます。 例えば、暗所による撮影における感度自動制御で、下図のようなノイズが生じます。 (感度自動制御とはカメラ信号処理の一部で、適正な明るさが得られない場合などに電気的に信号を増幅させることで適正な明るさの画像を得る処理のことです。) 同じカメラにおいても長期期間システムを運用するうえでは、季節や周辺環境の変化により影響度が変化します。 このカメラの精度ばらつきが、本ユースケースの人流情報の効果的な利用の問題になると考えられます。 暗所によるノイズの例 システムの概要 本記事では、認識精度のばらつきを自動的に補正する画像認識システムを考えます。 これにより、安定した認識率のシステムを構築するだけでなく、 従来はカメラの設置条件などを変えるなどしていた作業をシステムとアルゴリズムが肩代わりすることで、保守工数を削減したシステムを構築します。 このシステム構築にあたっては、Azure Custom VisionのOptimization機能を用いて、カメラ毎の条件に合わせて再学習します。 (*) 本記事ではセンサーノイズや画像処理の詳細には踏み込みません。あくまでシステム構築に主眼を置きます。 システムの内容 MLOps 機械学習の社会実装をするうえで、他のシステムと同様に継続的なインテグレーションとデリバリーが求められます。 MLOpsはこれを実現するエコシステムを指し、Googleの提唱する 実現レベル が有名です。 この実現レベルの概要は以下の通りです。 レベル０：手動による学習プロセス。モデルの変更が稀なケースを想定します。 レベル１：学習パイプラインの自動化。パイプライントリガーによって自動的にモデルを更新します。 レベル２：CI/CDパイプラインの自動化・効率化。モデルの変更アイデアを迅速に反映・検証します。 そこで本記事ではレベル1を題材に、継続的にモデルを更新することで、設置環境の変化によるノイズ影響の解決を考えます。 インフラ構成 本記事で構築するシステムのアーキテクチャは以下の通りです。 インフラ構成 Azure Custom Vision Azure Custom Visionは特定のドメインに特化した画像認識モデルを作成可能なサービスです。 利用にあたっては機械学習モデルの専門知識は必要なく、WebUIまたはREST APIでサービスを利用できます。 レベル1のMLOpsに必要不可欠な要素であるモデルのテストやエッジ環境などへデプロイに対応しています。 2024/02現在は、1枚の画像をクラス分類するClassificationと画像中に物体位置を認識するObject Detectionに対応しています。 本記事では、画像中から対象物の数を抽出するためにObject Detectionを採用し、REST APIを用いてカメラ毎に適切な学習を自動的に行います。 インフラ構成の説明 カメラで取得された画像データは、AzureのBlobストレージにアップロードされるものとします。 このアップロードをトリガーとして、Azure Functionsを起動させ、人物検出します。 人物検出には上のAzure Custom Visionで生成したONNXモデルをStorageからダウンロードします。 そして、検出された人物の数がSQLデータベースに記録されます。 また、Azure Functionsの定期実行を用いて、モデルを更新します。 モデル更新用に撮影された複数枚の画像から統計的なばらつきを推定し、それらの影響を学習データに付加して、カメラ環境に合った学習データを生成します。 この学習データをAzure Custom Visionにアップロードし、モデルの再学習します。学習終了後にStorageのモデルを更新します。 今後エッジでの検出処理を想定し、モデルデータのエクスポートします。 仮にクラウドでの処理に完結させる場合は、モデルのAzure Custom VisionのAPIエンドポイントとしてパブリッシュすることで、システムを簡略化可能です。 ソースコード ソースコードは以下のレポジトリで公開しています。 GitHub Link デプロイメント ソースコード中のterraformを用いてクラウドリソースのデプロイが可能です。 一方でCustom Visionについては、Microsoftの「AIの責任ある使用」に関するポリシーに同意する必要があるためAzure Portalで行います。 MarketPlaceよりCustom Visionを選択し、「作成オプション」を「トレーニング」にしてリソースを作成します。 モデルをエクスポートせずに、学習済みモデルをREST APIとして実行する場合は「両方」を選択してください。 トレーニングの価格レベルは要件に合わせて選択しますが、PoC段階ということで「Free F0」を選択します。 Custom Visionのリソース作成 MLワークフロー 本記事ではソースコードのMLワークフローおよびAzure Custom Visionについて説明します。 学習データの準備 人物検知に向けた学習データの作成にあたり、ここでは商用可能なものを選定または作成する必要があります。 しかし、このデータセットの用意は本記事のシステム構築の趣旨から外れるため、検証用としてお菓子袋の検出を考えます。 ここで用意した画像に、以下のような検出用のバウンディングボックスを設定し、それらの情報を保存します。 ここまでの準備をシステム構築前に行います。 お菓子とバウンディングボックス 再学習時には、この学習データにガウシアンノイズを付与します。 ガウシアンノイズの分散値には、被写体の時間変化が少ない期間に撮影された複数枚の画像から、画素ごとに分散値を算出し、全画素の最頻値を採用します。 これにより、被写体が一定であるときのランダムノイズの代表値を近似的に取得します。 (*) この方法では信号量に依存したノイズ量を正しく見積もることができません。より精度を求める場合は改善の余地があります。 ノイズ量の算出 モデル学習 Custom VisionをPython向けのSDK越しに用いて、学習データをアップロードします。 モデル学習のタスクをキューに追加し、一定期間待機することで学習が終了します。 以下はソースコードの一部を抜粋し、コメントを加えたものです。 from azure.cognitiveservices.vision.customvision.training import ( CustomVisionTrainingClient, ) from azure.cognitiveservices.vision.customvision.training.models import ( Region, ImageFileCreateEntry, ImageFileCreateBatch, ) from msrest.authentication import ApiKeyCredentials ``` 省略 ``` credentials = ApiKeyCredentials(in_headers={"Training-key": TRAINING_KEY}) trainer = CustomVisionTrainingClient(ENDPOINT, credentials) # ドメインの作設定 # エッジデバイスへのデプロイを見越して`compact`を選定 # `compact`を選定しない場合はWebAPI越しの実行しかできない obj_detection_domain = next( domain for domain in trainer.get_domains() if domain.type == "ObjectDetection" and domain.name == "General (compact)" ) # プロジェクトを作成 project = trainer.create_project( "People Counting Project", domain_id=obj_detection_domain.id, ) # タグの作成 person_tag = trainer.create_tag(project.id, "Person") # アップロード画像のリスト化 # 上で保存した情報(ファイル名とバウディングボックス)が"json_data"に格納 tagged_images_with_regions = [] for data in json_data: image_file = data['fileName'] tags = data["tags"] regions = [ Region( tag_id=person_tag.id, left=tag["left"], top=tag["top"], width=tag["width"], height=tag["height"], ) for tag in tags ] with open(image_file, "rb") as image_contents tagged_images_with_regions.append( ImageFileCreateEntry( name=image_file, contents=image_contents.read(), regions=regions, ) ) # ファイル群のアップデート trainer.create_images_from_files( project.id, ImageFileCreateBatch(images=tagged_images_with_regions) ) # 学習タスクをキューに入れる(ここでは１イテレーションのみ) iteration = trainer.train_project(project.id) プロジェクトの作成とファイル群のアップデートに成功すると、Custom Visionポータルからアップロードされたファイルとタグ情報を確認できます。 また、Custom Visionポータルからも画像のアップロードとタグ付けが可能です。 Custom Vision Portal 学習の確認 トレーニング終了後に、学習にデータにおける精度、再現率、平均精度を確認できます。 これにより、学習が成功したかを確認できます。 この内容はCustom VisionポータルのPerformanceタブからも確認可能です。 # interation.status == "Completed" で学習終了 iteration_id = iterations[0].id # 最新のイテレーション iteration_performance = trainer.get_iteration_performance( project_id, iteration_id ) # パフォーマンス指標の表示 print("Precision: {:.2f}".format(iteration_performance.precision)) print("Recall: {:.2f}".format(iteration_performance.recall)) print("Average Precision: {:.2f}".format(iteration_performance.average_precision)) パフォーマンス指標 モデルデプロイおよび実行 SDKよりモデルURLを取得し、ダウンロードできます。 ダウンロードされたzipファイルには、実行用のPythonソースコードとモデルデータ("*.onnx")が含まれます。 本記事のシステムでは、このモデルデータをBlobストレージに置き、ソースコードはAzure Functionにデプロイします。 # モデルのエクスポート export = trainer.export_iteration(project_id, iteration_id, "ONNX") while export.status != "Done": export = trainer.get_export(project_id, iteration_id, export.id) time.sleep(10) # URLの取得とダウンロード model_url = export.download_uri export_file = requests.get(model_url) with open("export.zip", "wb") as file: file.write(export_file.content) 実際にコードを実行すると以下のように出力され、検出物のリストが出力されます。 このリスト長を人流データとして記録します。 $ python python/onnxruntime_predict.py test_001.png [ {'probability': 0.96306247, 'tagId': 0, 'tagName': 'Person', 'boundingBox': {'left': 0.6113374, 'top': 0.1495378, 'width': 0.23059763, 'height': 0.18790943}}, {'probability': 0.93494284, 'tagId': 0, 'tagName': 'Person', 'boundingBox': {'left': 0.31712056, 'top': 0.43989411, 'width': 0.28013505, 'height': 0.18385402}}, {'probability': 0.86241835, 'tagId': 0, 'tagName': 'Person', 'boundingBox': {'left': 0.18591469, 'top': 0.15347767, 'width': 0.22360932, 'height': 0.20324681}}, {'probability': 0.86202902, 'tagId': 0, 'tagName': 'Person', 'boundingBox': {'left': 0.38832647, 'top': 0.13814446, 'width': 0.25019577, 'height': 0.22316483}}, {'probability': 0.83257216, 'tagId': 0, 'tagName': 'Person', 'boundingBox': {'left': 0.04233004, 'top': 0.41069869, 'width': 0.17654971, 'height': 0.19467201}}, {'probability': 0.78080565, 'tagId': 0, 'tagName': 'Person', 'boundingBox': {'left': 0.58802276, 'top': 0.39514219, 'width': 0.20800796, 'height': 0.2052871}}, {'probability': 0.66069514, 'tagId': 0, 'tagName': 'Person', 'boundingBox': {'left': 0.72162047, 'top': 0.49268371, 'width': 0.24379058, 'height': 0.19499978}}, {'probability': 0.39772633, 'tagId': 0, 'tagName': 'Person', 'boundingBox': {'left': 0.18672522, 'top': 0.35396666, 'width': 0.23256654, 'height': 0.19639073}} ] 今後の展望 ブログの趣旨としてCustom Visionを用いたシステム構築のPoCに終始してきました。 その他の構成については、上で紹介したソースコードにて公開しています。 現状は学習パイプラインの起動をスケジュール実行しており、 学習データやカメラ台数の増加により計算リソース面で破綻することが想定されます。 「MLOpsレベル1：MLパイプラインの自動化」を実現するにあたり、モデル認識精度を監視し、 効率的な学習のパイプラインのトリガー策定が不可欠です。 また、実用化や精度向上にむけて、学習データの拡充やエッジ処理によるスループットやプライバシーリスクの改善を検討したいと考えています。 まとめ Azure Custom Visionを用いて、簡易的なMLフローを構築しました。 このサービス強みとして、既存の学習モデルに無いドメインや実用上の課題を解決した画像識別モデルを、容易に生成できることにあると思います。 ただし、今後ChatGPT4 with VisionなどのLLMによるプロンプトエンジニアリングで解決できるようになる可能性があり、このようなサービスはLLMや生成形AIがリーチしにくいエッジ領域にシフトしていくかと思います。 今後の発展を注視しつつ、Insight Edgeでは現状でベストな選択をしていきたいと思います。

はじめまして、Insight Edge 開発チームの綱島です。昨年4月からInsight Edgeに参画し、生成AI関連の案件を中心に、PMやエンジニアロールを担当しています。 元々エンジニアリング経験が少ないバックグラウンドなので、非技術者でもとっつきやすいローコード・ノーコード領域などを中心に積極的に調査していきたいと思っています。 今回は上記領域の中でも比較的ホットなMicrosoft Copilot Studioを使ったChatbot作成について紹介できればと思います。 この領域に興味がある方、または軽く読んでみたいと思う方、ぜひお付き合いいただければ幸いです。 はじめに Microsoft Copilot Studioを使ったChatbotの作成 1. 作成画面までの操作 2. Copilot Studioにおけるアップデート部分の組み込み ① Webサイト情報の連携 ② 独自のアップロードデータの使用 ③ 生成的な回答を可能にするトピックの紹介 ④ トピックの自動提案 3. Copilotの公開（Microsoft Teams上での利用） つまずきポイントの紹介 最後に（今後試したいこと） はじめに 「Microsoft Copilot Studio（以下Copilot Studio）」は、昨年11月に開催された「Microsoft Ignite 2023」でMicrosoftが発表した会話型AIプラットフォームで、ローコードでMicrosoft 365 Copilotを独自にカスタマイズした生成AIツール（＝Copilot）を作成できるというものです。 ちなみに、Insight Edgeが内製組織としてDX推進のサポートを行っている住友商事では、昨年からCopilotの導入が進められており、Copilot Studioの生成AI機能についても、今後の業務活用に向けた検証が始まっています。それらの導入や検証のサポートにあたって、Insigh Edgeでは各種Copilotツールを検証出来る環境が整っており、日々調査を進めています。 現時点でCopilot Studioを使ってみた印象ですが、以前より提供されていたPower Virtual Agents（ノーコードのChatbot作成ツールで、現在はCopilot Studioに統合。以下PVA。）上で、生成AI機能が使えるようになった！という感じです。 Microsoft Copilot Studioを使ったChatbotの作成 今回はPVAからアップデートされた部分を中心に試しつつ、Chatbotを作成してみましたので、以下の流れでご説明します。 作成画面までの操作 Copilot Studioにおけるアップデート部分の組み込み ① Webサイト情報の連携 ② 独自のアップロードデータの使用 ③ 生成的な回答を可能にするトピックの紹介 ④ トピックの自動提案 Copilotの公開（Teams上での利用） 1. 作成画面までの操作 ホーム画面にて [+ Copilotを作成する] をクリックします。 Microsoft Copilot Studioホーム画面の抜粋。 [コパイロットを設定する]画面で、「コパイロットの名前」と「コパイロットが話す言語」を設定し、[作成]をクリックします。 言語は「英語」を指定※します。 ※現時点で、日本語では生成AIによる会話強化を利用できないため。 ※ただ、作成画面は日本語UIで、チャットのやり取りも日本語に対応していました。 下段の「生成型の回答で会話を強化する」欄では、データソースとして使用するWebサイトを設定できます。こちらは[作成]ボタンクリック後でも設定可能※です。（※次セクションでご説明します） Microsoft Copilot Studioの初回設定画面。 以下、概要画面に遷移し、ここからChatbotを作成していきます。 Microsoft Copilot Studioの概要画面。 前提として、Copilot Studioでは「トピック」と呼ばれる回答シナリオを予め定義し、基本的にはそれら既定トピックをもとに回答します。トピックに該当しない質問が投げられた際に、“生成AIによる会話強化機能”を使い、各種データソースをもとに生成型回答を返すというイメージです。 なお、トピックは[プラグイン(プレビュー)]タブで設定でき、下記キャプチャのようにノーコードでシナリオを設定することができます。 トピック設定画面。 トピックのシナリオ設定画面。 今回は上述の“生成AIによる会話強化機能”を中心に、PVA→Copilot Studioにおけるアップデート部分を試していますので、その前提で以下ご覧頂ければと思います。 2. Copilot Studioにおけるアップデート部分の組み込み ① Webサイト情報の連携 画面左の[生成AI]タブに移動し、[Webサイト]欄に、データソースとしたいWebサイトのURLを入力します。今回はInsight Edge HPの[ Company ]および[ Business ]ページを設定しました。 WebサイトURL入力画面。 上記データソースを設定のうえ、いくつか質問を試してみました。概要サマリ系とピンポイントの情報検索系の質問を投げてみましたが、どちらも正しく回答している印象です。 ちなみに、日本語で同じ質問をした場合にも正しく回答が返ってきました。 Insight Edge HPに関する質問に対するChatbot回答。 ② 独自のアップロードデータの使用 続いて、データアップロードについてもご紹介します。 先ほどと同じ [生成AI] タブの [ドキュメントをアップロードする（プレビュー）] 欄でアップロードします。 今回は Insight Edge求人サイト の、 データサイエンティスト募集要項 を英訳のうえ.txt化して取り込んでみました。 データアップロード画面のイメージ。 アップロードしたファイルにのみ記載がある標準労働時間について質問したところ、正しくデータを引用して回答が返せていました。 アップロードデータに関するChatbot回答。 ③ 生成的な回答を可能にするトピックの紹介 上述の Webサイト情報やアップロードデータを基にした生成型回答を返すためのトピック（「Conversational boosting」）について触れておきたいと思います。 本トピックは、既定トピックに定義されていない値が入力された場合に、下図の通り、”Unknown Intent”として生成AIに流し、予め設定した独自のデータソースを基に回答を生成する仕組みとなっています。 規定シナリオに基づく正確性の高いQ&Aと、生成AIによる柔軟なQ&Aのハイブリッド実装を可能にする注目機能と捉えています。 「Conversational boosting」トピックのフロー。 ④ トピックの自動提案 最後は少し毛色が違いますが、Chatbotからのトピック提案についてです。Microsoft公式ドキュメント( Microsoft Copilot Studio のシステム トピックを使用する - Microsoft Copilot Studio | Microsoft Learn )では、「システムトピック」（デフォルトで設定されているトピック）の一つとして紹介されていますが、システムが自動にやってくれると少し嬉しい機能だったのでご紹介します。 端的に言うと、ユーザーの入力内容が複数のトピックに該当しそうな場合に、それら該当トピックを表示し、ユーザーに選択するように求めるものです。試しに、Insight Edgeの福利厚生に関するトピックを2つ作成のうえ、どちらにも当てはまるような質問を投げてみました。すると、予め定義した2トピックを提示して選択を求めるフローとなりました。 （ちなみに、以下例示キャプチャの通り、使用言語は英語に設定しているものの、日本語でもやり取り可能です。） 作成トピックとChatbotの回答。 3. Copilotの公開（Microsoft Teams上での利用） Copilotの公開についても少し触れたいと思います。[公開]タブの[チャネルの構成]から、[チャネルに移動]をクリックし、[Teamsを有効にする]ことでMicrosoft Teamsでの利用が可能になります。 Microsoft Copilot Studioの公開設定画面イメージ。 Microsoft Teams上での利用イメージ。 つまずきポイントの紹介 今回Chatbot作成にあたって、少しつまずいたポイントをいくつかご紹介します。 アップロードファイル ファイル容量に制限（3MB以下）があります。 ファイルが英語でないと参照されませんでした。（今後、日本語対応が進むに連れて解消するかと思います） 作成時の設定 セカンダリ言語として日本語などを設定することも可能ですが、プライマリ言語（英語）でないと、各種トピックの更新が出来ませんでした。 最後に（今後試したいこと） 今回は少量データ且つ既定トピックも多くないので、回答精度が良かった印象ですが、今後はデータソースやトピックを増やしたうえで精度を確認していきたいと思います。 また、SharePointやOneDriveとの連携機能※1や、会話プラグイン機能※2はまだ試せていないので、それらも組み合わせたChatbotの作成にも取り組みたいと思います。 ※1： 生成型の回答に SharePoint または OneDrive for Business のコンテンツを使用する - Microsoft Copilot Studio | Microsoft Learn ※2： Microsoft Copilot 向け会話プラグインを作成する (プレビュー) - Microsoft Copilot Studio | Microsoft Learn 以上、最後まで読んでいただきありがとうございました！

こんにちは、Insigt Edgeで働いているデータサイエンティストの藤村です。 画像認識モデル開発に携わっています。 今回は、画像上の異常検知において一般的な問題である学習データ不足に着目し、その解決方法としての画像生成AI活用について解説します。 異常検知の現場課題とその重要性 品質管理における製品の微細なキズや欠陥の検出は非常に重要です。これらを解決する手段の1つとして画像認識による欠陥の異常検知がよく使われます。しかしながら、これらの欠陥は非常に稀であるため、「異常あり」の画像データを十分に集めることは一大課題となっています。具体的な例としては: 自動車製造 ：ラインでの塗装の不具合や組立のズレ。 電子機器の組み立て ：微細な接続エラーや部品の不良。 農業 ：作物の病気や害虫による損傷。 公共インフラ ：線路の点検での微細な亀裂や異物の発見。 航空機メンテナンス :機体表面の微小な損傷やひび割れ。 これらの例では、異常が極めて稀であるにもかかわらず、多様なデータセットが機械学習モデルの訓練に必要です。特に、線路点検などの公共インフラの安全管理では、稀な異常の正確な検出が事故防止に直結します。 画像生成AIのInpaint技術 Inpaint技術は、画像の一部分だけを変更・修正するためのAI技術です。これにより、元の画像の大枠を維持しつつ、必要な部分のみの変更が可能です。特に、Stable Diffusionを用いたInpaint技術は、従来の手法と比較して、異常や変更点を文章で具体的に定義することにより、AIがより精度の高い画像を生成できる点が特徴的です。 Inpaintに必要な要素は以下の通りです。 元の画像 ：変更する前の基本画像。 マスク画像 ：変更したい箇所を塗りつぶした画像。 変更後のプロンプト ：変更を指示するテキスト。 以下の生成例は、Hugging Faceで公開されています 元画像 マスク画像 プロンプト a tiger sitting on a park bench Inpaintされた画像 出展: Hugging Face この技術により、少量の現実データから多様な学習データの生成が期待できます。 異常画像生成への応用 この技術を異常検知に応用することで以下のメリットが得られます。 既存の正常な画像に人工的に「異常」を挿入 ：実際には存在しない欠陥を持つ画像の生成。 迅速かつコスト効率的なデータセット作成 ：従来のデータ収集方法よりも効率的。 この技術を用いることで、既存の正常な画像に人工的に「異常」を挿入することで、実際には存在しない欠陥を疑似的に生成できます。これにより、機械学習モデルのための豊富なデータセットが容易に作成可能となります。 異常画像生成の自動化プロセス 「Stable Diffusion Web UI」や「Adobe Firefly」といったGUIベースの生成ツールもありますが、今回は異常検知を認識させるための学習データ生成が目的なので大量生成できる仕組みが必要です。 Stable Diffusion XLを用いた異常画像生成のプロセスは以下の通りです: 異常が発生する可能性のあるピクセルエリアの特定 ：製品の特性や過去のデータに基づく。 Stable Diffusion XLを用いた異常画像の大量生成 ：異常をランダムな位置に生成し、複数のプロンプトを用いて大量に生成。 サンプルコード 以下は、スマートフォン画面に傷がある異常を生成する例です。 以下のサンプルコードは、Stable Diffusion XLを用いた異常画像生成のプロセスを示しています。 from diffusers import StableDiffusionInpaintPipeline import torch from PIL import Image, ImageDraw # モデルの初期化 pipe = AutoPipelineForInpaint.from_pretrained( "diffusers/stable-diffusion-xl-1.0-Inpaint-0.1" , torch_dtype=torch.float16, variant= "fp16" ).to( "cuda" ) # マスク画像の準備 mask_image = Image.new( 'RGB' , ( 640 , 640 ), color= 'black' ) draw = ImageDraw.Draw(mask_image) mask_size = 400 top_left_corner = ( 110 , 110 ) bottom_right_corner = (top_left_corner[ 0 ] + mask_size, top_left_corner[ 1 ] + mask_size) draw.rectangle([top_left_corner, bottom_right_corner], fill= 'white' ) # 異常の種類を定義 anomalies = [ "a crack in the smartphone screen" , ... ] # 画像の生成 for anomaly in anomalies: inpainted_image = pipe( prompt=prompt, image=original_image, mask_image=mask_image, num_inference_steps= 20 , strength= 0.99 , guidance_scale= 10 , ).images[ 0 ] inpainted_image.save(f 'path/to/inpainted_image_{anomaly}.jpg' ) このコードを通じて、特定の異常をシミュレートし、モデルの訓練に役立つ画像を生成できました。 結論：技術の価値と今後の可能性 Stable Diffusion XLのInpaint機能により、異常検知のための学習データ不足という問題に効果的に対処できます。これは品質管理の精度を高め、多くの産業に適用可能です。また画像生成は、異常検知以外にも、新製品のデザインやシミュレーション、エンターテイメント産業など、さまざまな分野での応用が期待されています。今後の動向にも注目していきたいです。