体会Semantic Kernel图片内容辨认

前语

    前几日在阅读devblogs.microsoft.com的时分，看到了一篇名为Image to Text with Semantic Kernel and HuggingFace的文章。这篇文章大致的内容讲的是，运用Semantic Kernel结合HuggingFace来完结图片内容辨认。留意，这儿说的是图片内容辨认，并非是OCR，而是它能够大致的描绘图片里的主要内容。我个人对这些仍是有点爱好的，所以就测验了一下，本文便是我体会进程的记载。

示例

话不多说，直接展现代码。依照文档上说的，运用HuggingFace ImageToText构建自己的运用程序时，需求运用以下的包

• Microsoft.SemanticKernel
• Microsoft.SemanticKernel.Connectors.HuggingFace

第一个包是SemanticKernel包，供给构建AI运用的根底才干。第二个包是HuggingFace包，供给HuggingFace的API，便利咱们调用HuggingFace的模型。需求留意的是这个包是预发行版，所以在用VS增加的时分需求在VS勾选包括预发行版。运用起来也十分简略，代码如下所示

var kernel = Kernel.CreateBuilder().AddHuggingFaceImageToText("Salesforce/blip-image-captioning-base").Build();
IImageToTextService service = kernel.GetRequiredService<IImageToTextService>();
var imageBinary = File.ReadAllBytes(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "demo.jpg"));
var imageContent = new ImageContent(imageBinary) { MimeType = "image/jpeg" };
var textContent = await service.GetTextContentAsync(imageContent);
Console.WriteLine($"已辨认图片中描绘的内容: {textContent.Text}");

代码很简略，运转起来试试效果，发现是直接报错了，报错信息如下：

Microsoft.SemanticKernel.HttpOperationException:“由于衔接方在一段时间后没有正确答复或衔接的主机没有反应，衔接测验失利。 (api-inference.huggingface.co:443)”

原因也很简略，我本地衔接不了huggingface，这个需求换种上网办法才干处理。看来默许是恳求的api-inference.huggingface.co:443这个地址，在源码中求证了一下HuggingFaceClient.cs#L41，发现的确是这样

internal sealed class HuggingFaceClient
{
    private readonly IStreamJsonParser _streamJsonParser;
    private readonly string _modelId;
    private readonly string? _apiKey;
    private readonly Uri? _endpoint;
    private readonly string _separator;
    private readonly HttpClient _httpClient;
    private readonly ILogger _logger;

    internal HuggingFaceClient(
        string modelId,
        HttpClient httpClient,
        Uri? endpoint = null,
        string? apiKey = null,
        IStreamJsonParser? streamJsonParser = null,
        ILogger? logger = null)
    {
        Verify.NotNullOrWhiteSpace(modelId);
        Verify.NotNull(httpClient);
        //默许恳求地址
        endpoint ??= new Uri("https://api-inference.huggingface.co");
        this._separator = endpoint.AbsolutePath.EndsWith("/", StringComparison.InvariantCulture) ? string.Empty : "/";
        this._endpoint = endpoint;
        this._modelId = modelId;
        this._apiKey = apiKey;
        this._httpClient = httpClient;
        this._logger = logger ?? NullLogger.Instance;
        this._streamJsonParser = streamJsonParser ?? new TextGenerationStreamJsonParser();
    }
}

它仅仅默许情况下恳求的api-inference.huggingface.co这个地址，假如想要恳求其他地址的话，需求自己完结一个api，然后经过SemanticKernel调用。

曲线完结

上面提到了既然是huggingface的api咱们拜访不到，而且我不是很喜爱这种在线办法，太依靠三方接口的稳定性了，我更喜爱本地能够布置的，这样的话就不必考虑网络和稳定性问题了。所以想到了一个曲线的办法，那是不是能够自己完结一个api，然后经过SemanticKernel调用呢？答案是必定的。

blip-image-captioning-base模型

经过上面的示例咱们能够看到它运用ImageToText图片辨认模型运用的是Salesforce/blip-image-captioning-base这个模型，咱们能够自行下载这个模型到本地。上面说了huggingface需求换种上网办法，不过不要紧这个国内是有镜像网站的https://hf-mirror.com/，找到模型地址Salesforce/blip-image-captioning-base挑选Files and versions标签把里边的一切文件下载到本地文件夹即可，大概是1.84 G左右。比方我是放到我的D:\Users\User\blip-image-captioning-base文件夹内，目录结构如下所示

这个模型没有特殊要求，我的电脑是16G内存和i5处理器都能够运转起来。接下来用调用这个模型试一试，该模型是适配了transformers结构，所以调用起来比较加单，代码如下所示

