QVQ モデルの使用法 - Alibaba Cloud Model Studio - Alibaba Cloud ドキュメントセンター

QVQ モデルは強力な視覚的推論機能を備えています。最初に思考プロセスを出力し、次に応答内容を出力します。現在、QVQ はストリーミング出力のみをサポートしています。

対応モデル

QVQ は、視覚的入力と連鎖的思考出力をサポートする視覚的推論モデルです。数学、プログラミング、視覚分析、創作、および一般的なタスクにおいて、より強力な機能を発揮します。

名前	バージョン	コンテキストウィンドウ	最大入力	最大 CoT	最大応答	入力価格	出力価格	無料枠 (注)
		(トークン)				(百万トークン)
qvq-max qvq-max-2025-03-25 と同じパフォーマンス	安定版	131,072	106,496 画像あたり最大 16,384	16,384	8,192	$1.2	$4.8	それぞれ 100 万トークンアクティベーション後 180 日間有効
qvq-max-latest 常に最新のスナップショットと同じパフォーマンス	最新版
qvq-max-2025-03-25 qvq-max-0325 とも呼ばれます	スナップショット

画像と動画のトークンを計算する

画像

28 × 28 ピクセルごとに 1 トークンに相当し、画像は少なくとも 4 トークンが必要です。次のコードを使用して、画像のトークンを推定できます。

Python

import math
# Pillow ライブラリをインストールするには、次のコマンドを使用します。pip install Pillow
from PIL import Image

def token_calculate(image_path):
    # 指定された PNG 画像ファイルを開きます
    image = Image.open(image_path)

    # 画像の元の寸法を取得します
    height = image.height
    width = image.width
    
    # 高さを 28 の倍数に調整します
    h_bar = round(height / 28) * 28
    # 幅を 28 の倍数に調整します
    w_bar = round(width / 28) * 28
    
    # 画像の最小トークン制限：4 トークン
    min_pixels = 28 * 28 * 4
    # 画像の最大トークン制限：1280 トークン
    max_pixels = 1280 * 28 * 28
        
    # 画像をスケーリングして、ピクセル総数が [min_pixels、max_pixels] の範囲内にあることを確認します
    if h_bar * w_bar > max_pixels:
        # スケーリング係数 beta を計算して、スケーリングされた画像のピクセル総数が max_pixels を超えないようにします
        beta = math.sqrt((height * width) / max_pixels)
        # 調整された高さを再計算し、28 の倍数であることを確認します
        h_bar = math.floor(height / beta / 28) * 28
        # 調整された幅を再計算し、28 の倍数であることを確認します
        w_bar = math.floor(width / beta / 28) * 28
    elif h_bar * w_bar < min_pixels:
        # スケーリング係数 beta を計算して、スケーリングされた画像のピクセル総数が min_pixels 以上になるようにします
        beta = math.sqrt(min_pixels / (height * width))
        # 調整された高さを再計算し、28 の倍数であることを確認します
        h_bar = math.ceil(height * beta / 28) * 28
        # 調整された幅を再計算し、28 の倍数であることを確認します
        w_bar = math.ceil(width * beta / 28) * 28
    return h_bar, w_bar

# test.png をローカル画像のパスに置き換えます
h_bar, w_bar = token_calculate("test.png")
print(f"スケーリングされた画像の寸法：高さ {h_bar}、幅 {w_bar}")

# 画像のトークン数を計算します：ピクセル総数を 28 * 28 で割ります
token = int((h_bar * w_bar) / (28 * 28))

# システムは自動的に視覚マーカー <|vision_bos|> と <|vision_eos|> を追加します（それぞれ 1 トークン）
print(f"画像のトークン数は {token + 2}")

Node.js

// sharp をインストールするには、次のコマンドを使用します。npm install sharp
import sharp from 'sharp';
import fs from 'fs';

