使用 gpt4o，如何计算图片 token？

```
def chat(client,messages,model):
print()
start=time.time()
answer=[]
for chunk in client.chat.completions.create(
model=model,
messages=messages,
stream=True,
stream_options={'include_usage':True},
temperature=0,
):
if not chunk.choices:
continue
stream=chunk.choices[0].delta.content or ''
if answer or stream.strip():
answer.append(stream)
print(stream,end='',flush=True)
end=time.time()
count=chunk.usage.total_tokens
print(f'\n\n{end-start:.2f} secs, {count} tokens')
return ''.join(answer)
```
最新版客户端，加上参数 stream_options={'include_usage':True}，那么在返回的最后一个 chunk 带 token 消耗数量

这边有写：

https://platform.openai.com/docs/guides/vision/calculating-costs

Image inputs are metered and charged in tokens, just as text inputs are. The token cost of a given image is determined by two factors: its size, and the detail option on each image_url block. All images with detail: low cost 85 tokens each. detail: high images are first scaled to fit within a 2048 x 2048 square, maintaining their aspect ratio. Then, they are scaled such that the shortest side of the image is 768px long. Finally, we count how many 512px squares the image consists of. Each of those squares costs 170 tokens. Another 85 tokens are always added to the final total.

Here are some examples demonstrating the above.

A 1024 x 1024 square image in detail: high mode costs 765 tokens
1024 is less than 2048, so there is no initial resize.
The shortest side is 1024, so we scale the image down to 768 x 768.
4 512px square tiles are needed to represent the image, so the final token cost is 170 * 4 + 85 = 765.
A 2048 x 4096 image in detail: high mode costs 1105 tokens
We scale down the image to 1024 x 2048 to fit within the 2048 square.
The shortest side is 1024, so we further scale down to 768 x 1536.
6 512px tiles are needed, so the final token cost is 170 * 6 + 85 = 1105.
A 4096 x 8192 image in detail: low most costs 85 tokens
Regardless of input size, low detail images are a fixed cost.

c#代码，就是 auto 没测试是怎么自动 low 和 high 的


public static int CalculateImageTokens(int width, int height, ImageDetailMode detailMode)
{
const int lowDetailCost = 85;
const int highDetailCostPerSquare = 170;
const int highDetailBaseCost = 85;
const int maxDimension = 2048;
const int targetShortSide = 768;
const int squareSize = 512;


if (detailMode == ImageDetailMode.None)
{
detailMode = ImageDetailMode.High; //
}

if (detailMode == ImageDetailMode.Low)
{
return lowDetailCost;
}
else if (detailMode == ImageDetailMode.High)
{
bool scaledToMax = false;

// Scale down the image if either dimension exceeds the maximum allowed.
if (width > maxDimension || height > maxDimension)
{
double scaleFactor = Math.Min((double)maxDimension / width, (double)maxDimension / height);
width = (int)(width * scaleFactor);
height = (int)(height * scaleFactor);
scaledToMax = true;
}

// Further scale down the image only if it has been scaled in the previous step.
if (scaledToMax)
{
double scaleToShortestSideFactor = (double)targetShortSide / Math.Min(width, height);
width = (int)(width * scaleToShortestSideFactor);
height = (int)(height * scaleToShortestSideFactor);
}

// Calculate how many 512px squares are needed to cover the image.
int squaresAcross = (int)Math.Ceiling((double)width / squareSize);
int squaresDown = (int)Math.Ceiling((double)height / squareSize);
int totalSquares = squaresAcross * squaresDown;

// Calculate final token cost for high detail images.
return highDetailCostPerSquare * totalSquares + highDetailBaseCost;
}

return lowDetailCost;
}