from PIL import Image
from transformers import BlipProcessor, BlipForConditionalGeneration

processor = BlipProcessor.from_pretrained("D:\\Users\\User\\blip-image-captioning-base")
model = BlipForConditionalGeneration.from_pretrained("D:\\Users\\User\\blip-image-captioning-base")

img_url = '01f8115545963d0000019ae943aaad.jpg@1280w_1l_2o_100sh.jpg'
raw_image = Image.open(img_url).convert('RGB')

inputs = processor(raw_image, return_tensors="pt")
out = model.generate(**inputs)
en_text = processor.decode(out[0], skip_special_tokens=True)
print(f'已辨认图片中描绘的内容：{en_text}')

然后我运用了我本地的一张图片

运转这段代码之后输出信息如下所示

已辨认图片中描绘的内容：a kitten is standing on a tree stump

辨认的成果描绘的和图片内容大致来说是共同的，看来简略的图片效果仍是不错的。不过美中缺乏的是，它说的是英文，给中国人看说英文这显着不符合设定。所以仍是得想办法把英文翻译成中文。

opus-mt-en-zh模型

上面咱们看到了blip-image-captioning-base模型效果的确还能够，仅仅它回来的是英文内容，这个关于英文缺乏六级的人来说读起来的确不便利。得想办法处理把英文翻译成中文的问题。由于不想调用翻译接口，所以这儿我仍是想运用模型的办法来处理这个问题。运用Bing查找了一番，发现引荐的opus-mt-en-zh模型效果不错，所以计划试一试。仍是在hf-mirror.com上下载模型到本地文件夹内，办法办法如上面的blip-image-captioning-base模型共同。它的巨细大概在1.41 GB左右，也是CPU可运转的，比方我的是下载到本地D:\Users\User\opus-mt-en-zh途径下，内容如下所示

接下来仍是老规矩，调用一下这个模型看看效果，不过在huggingface对应的仓库里并没有给出怎么运用模型的示例，所以去stackoverflow上找到两个相似的内容参阅了一下

• how-do-i-translate-using-huggingface-from-chinese-to-englis
• how-to-run-huggingface-helsinki-nlp-models

经过上面的衔接能够看到，十分好的地便利是，这个模型也是兼容transformers结构的，所以调用起来十分简略，把上面的英文内容拿过来试一试, 代码如下所示

from transformers import AutoTokenizer, AutoModelWithLMHead

model = AutoModelWithLMHead.from_pretrained("D:\\Users\\User\\opus-mt-en-zh")
tokenizer = AutoTokenizer.from_pretrained("D:\\Users\\User\\opus-mt-en-zh")
# 英文文本
en_text='a kitten is standing on a tree stump'

encoded = tokenizer([en_text], return_tensors="pt")
translation = model.generate(**encoded)
# 翻译后的中文内容
zh_text = tokenizer.batch_decode(translation, skip_special_tokens=True)[0]
print(f'已辨认图片中描绘的内容：\r\n英文：{en_text}\r\n中文：{zh_text}')

运转这段代码之后输出信息如下所示

已辨认图片中描绘的内容：
英文：a kitten is standing on a tree stump
中文：一只小猫站在树桩上

这下看着舒服了，至少不必凭借翻译东西了。模型的部分到此就差不多了，接下来看怎么整合一下模型的问题。

结合Microsoft.SemanticKernel.Connectors.HuggingFace

上面咱们调研了图片内容辨认的模型和英文翻译的模型，接下来咱们看一下怎么运用Microsoft.SemanticKernel.Connectors.HuggingFace去整合咱们本地的模型。咱们经过上面了解到了他说依据http的办法去调用了，这就很清晰了。只需求知道调用的途径、恳求参数、回来参数就能够自己写接口来模拟了。这个就需求去看一下SemanticKernel里边触及的代码了。中心类便是HuggingFaceClient类，咱们来看下它的GenerateTextAsync办法的代码

public async Task<IReadOnlyList<TextContent>> GenerateTextAsync(
        string prompt,
        PromptExecutionSettings? executionSettings,
        CancellationToken cancellationToken)
{
	string modelId = executionSettings?.ModelId ?? this._modelId;
	var endpoint = this.GetTextGenerationEndpoint(modelId);
	var request = this.CreateTextRequest(prompt, executionSettings);
	using var httpRequestMessage = this.CreatePost(request, endpoint, this._apiKey);

	string body = await this.SendRequestAndGetStringBodyAsync(httpRequestMessage, cancellationToken)
		.ConfigureAwait(false);

	var response = DeserializeResponse<TextGenerationResponse>(body);
	var textContents = GetTextContentFromResponse(response, modelId);

	return textContents;
}