async function tokenCalculate(imagePath) {
    // 指定された PNG 画像ファイルを開きます
    const image = sharp(imagePath);
    const metadata = await image.metadata();

    // 画像の元の寸法を取得します
    const height = metadata.height;
    const width = metadata.width;

    // 高さを 28 の倍数に調整します
    let hBar = Math.round(height / 28) * 28;
    // 幅を 28 の倍数に調整します
    let wBar = Math.round(width / 28) * 28;

    // 画像の最小トークン制限：4 トークン
    const minPixels = 28 * 28 * 4;
    // 画像の最大トークン制限：1280 トークン
    const maxPixels = 1280 * 28 * 28;

    // 画像をスケーリングして、ピクセル総数が [minPixels、maxPixels] の範囲内にあることを確認します
    if (hBar * wBar > maxPixels) {
        // スケーリング係数 beta を計算して、スケーリングされた画像のピクセル総数が maxPixels を超えないようにします
        const beta = Math.sqrt((height * width) / maxPixels);
        // 調整された高さを再計算し、28 の倍数であることを確認します
        hBar = Math.floor(height / beta / 28) * 28;
        // 調整された幅を再計算し、28 の倍数であることを確認します
        wBar = Math.floor(width / beta / 28) * 28;
    } else if (hBar * wBar < minPixels) {
        // スケーリング係数 beta を計算して、スケーリングされた画像のピクセル総数が minPixels 以上になるようにします
        const beta = Math.sqrt(minPixels / (height * width));
        // 調整された高さを再計算し、28 の倍数であることを確認します
        hBar = Math.ceil(height * beta / 28) * 28;
        // 調整された幅を再計算し、28 の倍数であることを確認します
        wBar = Math.ceil(width * beta / 28) * 28;
    }

    return { hBar, wBar };
}

// test.png をローカル画像のパスに置き換えます
const imagePath = 'test.png';
tokenCalculate(imagePath).then(({ hBar, wBar }) => {
    console.log(`スケーリングされた画像の寸法：高さ ${hBar}、幅 ${wBar}`);

    // 画像のトークン数を計算します：ピクセル総数を 28 * 28 で割ります
    const token = Math.floor((hBar * wBar) / (28 * 28));

    // システムは自動的に視覚マーカー <|vision_bos|> と <|vision_eos|> を追加します（それぞれ 1 トークン）
    console.log(`画像のトークン数は ${token + 2}`);
}).catch(err => {
    console.error('画像の処理中にエラーが発生しました：', err);
});

Java

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class Main {

    // リサイズされた寸法を格納するためのカスタムクラス
    public static class ResizedSize {
        public final int height;
        public final int width;

        public ResizedSize(int height, int width) {
            this.height = height;
            this.width = width;
        }
    }

    public static ResizedSize smartResize(String imagePath) throws IOException {
        // 1. 画像を読み込みます
        BufferedImage image = ImageIO.read(new File(imagePath));
        if (image == null) {
            throw new IOException("画像ファイルを読み込めません：" + imagePath);
        }

        int originalHeight = image.getHeight();
        int originalWidth = image.getWidth();

        final int minPixels = 28 * 28 * 4;
        final int maxPixels = 1280 * 28 * 28;
        // 2. 最初の調整を 28 の倍数にします
        int hBar = (int) (Math.round(originalHeight / 28.0) * 28);
        int wBar = (int) (Math.round(originalWidth / 28.0) * 28);
        int currentPixels = hBar * wBar;

        // 3. 条件に基づいて寸法を調整します
        if (currentPixels > maxPixels) {
            // 現在のピクセルが最大値を超えているため、縮小する必要があります
            double beta = Math.sqrt(
                    (originalHeight * (double) originalWidth) / maxPixels
            );
            double scaledHeight = originalHeight / beta;
            double scaledWidth = originalWidth / beta;

            hBar = (int) (Math.floor(scaledHeight / 28) * 28);
            wBar = (int) (Math.floor(scaledWidth / 28) * 28);
        } else if (currentPixels < minPixels) {
            // 現在のピクセルが最小値を下回っているため、拡大する必要があります
            double beta = Math.sqrt(
                    (double) minPixels / (originalHeight * originalWidth)
            );
            double scaledHeight = originalHeight * beta;
            double scaledWidth = originalWidth * beta;

            hBar = (int) (Math.ceil(scaledHeight / 28) * 28);
            wBar = (int) (Math.ceil(scaledWidth / 28) * 28);
        }

        return new ResizedSize(hBar, wBar);
    }

    public static void main(String[] args) {
        try {
            ResizedSize size = smartResize(
                    // xxx/test.png を画像パスに置き換えます
                    "xxx/test.png"
            );

            System.out.printf("スケーリングされた画像の寸法：高さ %d、幅 %d%n", size.height, size.width);

            // トークンを計算します（ピクセル総数 / 28 × 28 + 2）
            int token = (size.height * size.width) / (28 * 28) + 2;
            System.out.printf("画像のトークン数：%d%n", token);

        } catch (IOException e) {
            System.err.println("エラー：" + e.getMessage());
            e.printStackTrace();
        }
    }
}

