Flamingoとは？
(画像は、Geminiで作成されたものです)
Flamingoの概要
Deep Mindが発表したFlamingo（Alayrac et al., 2022）は、極めて少数の学習サンプル（Few-shot）から新しいマルチモーダルタスクに迅速に適応できる、革新的な視覚言語モデル（VLM）です。新しくゼロから巨大なニューラルネットワークを学習させるための莫大なコストを回避しつつ、高精度な理解・生成能力を実現するために、主に以下の3つの核心的なアプローチを採用しています。
-
凍結（Frozen）された事前学習済みモデルの最大活用
新しくゼロから巨大なモデルを学習させるのは莫大な計算コストがかかります。そこでFlamingoは、すでに学習済みの強力なVisionエンコーダと大規模言語モデル（LLM）をそのまま組み込み、それらのパラメータを固定（凍結）した状態で使用します。これにより、LLMが元々持っている高度な言語生成能力や膨大な知識をそのまま引き継ぐことができます。 -
Perceiver Resamplerによる視覚情報のスマートな圧縮
画像や動画（複数フレーム）は非常に高次元なデータであり、そのままLLMに流し込むとトークン長や計算量が爆発してしまいます。そこでFlamingoはPerceiver Resamplerを導入しました。これにより、入力された任意の解像度や枚数の画像・動画の特徴量を、固定数（例：64個）のビジュアルトークン（視覚的なコンテキスト）へと凝縮し、LLMが処理しやすい形へと最適化します。 -
Gated Cross-Attentionによる言語能力を維持した視覚融合
凍結されたLLMの層の間に、新しい接続道路であるGated Cross-Attention（ゲート付きクロスアテンション） 層を挿入します。この層のゲート値は、学習の初期段階では「0」に設定されています。これにより、学習初期のモデルは「単なるテキストモデル」として完璧に動作し、そこから徐々に視覚情報をブレンドしていくアプローチをとります。結果として、巨大なLLMの言語生成能力を損なう（破滅的忘却などを起こす）ことなく、安全に視覚情報を追加学習させることに成功しました。
本稿では、少数の視覚・テキストのペアを与えるだけで多様な指示に柔軟に対応できるFlamingoの画期的なアーキテクチャとその実装アプローチについて詳しく解説します。
Flamingo(Open Flamingo)の処理概要
⚠️ 技術的な注意点
DeepMindが発表したオリジナルの「Flamingo」のソースコードやモデルの重みは、実際には完全クローズド（非公開）です。
本節では、その論文のアーキテクチャを忠実に再現し、オープンソースとして完全公開されている OpenFlamingo（Awadalla et al., 2023 / OpenFlamingo: An Open-Source Framework for Training Large Autoregressive Vision-Language Models）の実際のソースコードの構造をベースに、Flamingo系モデルがどのように画像と言語を融合させているのか、その処理概要を解説します。
Flamingo（およびOpenFlamingo）は、事前に学習され固定（フリーズ）された「ビジョンエンコーダ（Vision）」と「言語モデル（LLM）」をベースに、それらを繋ぐ独自の「Perceiver Resampler」と「Gated Cross-Attention」層を挿入することで、少数の例（Few-Shot）から文脈を理解するマルチモーダルな入力を効率的に処理するモデルです。
1. ビジョンエンコーダ（Vision）
パイプラインの最上流では、入力された画像（Few-Shotの例示画像およびクエリ画像）の情報を高次元の視覚トークンへと変換します。
- VisionTransformer（OpenAI CLIP等）: 入力された画像群は、まずフリーズされた状態のビジョンエンコーダに送られます。画像はパッチ化され、Transformerブロック、LayerNorm、そして最終的なプロジェクション層を通過することで、固定長の「画像特徴量（Vision Features）」として抽出されます。Flamingoの設計思想に基づき、この領域のパラメータは一切更新（学習）されません。
2. 視覚トークンの圧縮と融合の鍵：Perceiver Resampler（PerceiverResampler クラス）
ビジョン層の直後に位置するのが、モデルの計算効率とマルチモーダル処理の高速性を支える最大の鍵である Perceiver Resampler です。
入力される画像の数や解像度が増えると、視覚トークン数が膨大になり、言語モデル側の計算コスト（コンテキスト長）を圧迫してしまいます。
- 特徴マッピング（Learned Latents）: Perceiver Resamplerは、入力された任意の長さの画像特徴量を、あらかじめ定義された固定数（例: 64トークン）の「学習可能な潜在トークン（Latents）」に対するアテンション（Cross-Attention）を介して、固定の長さへとダウンサンプリング（圧縮・融合）します。
- 役割: これにより、画像の情報を凝縮した一貫性のある「視覚埋め込み（Visual Embeddings）」へと変換し、言語モデル側が受け取りやすい形式へと橋渡しを行います。
3. 言語モデルとGated Cross-Attentionによるマルチモーダル統合（GatedCrossAttentionLayer クラス）
圧縮された視覚埋め込みと言語モデル（LLaMAやMPTなど）は、新しく挿入された「学習可能な層」を介してシームレスに統合されます。OpenFlamingoのコードを見ると、既存のLLM層（フリーズ状態）の直前に、独自のインターリーブ（交互に挟み込む）構造が配置されていることが分かります。
- Gated Cross-Attention（GatedCrossAttentionLayer）: テキストトークンを「Query」、Perceiver Resamplerから出力された視覚埋め込みを「Key / Value」としてクロスアテンションを計算します。これにより、テキストが画像内のどの部分に注目すべきかを動的に処理します。
- ゲートモジュール（Gating / tanh_gating）: クロスアテンションの出力には、学習初期に「0」で初期化された tanh ゲートが適用されます。これにより、学習開始直後は既存のLLMの挙動を全く微調整（破壊）することなく安定させ、学習が進むにつれて徐々に視覚情報をブレンドしていくことが可能になります。
💡 進化した画像シーケンス処理「Image Sequence Handling」
OpenFlamingoのFew-Shot（少数の例示）能力を支えているのが、コード内の media_locations や位置エンコーディングによる時系列・シーケンス管理技術です。 「画像1 ＋ テキスト1 ➔ 画像2 ＋ テキスト2 ➔ クエリ画像 ➔ 最終回答」といった、画像と言語が交互に現れる複雑な文脈において、各テキストトークンが 「自身の直前にある画像」に対してのみ適切にクロスアテンションを向けられるよう、マスキングと位置情報の制御を行います。この高度なシーケンス処理により、複数の画像の関係性や提示された文脈をLLMが正確に把握できるようになります。
4. 言語モデルデコーダと出力生成（Output Generation）
すべてのコンテキスト（視覚情報＋テキスト情報）が融合された特徴量は、最終的に言語モデルのデコーダ層（Self-AttentionやMLP）を通過し、出力ヘッドへと送られます。
- 損失計算（訓練時 / Cosine similarities & Cross Entropy）: 訓練フェーズ（OpenFlamingoチームによる事前学習など）では、マルチモーダルな文脈に基づいたテキスト予測の正確性を測るため、Image-To-Textのクロスエントロピー損失が計算されます。この際、バックプロパゲーションによって更新されるのは、新しく追加された層（Perceiver ResamplerとGated Cross-Attention）のパラメータのみです。
- 生成されたテキスト出力（推論時）: 推論時には、予測された確率スコア（Logits）を元に、次トークン予測を繰り返す自己回帰的な生成（generate）サイクルが回り、提示されたFew-Shotの例にならった「画像には犬が映っています。」といった、画像の文脈を正確に捉えた自然な回答テキストが生成されます。
Flamingo(Open Flamingo)の実装（概念的なシンプルな実装）
本節では、Flamingoの高度な設計思想を直感的に理解するために、PyTorchとHugging FaceのTransformersライブラリを用いた「ミニマムな概念実証（PoC）コード」を実装します。
DeepMindが発表したオリジナルのFlamingo（80B等）のウェイトや、使用されているLLM（Chinchilla）は一般公開されていません。そのため、本記事のハンズオンコードでは、オープンソースで手軽に検証できるよう、Hugging Faceで公開されている軽量な代替モデル（Vision: CLIP, LLM: OPT-125m）を組み合わせてミニマルに再現しています。この実装を通じて、凍結されたVisionエンコーダおよびLLMを、新しく追加する接続層（Perceiver ResamplerとGated Cross-Attention）によってどのように接続・協調動作させるか、その具体的なデータフローとトレーニングの流れを学びます。
概念モデル MiniFlamingo の実装
以下のコードでは、凍結（フリーズ）された CLIP 視覚エンコーダと GPT 系の事前学習済み言語モデル（OPT）を組み合わせた、簡易的な統合モデルである MiniOpenFlamingo クラスを定義します。PyTorchを用いて、画像特徴量を言語モデルの次元数へと射影し、Perceiver Resampler と Gated Cross-Attention を通過させて、視覚情報がシームレスに埋め込まれたテキストトークンをデコーダに流し込む一連のフォワードパスを実装します。
import torch
import torch.nn as nn
from transformers import CLIPVisionModel, AutoProcessor
from transformers import OPTForCausalLM, AutoTokenizer
from datasets import load_dataset
import ast
import matplotlib.pyplot as plt
class MiniOpenFlamingo(nn.Module):
def __init__(self):
super().__init__()
self.vision_encoder = CLIPVisionModel.from_pretrained("openai/clip-vit-base-patch32")
self.llm = OPTForCausalLM.from_pretrained("facebook/opt-125m")
# ビジョンエンコーダとLLMを完全にフリーズ（パラメータ更新しない）
for param in self.vision_encoder.parameters(): param.requires_grad = False
for param in self.llm.parameters(): param.requires_grad = False
vision_dim = self.vision_encoder.config.hidden_size
llm_dim = self.llm.config.hidden_size
self.vis_proj = nn.Linear(vision_dim, llm_dim)
self.perceiver = PerceiverResampler(dim=llm_dim)
self.gated_attn = GatedCrossAttentionLayer(dim=llm_dim)
def forward(self, pixel_values, input_ids, labels=None):
# --- Vision エンコーダ処理 (Frozen) ---
with torch.no_grad():
vis_features = self.vision_encoder(pixel_values).last_hidden_state
vis_features = self.vis_proj(vis_features)
# --- Perceiver Resampler 処理 ---
vis_tokens = self.perceiver(vis_features)
# --- LLM 入力エンベディング処理 (Frozen) ---
with torch.no_grad():
text_embeds = self.llm.get_input_embeddings()(input_ids)
# --- Gated Cross-Attention 処理 ---
# ※注: 実際のOpenFlamingoはLLMの各Transformer層の間にこれを挟み込みますが、
# 簡易版である本コードでは、LLM本体に入力する直前のエンベディング層で視覚情報を統合しています。
fused_embeds = self.gated_attn(text_embeds, vis_tokens)
# --- LLM デコーダ処理 (Frozen) ---
outputs = self.llm(inputs_embeds=fused_embeds, labels=labels)
return outputs
MiniOpenFlamingo クラスは、事前に学習され固定された事前学習済みモデル（Vision EncoderとLLM）を基盤に、マルチモーダル接続層を構築します。
init 内で、ビジョンエンコーダとして CLIPVisionModel.from_pretrained("openai/clip-vit-base-patch32") を、言語モデルとして OPTForCausalLM.from_pretrained("facebook/opt-125m") を初期化し、それらのパラメータ更新を防ぐために requires_grad = False に設定して完全にフリーズしています。 また、ビジョンエンコーダの隠れ層次元 vision_dim から言語モデルの隠れ層次元 llm_dim へのマッピングを行う線形射影層 self.vis_proj を作成します。 さらに、抽出した視覚特徴量を固定数のトークンに圧縮するための PerceiverResampler と、テキスト情報に視覚情報を融合するための GatedCrossAttentionLayer を定義しています。
forward メソッドでは、with torch.no_grad(): のもとでビジョンエンコーダから画像特徴量 vis_features を抽出し、射影層 self.vis_proj に通します。次に、self.perceiver を呼び出して固定数の視覚トークン vis_tokens に圧縮します。 同様に勾配計算を行わずに self.llm.get_input_embeddings() によってテキストの入力埋め込み text_embeds を取得し、self.gated_attn を用いて視覚トークンと融合させた fused_embeds を作成します。 最後に self.llm を呼び出し、融合された埋め込みを inputs_embeds 引数に渡してテキスト予測を行い、出力を返します。
PerceiverResamplerの実装
以下のコードでは、任意の枚数や解像度の画像から抽出された画像特徴量を、固定数の潜在トークン（Latents）へと圧縮・凝縮する PerceiverResampler クラスを実装します。PyTorch のマルチヘッドアテンション（nn.MultiheadAttention）とフィードフォワードネットワーク（FFN）を利用し、計算コストを抑えながらも重要な視覚的コンテキストを抽出・マッピングするプロセスを定義します。
class PerceiverResampler(nn.Module):
"""
任意の長さの画像特徴量を、固定数のLatents（潜在トークン）に圧縮・融合する層
"""
def __init__(self, dim, num_latents=64):
super().__init__()
self.latents = nn.Parameter(torch.randn(1, num_latents, dim))
self.cross_attn = nn.MultiheadAttention(embed_dim=dim, num_heads=4, batch_first=True)
self.ffn = nn.Sequential(
nn.Linear(dim, dim * 2),
nn.GELU(),
nn.Linear(dim * 2, dim)
)
def forward(self, x):
batch_size = x.shape[0]
latents = self.latents.repeat(batch_size, 1, 1)
# LatentsをQuery、画像特徴量をKey/Valueとしてアテンションを計算
attn_out, _ = self.cross_attn(query=latents, key=x, value=x)
return self.ffn(attn_out) + attn_out
PerceiverResampler は、入力される任意の長さ（あるいは異なる解像度や画像枚数）の視覚特徴量を、あらかじめ定められた一定の長さのビジュアルトークン（本コードではデフォルトで64トークン）へ集約・圧縮する役割を持ちます。
クラスの初期化 init 内で、学習可能なパラメータとして self.latents （形状は (1, num_latents, dim)）を定義します。また、圧縮を行うために nn.MultiheadAttention（ヘッド数4）によるクロスアテンション self.cross_attn と、フィードフォワードネットワーク self.ffn を用意しています。
forward メソッドでは、入力されたテンソル x のバッチサイズに合わせて、学習可能な潜在表現 self.latents を repeat(batch_size, 1, 1) を用いてバッチ方向に展開します。 クロスアテンションを計算する際、学習可能な潜在表現 latents を query に指定し、入力特徴量 x を key と value に指定します。これにより、可変長の画像特徴から最も重要かつ凝縮された固定数のアテンション出力 attn_out が抽出されます。 最後に、残差接続を伴うフィードフォワードネットワーク self.ffn(attn_out) + attn_out を通すことで、次元数を保ちつつ特徴表現の非線形性を高めて出力します。
Gated Cross Attention Layerの実装
以下のコードでは、言語モデル（LLM）が持つ本来のテキスト生成能力を破壊しないように配慮しつつ、視覚的コンテキストを動的にブレンドするための GatedCrossAttentionLayer クラスを実装します。PyTorchを用いて、テキストをQuery、視覚トークンをKeyおよびValueとするクロスアテンションを定義し、学習初期値が0である tanh ゲートパラメータを導入して、段階的なマルチモーダル学習を可能にする仕組みを構築します。
class GatedCrossAttentionLayer(nn.Module):
"""
テキストトークンから視覚トークンへアテンションを向け、tanhゲートで統合する層
"""
def __init__(self, dim):
super().__init__()
self.cross_attn = nn.MultiheadAttention(embed_dim=dim, num_heads=4, batch_first=True)
# 学習初期のLLMの挙動を壊さないためのゼロ初期化パラメータ
self.gate_attn = nn.Parameter(torch.zeros(1))
self.ffn = nn.Sequential(
nn.Linear(dim, dim * 2),
nn.GELU(),
nn.Linear(dim * 2, dim)
)
self.gate_ffn = nn.Parameter(torch.zeros(1))
def forward(self, text_features, visual_tokens):
# テキストをQuery、圧縮された視覚トークンをKey/Valueとする
attn_out, _ = self.cross_attn(query=text_features, key=visual_tokens, value=visual_tokens)
# 論文に忠実な tanh ゲーティングの適用
x = text_features + torch.tanh(self.gate_attn) * attn_out
ffn_out = self.ffn(x)
return x + torch.tanh(self.gate_ffn) * ffn_out
GatedCrossAttentionLayer は、言語モデル側のテキスト特徴量に、ビジョンエンコーダおよび Perceiver Resampler を経て得られた視覚情報を注意機構を用いて融合します。
init では、テキストと言語を融合するための nn.MultiheadAttention、アテンション出力を制御するためのゲートパラメータ self.gate_attn（ゼロ初期化）、2層の線形層と GELU 活性化関数からなる self.ffn、そしてFFNの出力を制御するためのゲートパラメータ self.gate_ffn（ゼロ初期化）を用意しています。
forward メソッドでは、テキスト特徴量 text_features を query、圧縮された視覚特徴量 visual_tokens を key および value とすることで、テキストが画像内のどこに焦点を当てるべきかを学習します。
クロスアテンションの出力に対して、パラメータ self.gate_attn に双曲線正接関数を適用した torch.tanh(self.gate_attn) を乗算し、text_features に足し合わせます（残差接続）。
初期状態で self.gate_attn と self.gate_ffn は0に設定されているため、torch.tanh(0) = 0 となり、初期の学習フェーズではアテンション層とFFN層の出力が完全に無視されます。これにより、すでに高い完成度を持つ凍結済みLLMが、学習当初はテキストのみの言語モデルとしてそのまま機能し、破滅的忘却を防ぎながら安全にマルチモーダル情報をブレンドしていくことが可能になっています。
なお、実際のOpenFlamingoでは、この GatedCrossAttentionLayer は入力エンベディングの直後ではなく、LLMの内部（Transformerの各ブロックの間）にインターリーブ（交互に挿入）されます。しかし、それをPyTorchで再現しようとするとLLMの内部コードを書き換える必要があり、コードが非常に複雑になります。
そのため、本記事の簡易コード（MiniOpenFlamingo）では、「入力エンベディング層で一度だけクロスアテンションを計算してからLLMに渡す」という擬似的なアプローチをとることで、難解な内部処理の書き換えを避け、アーキテクチャの本質的なデータフローをシンプルに理解できるように設計しています。
モデルの初期化
ここでは、これまでに実装したカスタムクラスを用いて、簡易的なFlamingo（MiniOpenFlamingo）モデルのインスタンスを生成・初期化します。GPUデバイスの検出を行い、CLIPビジュアルプロセッサおよびOPTトークナイザのロードを行い、モデルの学習可能パラメータのみを最適化対象としたAdamWオプティマイザを設定する準備をします。
# GPUデバイスの設定
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"使用中のデバイス: {device}")
# プロセッサとトークナイザの準備
processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")
tokenizer = AutoTokenizer.from_pretrained("facebook/opt-125m")
if tokenizer.pad_token is None:
tokenizer.pad_token = tokenizer.eos_token
model = MiniOpenFlamingo().to(device, dtype=torch.float32)
trainable_params = [p for p in model.parameters() if p.requires_grad]
optimizer = torch.optim.AdamW(trainable_params, lr=1e-3)
まず torch.device を使用して、GPUが利用可能であれば cuda を、利用不可であれば cpu を演算デバイス device として設定しています。
画像前処理用の AutoProcessor には openai/clip-vit-base-patch32 を、テキストトークナイズ用の AutoTokenizer には facebook/opt-125m をロードしています。OPTトークナイザはパディング用のトークンがデフォルトで定義されていない場合があるため、tokenizer.pad_token = tokenizer.eos_token として文末トークンをパディングに代用しています。
MiniOpenFlamingo() インスタンスを構築し、.to(device, dtype=torch.float32) によって指定されたデバイスに配置します。 パラメータ全体の中から、勾配計算が必要（フリーズされていない、すなわち requires_grad = True）なパラメータのみをリスト内包表記を用いて抽出し、リスト trainable_params に格納しています。 最適化アルゴリズムには torch.optim.AdamW を採用し、学習可能パラメータのみを更新対象とし、初期学習率を 1e-3 に指定してオプティマイザ optimizer を初期化しています。
データセットの読み込みとモデルの訓練
本記事で使用する「MMMU」データセットは、クリエイティブ・コモンズ（CC BY-NC-SA 4.0）ライセンスの下で提供されています。非商用目的のみに限定されており、商用・営利目的での利用には制限があります。詳細は記事の末尾に記載しています。
本記事で使用しているデータセットは,lmms-labが公開している MMMU (Massive Multi-discipline Multimodal Understanding) です。
- ライセンス: CC BY-NC-SA 4.0 (クリエイティブ・コモンズ 表示 - 非営利 - 継承 4.0 国際) に準拠しています。（※本コードやデータセット、検証用モデルは非商用ライセンスに基づいているため、商用目的での利用には制限があります）
- 引用元: MMMU Project Page / Hugging Face Dataset
以下のコードでは、Hugging Faceの datasets ライブラリを使用して高度なマルチモーダルベンチマークである MMMU データセット（Computer Science領域）を読み込み、モデルの訓練プロセス（過学習による適合検証）を実行します。取得した訓練データを画像とプロンプトテキストに整形し、matplotlibによる画像のプレビュー、入力トークンの処理とパディング、および損失計算と誤差逆伝播（Backpropagation）を50エポックにわたりループ処理する流れを示します。
💡 実験コードに関する技術的な注記
本記事で紹介しているコードは、AIモデルが「視覚情報」と「テキスト情報」を正しく融合して学習できているかを視覚的に確認（Sanity Check）するため、あえて単一のデータに対して過学習（Overfitting） させています。
実際のマルチモーダルAIの訓練や実用的な推論能力の獲得には、数百万〜数十億規模の多様なデータセットでの事前学習が必要となります。
# --- MMMUデータセットのロードと準備 ---
print("\nMMMUデータセットをダウンロード中...")
dataset = load_dataset("MMMU/MMMU", "Computer_Science", split="dev")
# 最初のサンプルを取得
sample = dataset[0]
# 画像の処理 (RGBAなどをRGBに変換してエラーを防ぐ)
raw_image = sample["image_1"].convert("RGB")
pixel_values = processor(images=raw_image, return_tensors="pt").pixel_values.to(device, dtype=torch.float32)
plt.figure(figsize=(8, 8)) # ウィンドウのサイズを少し大きめに設定
plt.imshow(raw_image) # 画像を描画
plt.title("MMMU Training Image Preview") # タイトルを設定
plt.axis("off") # 画像なのでXY軸の目盛りを非表示にする
plt.show()
# テキストのフォーマット作成 (質問 + 選択肢 -> 答え)
question = sample["question"]
raw_options = sample["options"]
answer = sample["answer"]
# 1. optionsが文字列( "['Phone', ...]" )の場合はリストに変換
if isinstance(raw_options, str):
try:
options_list = ast.literal_eval(raw_options)
except (ValueError, SyntaxError):
options_list = [] # パース失敗時のフォールバック
else:
options_list = raw_options
# 2. リストを "A. Phone", "B. Ssn" の形式にフォーマット
formatted_options = ""
for i, opt in enumerate(options_list):
label = chr(ord('A') + i) # i=0なら'A', i=1なら'B'...
formatted_options += f"{label}. {opt}\n"
# 3. 推論時にLLMに与えるプロンプト（正解を含まない）
prompt_text = f"Question: {question}\nOptions:\n{formatted_options.strip()}\nAnswer:"
# 学習時にLLMに与えるフルテキスト（正解を含む）
full_text = f"{prompt_text} {answer}"
# MMMUの長文に対応するため max_length を 256 に拡張
max_length = 256
inputs = tokenizer(
full_text,
return_tensors="pt",
max_length=max_length,
truncation=True,
padding="max_length"
)
input_ids = inputs.input_ids.to(device)
labels = input_ids.clone()
labels[labels == tokenizer.pad_token_id] = -100
print("\n--- [1] 過学習スタート (MMMU CS Data) ---")
model.train()
epochs = 50 # 問題が複雑なため少しエポック数を増やします
for epoch in range(epochs):
optimizer.zero_grad()
outputs = model(pixel_values=pixel_values, input_ids=input_ids, labels=labels)
loss = outputs.loss
loss.backward()
optimizer.step()
if (epoch + 1) % 5 == 0:
print(f"Epoch {epoch+1:02d} | Loss: {loss.item():.4f} | ゲート値: {model.gated_attn.gate_attn.item():.4f}")
Hugging Faceの load_dataset を用いてマルチモーダルな推論性能を問う MMMU/MMMU ベンチマークの「Computer Science」タスクから検証用のデータをロードしています。
sample = dataset[0] から画像を抽出し、アルファチャンネル等の処理不具合を避けるために .convert("RGB") を適用してRGB形式に変換。これを processor に渡して形状変換・正規化されたテンソル pixel_values を作成します。 データの視覚的確認のために matplotlib.pyplot を用いて画像をウィンドウに描画し、座標軸を plt.axis("off") で非表示にして plt.show() で出力しています。
データセット内の question、options、answer を取り出します。options が文字列形式のリスト表現になっている可能性があるため、ast.literal_eval を使って安全にPythonのリストオブジェクトへデコードします。 リスト化された選択肢に対して、順番にアルファベット（A, B, C...）を割り当てるフォーマット処理を行い、推論用プロンプトテキスト prompt_text と、正解ラベルを付加した訓練用フルテキスト full_text を作成します。
tokenizer を用いて full_text をトークンIDシーケンス input_ids に変換します。このとき長文による途切れを防ぐため、最大長 max_length = 256 で切り詰め（truncation=True）とパディング（padding="max_length"）を行います。 ターゲットラベル labels は、input_ids のコピーから作成し、パディング部分を損失計算から除外するため、PyTorch の交差エントロピー損失の無視インデックスに相当する値である -100 に置き換えています。
モデルを model.train() モードに切り替え、50エポックの学習ループを開始します。 各エポックで optimizer.zero_grad() を呼び出し、勾配情報をリセットしてから、画像テンソルとトークンIDをモデルに流し込み、予測損失 outputs.loss を計算。loss.backward() により誤差を逆伝播させ、optimizer.step() でパラメータを更新します。5エポックごとに、現在の損失値とゲート係数のパラメータ gate_attn の変化を標準出力にプリントしています。
推論テスト
以下のコードでは、過学習（訓練）を終えた簡易Flamingoモデルを評価モード（eval）へと切り替え、MMMUデータセットの画像と質問（正解を含まないプロンプト）を元に、次トークン予測を行う推論処理を実行します。言語モデルのテキスト生成メソッド（generate）を呼び出し、モデルから予測された回答を取得・クリーニングして、実際の正解ラベルと比較検証するまでの一連の流れを定義しています。
print("\n--- [2] 推論テスト (Eval Mode) ---")
model.eval()
prompt_inputs = tokenizer(prompt_text, return_tensors="pt")
prompt_ids = prompt_inputs.input_ids.to(device)
with torch.no_grad():
vis_features = model.vision_encoder(pixel_values).last_hidden_state
vis_features = model.vis_proj(vis_features)
vis_tokens = model.perceiver(vis_features)
text_embeds = model.llm.get_input_embeddings()(prompt_ids)
fused_embeds = model.gated_attn(text_embeds, vis_tokens)
# 新たに生成するトークンは選択肢(A, B, Cなど)を想定し少なめに設定
generated_ids = model.llm.generate(
inputs_embeds=fused_embeds,
max_new_tokens=1,
pad_token_id=tokenizer.pad_token_id,
eos_token_id=tokenizer.eos_token_id
)
raw_generated_text = tokenizer.decode(generated_ids[0], skip_special_tokens=True).strip()
# 余計な改行や記号を取り除き、最初の1文字（A~Eなど）だけを抽出
# 英字のみを抽出する場合の安全な処理
clean_answer = ""
for char in raw_generated_text:
if char.isalpha():
clean_answer = char.upper()
break
print("\n[入力プロンプト]")
print(prompt_text)
print(f"\n[実際の正解]: {answer}")
print(f"[AIの予測出力]: {clean_answer}") # クリーニングした変数を表示
推論時の不要な勾配計算を防ぎメモリを節約するため、モデルを評価モード model.eval() に設定します。
質問テキスト prompt_text をトークナイズし、テンソル prompt_ids を準備します。 with torch.no_grad(): の下で、訓練時と同様にビジョンエンコーダから特徴量を抽出し、リサンプラ model.perceiver を経て圧縮視覚トークン vis_tokens を得ます。 言語モデルの入力埋め込み text_embeds をテキストトークンから取り出し、model.gated_attn によって視覚トークンをマージした融合埋め込み fused_embeds を構築します。
得られた埋め込みを言語モデルのデコーダへ入力し、次トークンの自己回帰生成を行うため model.llm.generate を呼び出しています。この時、質問に対する回答が「A」や「B」などの一文字の選択肢であると想定されているため、生成する最大トークン数を max_new_tokens=1 に設定して推論処理を効率化しています。
生成されたトークンIDを tokenizer.decode によって文字列表現にデコードし、不要な特殊トークンを除去した raw_generated_text を得ます。 得られたテキストから英字（選択肢に該当する文字）を検出し、大文字に揃えるクレンジング処理を施して、clean_answer として格納しています。 最終的に、提示した質問テキスト、人間による正しい解答ラベル、およびモデルの予測値を並べて画面に出力しています。
実行結果
上記のコードを実行すると以下の結果が得られます。
使用中のデバイス: cuda
MMMUデータセットをダウンロード中...
(⚠️ 著作権に関するご注意：データセット内に含まれる画像や問題文の著作権は、それぞれの原著作者に帰属します。本記事では、マルチモーダルAIの学習プロセスを解説する研究・教育目的（引用の範囲内）として、データセットの一部（dev スプリットのサンプル）を可視化・利用しています。)
--- [1] 過学習スタート (MMMU CS Data) ---
Epoch 05 | Loss: 3.9198 | ゲート値: 0.0029
Epoch 10 | Loss: 3.2432 | ゲート値: 0.0025
Epoch 15 | Loss: 2.9413 | ゲート値: 0.0022
Epoch 20 | Loss: 2.5325 | ゲート値: 0.0020
Epoch 25 | Loss: 2.2604 | ゲート値: 0.0017
Epoch 30 | Loss: 1.8719 | ゲート値: 0.0016
Epoch 35 | Loss: 1.6544 | ゲート値: 0.0014
Epoch 40 | Loss: 1.5006 | ゲート値: 0.0010
Epoch 45 | Loss: 1.1997 | ゲート値: 0.0005
Epoch 50 | Loss: 0.8612 | ゲート値: 0.0004
--- [2] 推論テスト (Eval Mode) ---
[入力プロンプト]
Question: What is the key attribute for the CUSTOMER entity in the entity-relationship (ER) diagram in <image 1>?
Options:
A. Phone
B. Ssn
C. Name
D. Addr
E. None of the other answers
Answer:
[実際の正解]: B
[AIの予測出力]: B
実行ログから明らかなように、5エポック時点の予測損失は 3.9198 程度であったが、50エポックにわたる訓練を経て 0.8612 まで大幅に低下していることが確認できます。
これと並行して、初期状態では 0 に固定されていたクロスアテンション層のゲート係数 gate_attn の値が、50エポック終了時点で 0.0004（5エポック時点では 0.0029）へと変化しています。これは、誤差逆伝播によってゲートパラメータが更新され、凍結された言語モデルに対して、画像から圧縮抽出された視覚情報が徐々に影響を与え始めた（ブレンドされた）ことを示しています。
推論テストの結果を確認すると、入力された ER 図の画像情報と、「CUSTOMER エンティティの主キー属性は何か」という質問、および選択肢「A. Phone」「B. Ssn」などのコンテキストをモデルが正確に踏まえています。 出力生成においては、過学習された1枚のサンプルに対する結果ではありますが、モデルが正解である B（Ssn）を的確に予測することに成功しています。これにより、フリーズされた強力な Vision-Language のパラメータを崩すことなく、新規に挿入された Perceiver Resampler と Gated Cross Attention の学習のみで、特定の視覚質問応答タスクに適合させることが可能であるという Flamingo の設計思想の正しさが、ミニマムな実装によって実証されています。
実際のOpen Flamingoを用いたFew-Shot Learningと推論テスト
Flamingoのシンプルなアーキテクチャで概念を学んだところで、実際にOpen Flamingoを用いてFew-Shot Learningと推論テストを実行してみましょう。 以下のコードはGoogle Colaboratory ProのA100のGPUを用いて実行しました。
関連ライブラリのインストール
# 1. OpenFlamingo本体を依存関係無視でインストール
!pip install --no-deps git+https://github.com/mlfoundations/open_flamingo.git
# 2. 必要な関連ライブラリを個別にインストール
!pip install datasets huggingface_hub einops accelerate Pillow
!pip install einops-exts open-clip-torch
Open Flamingoの実行コード
import sys
import types
import torch
import transformers
import importlib
# パッチ1: triton_pre_mlir のダミー化
sys.modules['triton_pre_mlir'] = types.ModuleType('triton_pre_mlir')
# パッチ2: 最新transformers向けに古い関数を自作
def _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len=None):
bsz, src_len = mask.size()
tgt_len = tgt_len if tgt_len is not None else src_len
expanded_mask = mask[:, None, None, :].expand(bsz, 1, tgt_len, src_len).to(dtype)
inverted_mask = 1.0 - expanded_mask
return inverted_mask.masked_fill(inverted_mask.to(torch.bool), torch.finfo(dtype).min)
def _make_causal_mask(input_ids_shape, dtype: torch.dtype, device: torch.device, past_key_values_length: int = 0):
bsz, tgt_len = input_ids_shape
mask = torch.full((tgt_len, tgt_len), torch.finfo(dtype).min, device=device)
mask_cond = torch.arange(mask.size(-1), device=device)
mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0)
mask = mask.to(dtype)
if past_key_values_length > 0:
mask = torch.cat([torch.zeros(tgt_len, past_key_values_length, dtype=dtype, device=device), mask], dim=-1)
return mask[None, None, :, :].expand(bsz, 1, tgt_len, tgt_len + past_key_values_length)
# パッチ3: MPTが読み込みそうな「すべてのモジュール」に強制注入
modules_to_patch = [
"transformers.models.bloom.modeling_bloom",
"transformers.models.opt.modeling_opt",
"transformers.models.gptj.modeling_gptj",
"transformers.models.gpt_neox.modeling_gpt_neox"
]
for mod_name in modules_to_patch:
try:
mod = importlib.import_module(mod_name)
mod._expand_mask = _expand_mask
mod._make_causal_mask = _make_causal_mask
mod.logging = transformers.utils.logging
except Exception:
pass
# パッチ4: MPTConfigの属性エラー回避（MPTはTrueが必須）
transformers.PretrainedConfig.tie_word_embeddings = True
# パッチ5: 最新Hugging Faceの内部処理用プロパティをダミー化（辞書型に修正！）
transformers.PreTrainedModel.all_tied_weights_keys = property(lambda self: {})
import ast
from PIL import Image
from datasets import load_dataset
from huggingface_hub import hf_hub_download
from open_flamingo import create_model_and_transforms
print("モデルを初期化中...")
model, image_processor, tokenizer = create_model_and_transforms(
clip_vision_encoder_path="ViT-L-14",
clip_vision_encoder_pretrained="openai",
lang_encoder_path="anas-awadalla/mpt-7b",
tokenizer_path="anas-awadalla/mpt-7b",
cross_attn_every_n_layers=4
)
print("重みをダウンロード中...")
checkpoint_path = hf_hub_download("openflamingo/OpenFlamingo-9B-vitl-mpt7b", "checkpoint.pt")
# 【↓ここに追加↓】モデルの語彙サイズをチェックポイント(50280)に強制的に合わせる
model.lang_encoder.resize_token_embeddings(50280)
# 重みのロード
model.load_state_dict(torch.load(checkpoint_path), strict=False)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
model.eval()
tokenizer.padding_side = "left"
print("データセットをロード中...")
dataset = load_dataset("MMMU/MMMU", "Computer_Science", split="dev")
def format_options(options_str):
if isinstance(options_str, str):
try:
options_list = ast.literal_eval(options_str)
except:
options_list = []
else:
options_list = options_str
formatted = ""
for i, opt in enumerate(options_list):
label = chr(ord('A') + i)
formatted += f"{label}. {opt}\n"
return formatted.strip()
num_shots = 2
prompt_text = ""
image_list = []
for i in range(num_shots):
sample = dataset[i]
q = sample["question"]
ans = sample["answer"]
opts = format_options(sample["options"])
raw_image = sample["image_1"].convert("RGB")
image_list.append(raw_image)
prompt_text += f"<image>Question: {q}\nOptions:\n{opts}\nAnswer: {ans}<|endofchunk|>"
target_sample = dataset[num_shots]
target_q = target_sample["question"]
target_ans = target_sample["answer"]
target_opts = format_options(target_sample["options"])
target_image = target_sample["image_1"].convert("RGB")
image_list.append(target_image)
prompt_text += f"<image>Question: {target_q}\nOptions:\n{target_opts}\nAnswer:"
print("\n--- [構築されたプロンプト] ---")
print(prompt_text)
encodings = tokenizer(
prompt_text,
return_tensors="pt",
padding=True,
truncation=True
)
input_ids = encodings["input_ids"].to(device)
attention_mask = encodings["attention_mask"].to(device)
vision_x = [image_processor(img).unsqueeze(0) for img in image_list]
vision_x = torch.cat(vision_x, dim=0)
vision_x = vision_x.unsqueeze(1).unsqueeze(0)
vision_x = vision_x.to(device)
print("\n--- 推論開始 ---")
# 【↓ここに追加↓】最新仕様に合わせて、MPTモデルに生成機能を強制的に継承させる
from transformers.generation import GenerationMixin
if GenerationMixin not in model.lang_encoder.__class__.__bases__:
model.lang_encoder.__class__.__bases__ += (GenerationMixin,)
with torch.inference_mode():
generated_ids = model.generate(
vision_x=vision_x,
lang_x=input_ids,
attention_mask=attention_mask,
max_new_tokens=2, # AやBなどの記号のみを生成
num_beams=3, # ビームサーチで精度を少し上げる
)
generated_text = tokenizer.decode(
generated_ids[0][input_ids.shape[1]:],
skip_special_tokens=True
).strip()
clean_answer = ""
for char in generated_text:
if char.isalpha():
clean_answer = char.upper()
break
print(f"\n[実際の正解]: {target_ans}")
print(f"[AIの予測出力]: {clean_answer}")
上記のOpenFlamingo（MPT-7Bベース）の実行コードには、通常のライブラリインポートに加えて、特殊なインストールオプションと「モンキーパッチ（プログラムの動的書き換え）」が含まれています。 これらは、「数年前に開発されたモデルの古いコード」と「現在の最新のPython/Hugging Face環境」の間で発生する互換性エラーを解消するための必須処理です。それぞれの背景について解説します。
1. 依存関係を無視したインストール（--no-deps）
!pip install --no-deps git+https://github.com/mlfoundations/open_flamingo.git
【理由】PyTorchのダウングレードによる環境破壊を防ぐため OpenFlamingoの公式パッケージは、内部で古いバージョンのPyTorch（torch==2.0.1）を厳密に要求します。しかし、現在のGoogle Colab（Python 3.12環境）に古いPyTorchをそのままインストールしようとすると競合が発生します。 そのため、--no-deps オプションで「OpenFlamingo本体のコード」のみを強制ダウンロードし、PyTorchなどの重いライブラリはColabに最初から入っている最新版をそのまま流用することで、環境をクリーンに保っています。
2. Hugging Faceの厳格なインポートチェックの回避（パッチ1）
sys.modules['triton_pre_mlir'] = types.ModuleType('triton_pre_mlir')
【理由】存在しないレガシーモジュールへの参照エラーをスキップするため MPTモデルの古いソースコード内には、推論時には使用しない triton_pre_mlir という過去の最適化モジュールの名前が残っています。最新の transformers ライブラリはこれを検知すると「必要なパッケージが足りない」と強制的にエラー（ImportError）を出してしまいます。そこで、空のダミーモジュールをシステムに登録し、チェックをすり抜けさせています。
3. 廃止された内部関数の自己定義と注入（パッチ2・3）
def _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len=None):
def _make_causal_mask(input_ids_shape, dtype: torch.dtype, device: torch.device, past_key_values_length: int = 0):
_expand_maskと_make_causal_maskの自作と、各モジュールへの強制注入 【理由】Transformersのアップデートに伴う内部関数の消失を補うため 本来であれば、モデルが作られた当時の古い transformers にダウングレードするのが定石ですが、Colab（Python 3.12）では古いライブラリが要求するC++系のビルド（Rustコンパイラ等）が通らずインストールできません。 そこで、最新の transformers 環境を維持したまま、モデルが要求する古い内部関数（_expand_mask や _make_causal_mask）をPythonコード上で自作し、bloom や opt などの各モデルクラスへ動的に注入（モンキーパッチ）して補完しています。
4. 不足しているConfigプロパティの補完（パッチ4・5）
transformers.PretrainedConfig.tie_word_embeddings = True
transformers.PreTrainedModel.all_tied_weights_keys = property(lambda self: {})
【理由】最新Hugging Faceの必須パラメータ仕様に対応するため 最新の transformers は、モデルを初期化する際に「重みの共有設定（tie_word_embeddings）」と「その対象リスト（all_tied_weights_keys）」が設定ファイルに存在することを前提として動きます。 古いMPTモデルのConfigにはこれらの記述がないため属性エラー（AttributeError）になります。モデル側の仕様に合わせて基底クラスに直接 True と空の辞書 を流し込むことで、最新の初期化プロセスを無事に通過させています。
モンキーパッチを適用した後、実際のFew-Shot推論処理が始まります。 ast.literal_eval は、データセット内の選択肢（例: "['Phone', 'Ssn', ...]"）が文字列として格納されている場合に、それを安全にPythonのリストオブジェクトへと変換するために使用されます。 format_options 関数は、このリストを受け取り、「A. Phone」「B. Ssn」のような整形済みテキストを生成します。
推論プロンプトは、num_shots=2 の設定に基づき、2つの「画像＋質問＋正解」のペアをデモンストレーション（Few-Shotの例）として構築します。 ループ内でデータセットからサンプルを抽出し、整形済みの質問・選択肢・正解を prompt_text に追加し、対応する画像を image_list に格納しています。最後に、実際に解かせたい3番目のサンプル（target_sample）の「画像＋質問（正解なし）」をプロンプトの末尾に結合します。
tokenizer と image_processor は、それぞれ構築されたプロンプトテキストと画像リストを、モデルが解釈できるテンソル形式（input_ids, vision_x）へと変換します。 model.generate メソッドが実際の推論を実行します。このとき、Few-Shotのコンテキスト（vision_x, lang_x）が入力され、max_new_tokens=2 で生成するテキストを短く（選択肢のA, Bなど）制限し、num_beams=3 のビームサーチで回答の精度を高めています。 最後に、生成されたトークンIDを tokenizer.decode で文字列に戻し、不要な部分を削ぎ落として予測結果 clean_answer を抽出し、実際の正解 target_ans と比較しています。
なお、上記の特殊インストールオプション適用前の関連ライブラリのバージョン等は以下の通りでした。
関連ライブラリのバージョン
import sys
import torch
import transformers
print(f"■ Python バージョン: {sys.version.split()[0]}")
print(f"■ PyTorch バージョン: {torch.__version__}")
print(f"■ Transformers バージョン: {transformers.__version__}")
print(f"■ CUDAが利用可能か: {torch.cuda.is_available()}")
実行結果
■ Python バージョン: 3.12.13
■ PyTorch バージョン: 2.11.0+cu128
■ Transformers バージョン: 5.12.1
■ CUDAが利用可能か: True
torch, transformersの詳細情報
!pip show torch transformers
実行結果
Name: torch
Version: 2.11.0+cu128
Summary: Tensors and Dynamic neural networks in Python with strong GPU acceleration
Home-page: https://pytorch.org
Author:
Author-email: PyTorch Team <packages@pytorch.org>
License: BSD-3-Clause
Location: /usr/local/lib/python3.12/dist-packages
Requires: cuda-bindings, cuda-toolkit, filelock, fsspec, jinja2, networkx, nvidia-cudnn-cu12, nvidia-cusparselt-cu12, nvidia-nccl-cu12, nvidia-nvshmem-cu12, setuptools, sympy, triton, typing-extensions
Required-by: accelerate, fastai, peft, sentence-transformers, timm, torchdata, torchvision
---
Name: transformers
Version: 5.12.1
Summary: Transformers: the model-definition framework for state-of-the-art machine learning models in text, vision, audio, and multimodal models, for both inference and training.
Home-page: https://github.com/huggingface/transformers
Author: The Hugging Face team (past and future) with the help of all our contributors (https://github.com/huggingface/transformers/graphs/contributors)
Author-email: transformers@huggingface.co
License: Apache 2.0 License
Location: /usr/local/lib/python3.12/dist-packages
Requires: huggingface-hub, numpy, packaging, pyyaml, regex, safetensors, tokenizers, tqdm, typer
Required-by: peft, sentence-transformers
CUDAバージョン
!nvcc --version
実行結果
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2025 NVIDIA Corporation
Built on Fri_Feb_21_20:23:50_PST_2025
Cuda compilation tools, release 12.8, V12.8.93
Build cuda_12.8.r12.8/compiler.35583870_0
Open Flamingoの実行結果
モデルを初期化中...
Flamingo model initialized with 1384777744 trainable parameters
重みをダウンロード中...
[transformers] The new embeddings will be initialized from a multivariate normal distribution that has old embeddings' mean and covariance. As described in this article: https://nlp.stanford.edu/~johnhew/vocab-expansion.html. To disable this, use `mean_resizing=False`
データセットをロード中...
--- [構築されたプロンプト] ---
<image>Question: What is the key attribute for the CUSTOMER entity in the entity-relationship (ER) diagram in <image 1>?
Options:
A. Phone
B. Ssn
C. Name
D. Addr
E. None of the other answers
Answer: B<|endofchunk|><image>Question: The <image 1> shows the truth table and calculation circuit diagram for the addition of 1-digit integers. What is the simple circuit that the diagram represents usually called?
Options:
A. half adder
B. full adder
Answer: A<|endofchunk|><image>Question: How many context switches are required in the last row of <image 1>?
Options:
A. 0
B. 1
C. 2
D. None of the other answers
Answer:
[実際の正解]: D
[AIの予測出力]: C
実行ログに示されている通り、2つのデモンストレーション（Few-Shot例）を含むプロンプトが構築され、3つ目の質問に対して推論が実行されました。結果は、実際の正解が D であったのに対し、AIの予測出力は C となり、この問題には不正解でした。
しかし、これは環境構築の失敗やモデルの異常を意味するものではありません。今回使用している MMMU (Massive Multi-discipline Multimodal Understanding) データセットは、様々な分野の大学レベルの専門知識を問う、極めて高難易度のマルチモーダルベンチマークです。実際、論文によれば、今回使用したOpenFlamingo-9B（90億パラメータ）クラスのモデルでも、MMMUに対する正解率は30%〜40%程度と報告されています。これは4択問題であれば、ランダムに回答するより少し良い程度のスコアです。
したがって、1つのサンプルで不正解だったからといって、モデルや環境が正しく機能していないと判断するのは早計です。むしろ、この結果は、現在のモデルが直面している課題の大きさと、MMMUベンチマークの難易度の高さを如実に示していると言えます。
まとめ
Flamingoは、既存の強力な事前学習済み Vision モデルと言語モデル（LLM）をフリーズしてそのまま活用しながら、マルチモーダル表現の動的マッピングを可能にするアーキテクチャです。
- 効率的な視覚情報の圧縮: Perceiver Resampler によって画像や動画の多次元で可変な特徴量を、計算効率の高い固定数の潜在トークンへと効果的に圧縮・表現します。
- 言語能力の維持と破滅的忘却の防止: 凍結されたLLMの層に挿入される Gated Cross-Attention（および
tanhゲート）が、既存の高度なテキスト生成能力を一切損なうことなく、段階的かつ安定的に視覚情報のブレンドを可能にしています。 - 少数のパラメータ学習による適応: 概念モデルを用いた過学習実験からも確認できるように、追加の接続層（リサンプラおよびクロスアテンションゲート）のわずかなパラメータのみを更新することで、少数の例（Few-shot）や特定のマルチモーダル問題（MMMUなど）に対してモデルを迅速かつ効果的に適合させることが可能です。
Flamingoに代表される「凍結＋インターリーブ＋ゲート接続」のアプローチは、昨今の極めて大規模なマルチモーダル基盤モデル（VLM）の効率的な学習と適応における強力なパラダイムであり、現在の最先端モデルの多くにその設計思想が引き継がれています。
参考文献・引用 / References
本記事で紹介した内容や、OpenFlamingoのリポジトリ、あるいはオリジナルのFlamingo論文を引用・参照される際は、以下の参考文献リスト、または折りたたみ内のBibTeX情報をご利用ください。
- Jean-Baptiste Alayrac, et al. (2022). Flamingo: a Visual Language Model for Few-Shot Learning. ArXiv, abs/2204.14198.
https://arxiv.org/abs/2204.14198 - Anas Awadalla, et al. (2023). OpenFlamingo: An Open-Source Framework for Training Large Autoregressive Vision-Language Models. arXiv preprint arXiv:2308.01390.
https://arxiv.org/abs/2308.01390 - Anas Awadalla, et al. (2023). OpenFlamingo (Version v0.1.1) [Software]. Zenodo.
https://doi.org/10.5281/zenodo.7733589
BibTeXをコピーする
@article{Alayrac2022FlamingoAV,
title={Flamingo: a Visual Language Model for Few-Shot Learning},
author={Jean-Baptiste Alayrac and Jeff Donahue and Pauline Luc and Antoine Miech and Iain Barr and Yana Hasson and Karel Lenc and Arthur Mensch and Katie Millican and Malcolm Reynolds and Roman Ring and Eliza Rutherford and Serkan Cabi and Tengda Han and Zhitao Gong and Sina Samangooei and Marianne Monteiro and Jacob Menick and Sebastian Borgeaud and Andy Brock and Aida Nematzadeh and Sahand Sharifzadeh and Mikolaj Binkowski and Ricardo Barreira and Oriol Vinyals and Andrew Zisserman and Karen Simonyan},
journal={ArXiv},
year={2022},
volume={abs/2204.14198}
}
@article{awadalla2023openflamingo,
title={OpenFlamingo: An Open-Source Framework for Training Large Autoregressive Vision-Language Models},
author={Anas Awadalla and Irena Gao and Josh Gardner and Jack Hessel and Yusuf Hanafy and Wanrong Zhu and Kalyani Marathe and Yonatan Bitton and Samir Gadre and Shiori Sagawa and Jenia Jitsev and Simon Kornblith and Pang Wei Koh and Gabriel Ilharco and Mitchell Wortsman and Ludwig Schmidt},
journal={arXiv preprint arXiv:2308.01390},
year={2023}
}
@software{anas_awadalla_2023_7733589,
author = {Awadalla, Anas and Gao, Irena and Gardner, Joshua and Hessel, Jack and Hanafy, Yusuf and Zhu, Wanrong and Marathe, Kalyani and Bitton, Yonatan and Gadre, Samir and Jitsev, Jenia and Kornblith, Simon and Koh, Pang Wei and Ilharco, Gabriel and Wortsman, Mitchell and Schmidt, Ludwig},
title = {OpenFlamingo},
month = mar,
year = 2023,
publisher = {Zenodo},
version = {v0.1.1},
doi = {10.5281/zenodo.7733589},
url = {https://doi.org/10.5281/zenodo.7733589}
}
出典・ライセンスについて
- MMMUデータセット: lmms-labによって提供されているマルチモーダルベンチマークデータセット MMMU/MMMU（CC BY-NC-SA 4.0）を使用しています。本検証コードおよび検証用データは非商用目的での利用に限られます。
本記事の文章・構成の一部に生成AIを使用しています。