//拼装恳求途径办法
private Uri GetTextGenerationEndpoint(string modelId)
	=> new($"{this._endpoint}{this._separator}models/{modelId}");

private HttpRequestMessage CreateImageToTextRequest(ImageContent content, PromptExecutionSettings? executionSettings)
{
	var endpoint = this.GetImageToTextGenerationEndpoint(executionSettings?.ModelId ?? this._modelId);

	var imageContent = new ByteArrayContent(content.Data?.ToArray());
	imageContent.Headers.ContentType = new(content.MimeType);

	var request = new HttpRequestMessage(HttpMethod.Post, endpoint)
	{
		Content = imageContent
	};

	this.SetRequestHeaders(request);

}

private Uri GetImageToTextGenerationEndpoint(string modelId)
	=> new($"{this._endpoint}{this._separator}models/{modelId}");

经过上面的GenerateTextAsync办法代码咱们能够得到咱们自界说接口时所需求的悉数信息

• 首先是恳求途径问题， 咱们经过GetTextGenerationEndpoint和GetImageToTextGenerationEndpoint办法能够看到，拼接的途径地址服务地址/models/模型id，比方咱们上面调用的是Salesforce/blip-image-captioning-base模型，拼接的途径便是models/Salesforce/blip-image-captioning-base。
• 其次经过CreateImageToTextRequest办法咱们能够得知，恳求参数的类型是ByteArrayContent，恳求参数的ContentType是image/jpeg。也便是把咱们的图片内容转化成字节数组放到恳求body恳求体里即可，然后POST到详细的服务里即可。
• 经过TextGenerationResponse回来类型咱们能够知道这个承载的是回来参数的类型里。

咱们来看下TextGenerationResponse类的界说

internal sealed class TextGenerationResponse : List<GeneratedTextItem>
{
    internal sealed class GeneratedTextItem
    {
        [JsonPropertyName("generated_text")]
        public string? GeneratedText { get; set; }
    }
}

这个参数比较简略，便是回来一个包括generated_text字段的数组即可对应成json格局的话便是[{"generated_text":"辨认成果"}]。接下来咱们需求做的是把模型整合换成http接口，这样的话Microsoft.SemanticKernel.Connectors.HuggingFace就能够调用这个接口了。这儿我挑选运用的是python的fastapiweb结构去整组成webapi服务，其他结构也能够，只需入参回来的成果把握住就能够，整合后效果如下所示

import io
import uvicorn
from fastapi import FastAPI, Request
from PIL import Image
from transformers import BlipProcessor, BlipForConditionalGeneration, AutoTokenizer, AutoModelWithLMHead

app = FastAPI()

# 图片内容辨认模型
processor = BlipProcessor.from_pretrained("D:\\Users\\User\\blip-image-captioning-base")
blipModel = BlipForConditionalGeneration.from_pretrained("D:\\Users\\User\\blip-image-captioning-base")

# 英文翻译模型
tokenizer = AutoTokenizer.from_pretrained("D:\\Users\\User\\opus-mt-en-zh")
opusModel = AutoModelWithLMHead.from_pretrained("D:\\Users\\User\\opus-mt-en-zh")

# 界说接口函数
@app.post("/models/Salesforce/blip-image-captioning-base", summary="图片内容辨认")
async def blip_image_captioning_base(request: Request):
    # 获取恳求参数
    request_object_content: bytes = await request.body()
    # 转化图片内容
    raw_image = Image.open(io.BytesIO(request_object_content)).convert('RGB')

    # 辨认图片内容
    inputs = processor(raw_image, return_tensors="pt")
    out = blipModel.generate(**inputs)
    en_text = processor.decode(out[0], skip_special_tokens=True)
    
    # 英译汉
    encoded = tokenizer([en_text], return_tensors="pt")
    translation = opusModel.generate(**encoded)
    zh_text = tokenizer.batch_decode(translation, skip_special_tokens=True)[0]
    return [{"generated_text": zh_text}]


if __name__ == '__main__':
    # 运转fastapi程序
    uvicorn.run(app="snownlpdemo:app", host="0.0.0.0", port=8000, reload=True)

这儿咱们把服务露出到8000端口上去，等候服务发动成功即可，然后咱们去改造Microsoft.SemanticKernel.Connectors.HuggingFace的代码如下所示