動画

次のコードを使用して、動画のトークンを推定できます。

Python

# 使用前にインストールします。pip install opencv-python
import math
import os
import logging
import cv2

logger = logging.getLogger(__name__)

FRAME_FACTOR = 2
IMAGE_FACTOR = 28
# 動画フレームの縦横比
MAX_RATIO = 200

# 動画フレームの最小トークン制限
VIDEO_MIN_PIXELS = 128 * 28 * 28
# 動画フレームの最大トークン制限
VIDEO_MAX_PIXELS = 768 * 28 * 28

# ユーザーが FPS パラメーターを渡さない場合は、デフォルト値を使用します
FPS = 2.0
# 抽出する最小フレーム数
FPS_MIN_FRAMES = 4
# 抽出する最大フレーム数。qwen2.5-vl モデルを使用する場合は、FPS_MAX_FRAMES を 512 に設定します。他のモデルの場合は、80 に設定します
FPS_MAX_FRAMES = 512

# 動画入力の最大ピクセル値
# qwen2.5-vl モデルを使用する場合は、VIDEO_TOTAL_PIXELS を 65536 * 28 * 28 に設定します。他のモデルの場合は、24576 * 28 * 28 に設定します
VIDEO_TOTAL_PIXELS = int(float(os.environ.get('VIDEO_MAX_PIXELS', 65536 * 28 * 28)))

def round_by_factor(number: int, factor: int) -> int:
    """'factor' で割り切れる 'number' に最も近い整数を返します。"""
    return round(number / factor) * factor

def ceil_by_factor(number: int, factor: int) -> int:
    """'factor' で割り切れる 'number' 以上の最小の整数を返します。"""
    return math.ceil(number / factor) * factor

def floor_by_factor(number: int, factor: int) -> int:
    """'factor' で割り切れる 'number' 以下の最大の整数を返します。"""
    return math.floor(number / factor) * factor

def smart_nframes(ele,total_frames,video_fps):
    """抽出する動画フレームの数を計算します。

    Args:
        ele (dict): 動画構成を含む辞書
            - fps: fps は、モデルによって抽出される入力フレームの数を制御するために使用されます。
        total_frames (int): 元の動画の合計フレーム数。
        video_fps (int | float): 動画の元のフレームレート

    Raises:
        nframes は [FRAME_FACTOR、total_frames] の範囲内である必要があります。そうでない場合は、エラーがスローされます

    Returns:
        モデル入力の動画フレームの数。
    """
    assert not ("fps" in ele and "nframes" in ele), "「fps」または「nframes」のいずれかのみを受け入れます"
    fps = ele.get("fps", FPS)
    min_frames = ceil_by_factor(ele.get("min_frames", FPS_MIN_FRAMES), FRAME_FACTOR)
    max_frames = floor_by_factor(ele.get("max_frames", min(FPS_MAX_FRAMES, total_frames)), FRAME_FACTOR)
    duration = total_frames / video_fps if video_fps != 0 else 0
    if duration-int(duration) > (1/fps):
        total_frames = math.ceil(duration * video_fps)
    else:
        total_frames = math.ceil(int(duration) * video_fps)
    nframes = total_frames / video_fps * fps
    if nframes > total_frames:
        logger.warning(f"smart_nframes: nframes[{nframes}] > total_frames[{total_frames}]")
    nframes = int(min(min(max(nframes, min_frames), max_frames), total_frames))
    if not (FRAME_FACTOR <= nframes and nframes <= total_frames):
        raise ValueError(f"nframes は [{FRAME_FACTOR}、{total_frames}] の間隔である必要がありますが、{nframes} が取得されました。")

    return nframes