//这儿咱们传递方才自行构建的fastapi服务地址
var kernel = Kernel.CreateBuilder().AddHuggingFaceImageToText("Salesforce/blip-image-captioning-base", new Uri("http://127.0.0.1:8000")).Build();
IImageToTextService service = kernel.GetRequiredService<IImageToTextService>();
var imageBinary = File.ReadAllBytes(Path.Combine(Directory.GetCurrentDirectory(), "01f8115545963d0000019ae943aaad.jpg@1280w_1l_2o_100sh.jpg"));
var imageContent = new ImageContent(imageBinary) { MimeType = "image/jpeg" };
var textContent = await service.GetTextContentAsync(imageContent);
Console.WriteLine($"已辨认图片中描绘的内容: {textContent.Text}");

这样的话代码改造完结，需求留意的是得先运转fastapi服务等候服务发动成功之后，再去然后运转dotnet项目，运转起来效果如下所示

已辨认图片中描绘的内容: 一只小猫站在树桩上

改形成插件

咱们运用上面的办法是比较僵硬死板的，了解SemanticKernel的同学都清楚它是支撑自定插件的，这样的话它能够依据咱们的提示词来剖析调用详细的插件，然后完结调用咱们自界说的接口。这是一个十分有用的功用，让SemanticKernel的调用愈加灵敏，是对AIGC才干的扩展，能够让他调用咱们想调用的接口或许服务等等。话不多说，咱们界说一个插件让它承载咱们辨认图片的内容，这样的话就能够经过SemanticKernel的调用办法去调用这个插件了。界说插件的代码如下所示

public class ImageToTextPlugin
{
    private IImageToTextService _service;
    public ImageToTextPlugin(IImageToTextService service)
    {
        _service = service;
    }

    [KernelFunction]
    [Description("依据图片途径剖析图片内容")]
    public async Task<string> GetImageContent([Description("图片途径")] string imagePath)
    {
        var imageBinary = File.ReadAllBytes(imagePath);
        var imageContent = new ImageContent(imageBinary) { MimeType = "image/jpeg" };
        var textContent = await _service.GetTextContentAsync(imageContent);
        return $"图片[{imagePath}]剖析内容为:{textContent.Text!}";
    }
}

这儿需求留意的是咱们界说的办法的Description和参数的Description，其间GetImageContent办法的Description是SemanticKernel的提示词，这样在调用的时分就能够经过提示词来调用这个办法了。参数imagePath的Description这样OpenAI就知道怎么在提示词里提取出来对应的参数信息了。好了接下来咱们看下怎么运用这个插件

using HttpClient httpClient = new HttpClient(new RedirectingHandler());
var executionSettings = new OpenAIPromptExecutionSettings()
{
    ToolCallBehavior = ToolCallBehavior.EnableKernelFunctions,
    Temperature = 1.0
};
var builder = Kernel.CreateBuilder().AddHuggingFaceImageToText("Salesforce/blip-image-captioning-base", new Uri("http://127.0.0.1:8000"));
var kernel = builder.Build();
ImageToTextPlugin imageToTextPlugin = new ImageToTextPlugin(kernel.GetRequiredService<IImageToTextService>());
kernel.Plugins.AddFromObject(imageToTextPlugin);

var chatCompletionService = new OpenAIChatCompletionService("gpt-3.5-turbo-0125", "你的apiKey", httpClient: httpClient);

Console.WriteLine("现在你能够开端和我谈天了，输入quit退出。等候你的问题：");
do
{
    var prompt = Console.ReadLine();
    if (!string.IsNullOrWhiteSpace(prompt))
    {
        if (prompt.ToLowerInvariant() == "quit")
        {
            Console.WriteLine("十分感谢！下次见。");
            break;
        }
        else
        {
            var history = new ChatHistory();
            history.AddUserMessage(prompt);
            //调用gpt的chat接口
            var result = await chatCompletionService.GetChatMessageContentAsync(history,
                        executionSettings: executionSettings,
                        kernel: kernel);
            //判别gpt回来的成果是否是调用插件
            var functionCall = ((OpenAIChatMessageContent)result).GetOpenAIFunctionToolCalls().FirstOrDefault();
            if (functionCall != null)
            {
                kernel.Plugins.TryGetFunctionAndArguments(functionCall, out KernelFunction? pluginFunction, out KernelArguments? arguments);
                var content = await kernel.InvokeAsync(pluginFunction!, arguments);
                Console.WriteLine(content);
            }
            else
            {
                //不是调用插件这直接输出回来成果
                Console.WriteLine(result.Content);
            }
        }
    }
} while (true);

这儿需求留意自界说的RedirectingHandler，假如你不是运用OpenAI的接口而是自己对接或许署理的OpenAI的接口，就需求自行界说HttpClientHandler来修正恳求的GPT的服务地址。

public class RedirectingHandler : HttpClientHandler
{
    protected override Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        request.RequestUri = new UriBuilder(request.RequestUri!) { Scheme = "http", Host = "你的服务地址", Path= "/v1/chat/completions" }.Uri;
        return base.SendAsync(request, cancellationToken);
    }
}

这样的话咱们就能够在于GPT的交互中调用咱们自界说的插件了，当咱们输入相关的提示词OpenAI的接口就能够依据提示词和插件信息回来调用哪个插件。运用了几张我本地的图片试了一下效果仍是不错的，能剖分出大致的图片内容，如下所示

这样运用起来就比较灵敏了，在对话的进程中就能够运用本地的功用，不得不说有了插件化的才干SemanticKernel的功用就愈加丰厚了。关于插件化的完结原理也是比较简略，这是运用OpenAI对话接口的才干，咱们只需求界说好插件和相关的提示词就能够，比方咱们上面示例，运用Fiddler或Charles阻拦一下宣布的恳求即可，它是建议的HTTP恳求，恳求格局如下

{
    "messages": [
        {
            "content": "Assistant is a large language model.",
            "role": "system"
        },
        {
            "content": "请帮我剖析这张图片的内容D:\\Software\\AI.Lossless.Zoomer-2.1.0-x64\\Release\\output\\20200519160906.png",
            "role": "user"
        }
    ],
    "temperature": 1,
    "top_p": 1,
    "n": 1,
    "presence_penalty": 0,
    "frequency_penalty": 0,
    "model": "gpt-3.5-turbo-0125",
    "tools": [
        {
            "function": {
                "name": "ImageToTextPlugin-GetImageContent",
                "description": "依据图片途径剖析图片内容",
                "parameters": {
                    "type": "object",
                    "required": [
                        "imagePath"
                    ],
                    "properties": {
                        "imagePath": {
                            "type": "string",
                            "description": "图片途径"
                        }
                    }
                }
            },
            "type": "function"
        }
    ],
    "tool_choice": "auto"
}

经过恳求OpenAI的/v1/chat/completions接口的恳求参数咱们能够大致了解它的作业原理，SemanticKernel经过扫描咱们界说的插件的元数据比方类_办法、办法的描绘、参数的描绘来放入恳求的JSON数据里，咱们界说的Description里的描绘作为提示词拆分来详细匹配插件的依据。接下来咱们再来看一下这个接口的回来参数的内容

{
    "id": "chatcmpl-996IuJbsTrXHcHAM3dqtguwNi9M3Z",
    "object": "chat.completion",
    "created": 1711956212,
    "model": "gpt-35-turbo",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": null,
                "tool_calls": [
                    {
                        "id": "call_4aN9xUhly2cEbNmzRcIh1it0",
                        "type": "function",
                        "function": {
                            "name": "ImageToTextPlugin-GetImageContent",
                            "arguments": "{\"imagePath\":\"D:\\\\Software\\\\AI.Lossless.Zoomer-2.1.0-x64\\\\Release\\\\output\\\\20200519160906.png\"}"
                        }
                    }
                ]
            },
            "finish_reason": "tool_calls"
        }
    ],
    "usage": {
        "prompt_tokens": 884,
        "completion_tokens": 49,
        "total_tokens": 933
    },
    "system_fingerprint": "fp_2f57f81c11"
}

OpenAI接口给咱们回来了它挑选的插件信息，告知咱们能够调用ImageToTextPlugin-GetImageContent这个办法，传递的参数则是{\"imagePath\":\"D:\\\\Software\\\\AI.Lossless.Zoomer-2.1.0-x64\\\\Release\\\\output\\\\20200519160906.png\"}，这是GPT帮咱们剖析的成果，SemanticKernel依据这个信息来调用咱们本地的插件，履行详细操作。这儿GPT的起到的效果便是，咱们恳求的时分提交插件的元数据，GPT依据提示词和插件的元数据帮我剖析咱们能够调用哪个插件，而且把插件参数帮咱们剖分出来，这样咱们就能够依据回来的插件元数据来调用咱们本地的插件了。

需求留意的，现在我测验的是只要OpenAI或AzureOpenAI供给的对话接口支撑插件的才干，国内的模型我试了一下比方文心一言、讯飞星火、通义千问、百川都不支撑，至少经过OneApi对接过来的不支撑，不知道是不是我姿态不对。

参阅衔接

以下是学习研讨进程中参阅的一些衔接，在这儿展现出来供我们参阅。触及到学习参阅、处理问题、查找资源相关。究竟人生地不熟的，需求找到方向