def get_video(video_path):
    # 動画情報を取得します
    cap = cv2.VideoCapture(video_path)

    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    # 動画の高さを取得します
    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

    video_fps = cap.get(cv2.CAP_PROP_FPS)
    return frame_height, frame_width, total_frames, video_fps

def smart_resize(ele, path, factor=IMAGE_FACTOR):
    # 元の動画の幅と高さを取得します
    height, width, total_frames, video_fps = get_video(path)
    # 動画フレームの最小トークン制限
    min_pixels = VIDEO_MIN_PIXELS
    total_pixels = VIDEO_TOTAL_PIXELS
    # 抽出された動画フレームの数
    nframes = smart_nframes(ele, total_frames, video_fps)
    max_pixels = max(min(VIDEO_MAX_PIXELS, total_pixels / nframes * FRAME_FACTOR), int(min_pixels * 1.05))

    # 動画の縦横比は 200:1 または 1:200 を超えてはなりません
    if max(height, width) / min(height, width) > MAX_RATIO:
        raise ValueError(
            f"絶対縦横比は {MAX_RATIO} より小さくなければなりませんが、{max(height, width) / min(height, width)} が取得されました"
        )

    h_bar = max(factor, round_by_factor(height, factor))
    w_bar = max(factor, round_by_factor(width, factor))
    if h_bar * w_bar > max_pixels:
        beta = math.sqrt((height * width) / max_pixels)
        h_bar = floor_by_factor(height / beta, factor)
        w_bar = floor_by_factor(width / beta, factor)
    elif h_bar * w_bar < min_pixels:
        beta = math.sqrt(min_pixels / (height * width))
        h_bar = ceil_by_factor(height * beta, factor)
        w_bar = ceil_by_factor(width * beta, factor)
    return h_bar, w_bar
    

def token_calculate(video_path, fps):
    # 動画パスと fps 抽出パラメーターを渡します
    messages = [{"content": [{"video": video_path, "fps": fps}]}]
    vision_infos = extract_vision_info(messages)[0]

    resized_height, resized_width = smart_resize(vision_infos, video_path)

    height, width, total_frames, video_fps = get_video(video_path)
    num_frames = smart_nframes(vision_infos, total_frames, video_fps)
    print(f"元の動画サイズ：{height}*{width}、モデル入力のサイズ：{resized_height}*{resized_width}、動画の合計フレーム数：{total_frames}、fps が {fps} の場合、抽出された合計フレーム数：{num_frames}", end=", ")
    video_token = int(math.ceil(num_frames / 2) * resized_height / 28 * resized_width / 28)
    video_token += 2  # システムは自動的に視覚マーカー <|vision_bos|> と <|vision_eos|> を追加します（それぞれ 1 トークンとしてカウントされます）
    return video_token

def extract_vision_info(conversations):
    vision_infos = []
    if isinstance(conversations[0], dict):
        conversations = [conversations]
    for conversation in conversations:
        for message in conversation:
            if isinstance(message["content"], list):
                for ele in message["content"]:
                    if (
                        "image" in ele
                        or "image_url" in ele
                        or "video" in ele
                        or ele.get("type", "") in ("image", "image_url", "video")
                    ):
                        vision_infos.append(ele)
    return vision_infos


video_token = token_calculate("xxx/test.mp4", 1)
print("動画トークン：", video_token)

Node.js

// 使用前にインストールします。npm i node-ffprobe
import ffprobeInstaller from '@ffprobe-installer/ffprobe';
import ffprobe from 'node-ffprobe';
import probe from "node-ffprobe";
// ffprobe パスを設定します（グローバル構成）
ffprobe.FFPROBE_PATH = ffprobeInstaller.path;

// 動画情報を取得します
async function getVideoInfo(videoPath) {
  try {
    const probeData = await probe(videoPath);
    const videoStream = probeData.streams.find(
      stream => stream.codec_type === 'video'
    );

    if (!videoStream) {
      throw new Error('動画に動画ストリームが見つかりません');
    }

    const width = videoStream.width;
    const height = videoStream.height;
    const totalFrames = videoStream.nb_frames;
    const [numerator, denominator] = videoStream.avg_frame_rate.split('/');
    const frameRate = parseFloat(numerator / denominator);

    return {
      width,
      height,
      totalFrames,
      frameRate
    };
  } catch (error) {
    console.error('動画情報の取得に失敗しました：', error);
    throw error;
  }
}

// 構成パラメーター
const FRAME_FACTOR = 2; 
const IMAGE_FACTOR = 28;
const MAX_RATIO = 200;
// 動画フレームの最小トークン制限
const VIDEO_MIN_PIXELS = 128 * 28 * 28; 
// 動画フレームの最大トークン制限
const VIDEO_MAX_PIXELS = 768 * 28 * 28; 
const FPS = 2.0; // ユーザーが FPS パラメーターを渡さない場合は、デフォルト値を使用します
// 抽出する最小フレーム数
const FPS_MIN_FRAMES = 4;
// 抽出する最大フレーム数。qwen2.5-vl モデルを使用する場合は、FPS_MAX_FRAMES を 512 に設定します。他のモデルの場合は、80 に設定します
const FPS_MAX_FRAMES = 512; 
// 動画入力の最大ピクセル値
// qwen2.5-vl モデルを使用する場合は、VIDEO_TOTAL_PIXELS を 65536 * 28 * 28 に設定します。他のモデルの場合は、24576 * 28 * 28 に設定します
const VIDEO_TOTAL_PIXELS = parseInt(process.env.VIDEO_MAX_PIXELS) || 65536 * 28 * 28;

// 数学ユーティリティ関数
function roundByFactor(number, factor) {
    return Math.round(number / factor) * factor;
}

function ceilByFactor(number, factor) {
    return Math.ceil(number / factor) * factor;
}

function floorByFactor(number, factor) {
    return Math.floor(number / factor) * factor;
}

// 抽出するフレームの数を計算します
function smartNFrames(ele, totalFrames, frameRate) {
    const fps = ele.fps || FPS;
    const minFrames = ceilByFactor(ele.min_frames || FPS_MIN_FRAMES, FRAME_FACTOR);
    const maxFrames = floorByFactor(
        ele.max_frames || Math.min(FPS_MAX_FRAMES, totalFrames),
        FRAME_FACTOR
    );
    const duration = frameRate !== 0 ? parseFloat(totalFrames / frameRate) : 0;

    let totalFramesAdjusted = duration % 1 > (1 / fps)
        ? Math.ceil(duration * frameRate)
        : Math.ceil(Math.floor(parseInt(duration)) * frameRate);

    const nframes = (totalFramesAdjusted / frameRate) * fps;
    const finalNFrames = parseInt(Math.min(
        Math.max(nframes, minFrames),
        Math.min(maxFrames, totalFramesAdjusted)
    ));

    if (finalNFrames < FRAME_FACTOR || finalNFrames > totalFramesAdjusted) {
        throw new Error(
            `nframes は ${FRAME_FACTOR} から ${totalFramesAdjusted} の間である必要がありますが、${finalNFrames} が取得されました`
        );
    }
    return finalNFrames;
}

// 解像度をスマートに調整します
async function smartResize(ele, videoPath) {
    const { height, width, totalFrames, frameRate } = await getVideoInfo(videoPath);
    const minPixels = VIDEO_MIN_PIXELS;
    const nframes = smartNFrames(ele, totalFrames, frameRate);
    const maxPixels = Math.max(
        Math.min(VIDEO_MAX_PIXELS, VIDEO_TOTAL_PIXELS / nframes * FRAME_FACTOR),
        Math.floor(minPixels * 1.05)
    );

    // 縦横比を確認します
    const ratio = Math.max(height, width) / Math.min(height, width);
    if (ratio > MAX_RATIO) {
        throw new Error(`縦横比 ${ratio} が ${MAX_RATIO} を超えています`);
    }

    let hBar = Math.max(IMAGE_FACTOR, roundByFactor(height, IMAGE_FACTOR));
    let wBar = Math.max(IMAGE_FACTOR, roundByFactor(width, IMAGE_FACTOR));

    if (hBar * wBar > maxPixels) {
        const beta = Math.sqrt((height * width) / maxPixels);
        hBar = floorByFactor(height / beta, IMAGE_FACTOR);
        wBar = floorByFactor(width / beta, IMAGE_FACTOR);
    } else if (hBar * wBar < minPixels) {
        const beta = Math.sqrt(minPixels / (height * width));
        hBar = ceilByFactor(height * beta, IMAGE_FACTOR);
        wBar = ceilByFactor(width * beta, IMAGE_FACTOR);
    }

    return { hBar, wBar };
}

// トークン数を計算します
async function tokenCalculate(videoPath, fps) {
    const messages = [{ content: [{ video: videoPath, fps }] }];
    const visionInfos = extractVisionInfo(messages);

    const { hBar, wBar } = await smartResize(visionInfos[0], videoPath);
    const { height, width, totalFrames, frameRate } = await getVideoInfo(videoPath);
    const numFrames = smartNFrames(visionInfos[0], totalFrames, frameRate);

    console.log(
        `元の動画サイズ：${height}*${width}、モデル入力のサイズ：${hBar}*${wBar}、動画の合計フレーム数：${totalFrames}、fps が ${fps} の場合、抽出された合計フレーム数：${numFrames}`
    );

    const videoToken = Math.ceil(numFrames / 2) * Math.floor(hBar / 28) * Math.floor(wBar / 28) + 2;
    return videoToken;
}

// 視覚情報を抽出します
function extractVisionInfo(conversations) {
    const visionInfos = [];
    if (!Array.isArray(conversations)) {
        conversations = [conversations];
    }
    conversations.forEach(conversation => {
        if (!Array.isArray(conversation)) {
            conversation = [conversation];
        }
        conversation.forEach(message => {
            if (Array.isArray(message.content)) {
                message.content.forEach(ele => {
                    if (ele.image || ele.image_url || ele.video || ['image', 'image_url', 'video'].includes(ele.type)) {
                        visionInfos.push(ele);
                    }
                });
            }
        });
    });
    return visionInfos;
}

// 使用例
(async () => {
    try {
        const videoPath = "xxx/test.mp4"; // ローカルパスに置き換えます
        const videoToken = await tokenCalculate(videoPath, 1);
        console.log('動画トークン：', videoToken);
    } catch (error) {
        console.error('エラー：', error.message);
    }
})();

同時実行レート制限については、レート制限を参照してください。

始めよう

前提条件：API キーを取得し、環境変数として構成する必要があります。 SDK を使用するには、OpenAI または DashScope SDK をインストールする必要があります。 Java 用の DashScope SDK は、バージョン 2.19.0 以降である必要があります。

重要

推論時間が長いため、現在 QVQ はストリーミング出力のみをサポートしています。
QVQ では思考を無効にすることはできません。
QVQ はシステムメッセージをサポートしていません。
DashScope メソッドの場合：
- incremental_output はデフォルトで true であり、false にすることはできません。
- result_format はデフォルトで "message" であり、"text" にすることはできません。

次のサンプルコードは、理解のために画像 URL を使用しています。

入力画像の制限セクションを確認してください。ローカル画像を使用するには、ローカルファイルの使用を参照してください。