带ollama的镜像：

```
docker run -d -p 8080:8080 \
  -v /root/ollama:/root/.ollama \
  -v /root/openwebui-test:/app/backend/data \
  --name xd --restart always \
  ghcr.io/open-webui/open-webui:ollama
```

ollama




```
ollama run qwen2.5:0.5b-instruct

ollama ps

```

访问ollama接口：

https://gitcode.csdn.net/66277296c46af92642763e71.html


```
curl http://localhost:11434/api/generate -d '{
  "model": "dolphin-phi",
  "prompt":"Why is the sky blue?"
}'

```

Open WebUI + Ollama

Azure OpenAI 转 openai proxy接口：

https://www.dong-blog.fun/post/1896


先部署好，然后这样设置后就可以使用了：


![image.png](/static/img/8ac75558df0ad2c9178cede5c1f0a8b5.image.webp)

OpenWebUI 使用 Azure OpenAI

https://uright.ca/blogs/2024-07-29-unlocking-the-power-of-azure-openai-on-open-webui/


### 使用 `litellm` 简化 Azure GPT-4 调用

`litellm` 是一个统一接口库，它可以将 Azure 和 OpenAI 的接口规范统一，方便开发者使用。下面是如何通过 `litellm` 进行简单的 Azure GPT-4 调用。



![image.png](/static/img/e0eeb02036fa5f8953bf8b0bd5690d82.image.webp)





#### Python 示例：直接调用 Azure GPT-4

```python
import litellm

# Azure GPT-4 API 调用示例
response = litellm.completion(
    model="azure/GPT-4o",                    # 替换为你自己的 Azure 模型名称
    api_base="https://gpt4.openai.azure.com", # Azure API base URL
    api_version="2023-12-01-preview",        # Azure API 版本
    api_key="26e616018d3a624",               # 你的 Azure API Key
    messages=[{"role": "user", "content": "good morning"}],  # 用户消息
)

print(response)
```

这个代码能够直接检查 Azure 是否通畅。请注意，`litellm` 库帮助统一了 Azure 和 OpenAI 接口的调用方式，简化了不同接口的使用。

#### 使用 `litellm` Proxy 配置 Azure API

你可以通过 `litellm` 提供的 Proxy 来更便捷地管理多个接口配置。首先，创建一个 YAML 配置文件：

```yaml
model_list:
  - model_name: 'GPT-4o'  # 模型名称，随便写的
    litellm_params:
      model: 'azure/GPT-4o'  # 必须以 azure/ 开头
      api_base: 'https://gpt4.openai.azure.com/'  # Azure API 基础 URL
      api_version: '2023-12-01-preview'  # 选择正确的 API 版本
      api_key: '26e616018d3a624'  # 你的 Azure API Key
```

#### 安装 `litellm` Proxy

在命令行中安装 `litellm` Proxy：

```bash
pip install 'litellm[proxy]'
```

#### 启动接口服务

使用以下命令启动本地接口服务：

```bash
litellm --host 0.0.0.0 --port 8000 -c litellm_config.yaml

litellm --host 0.0.0.0 --port 8000 -c litellm_config.yaml --add_key "nsyabB134.."
```

#### 测试接口是否可用

你可以通过 `curl` 命令来测试接口是否通畅：

```bash
curl --location 'http://0.0.0.0:8000/chat/completions' \
     --header 'Content-Type: application/json' \
     --data '{
         "model": "GPT-4o",
         "messages": [
             {"role": "user", "content": "你好，你是谁？"}
         ]
     }'
```


```bash
curl --location 'http://0.0.0.0:8000/chat/completions' \
     --header 'Content-Type: application/json' \
     --header 'Authorization: Bearer nsyabB134..' \
     --data '{
         "model": "GPT-4o",
         "messages": [
             {"role": "user", "content": "你好，你是谁？"}
         ]
     }'
```



---

### 总结

`litellm` 简化了 Azure API 调用，并且通过 Proxy 配置使得不同接口统一在 OpenAI 的规范下工作，极大地方便了开发者的使用。希望这篇教程能帮助你快速配置和测试 Azure 的 GPT-4 接口。

Azure OpenAI 转 openai proxy接口

https://kb.cloudpss.net/documents/software/emtlab/power-flow/fundamentals/




各个部分的参数：

1. 基准容量 (baseMVA)
- mpc.baseMVA = 100，表示系统的基准容量为100MVA

2. 母线数据 (bus data)
每行包含以下参数：
- bus_i: 母线编号
- type: 节点类型（1=PQ节点，2=PV节点，3=平衡节点/参考节点）
- Pd: 有功负荷（MW）
- Qd: 无功负荷（MVar）
- Gs: 对地电导
- Bs: 对地电纳
- area: 区域号
- Vm: 电压幅值初值（标幺值）
- Va: 电压相角初值（度）
- baseKV: 基准电压（kV）
- zone: 区域
- Vmax/Vmin: 电压上下限

3. 发电机数据 (generator data)
- bus: 发电机连接的母线号
- Pg: 有功出力（MW）
- Qg: 无功出力（MVar）
- Qmax/Qmin: 无功出力上下限
- Vg: 发电机端电压设定值
- mBase: 发电机容量基准
- status: 发电机运行状态（1=运行，0=停运）
- Pmax/Pmin: 有功出力上下限

4. 支路数据 (branch data)
- fbus/tbus: 支路起始和终止节点
- r: 支路电阻（标幺值）
- x: 支路电抗（标幺值）
- b: 支路对地电纳（标幺值）
- rateA/B/C: 支路容量限值（不同时期）
- ratio: 变压器变比
- angle: 移相角度
- status: 支路运行状态（1=运行，0=停运）
- angmin/angmax: 相角差限值



```matlab


%% 模块1：读取原始数据（ReadData）
[baseMVA, bus, gen, branch, NUM, PL, U, Theta] = ReadData(fileName);


%% 运行Matpower库潮流计算
[results, Vm, Va, Pij_AC, Qij_AC, Sbus, Pbus, Qbus] = runMatpowerPF(fileName);


%% 我的牛顿拉夫逊法计算潮流
tic;  %开始计时
%% 模块2：形成导纳矩阵（ FormYmatrix ）
[Y,G,B] = FormYmatrix(baseMVA,bus,branch,NUM);% 形成导纳矩阵 

%% 牛顿-拉夫逊迭代法求解潮流
% 计算初始节点注入功率
[P,Q] = PQ_inject(baseMVA,bus,gen,NUM);  % 计算各节点的有功、无功功率注入值

% 设置迭代参数
Iteration_Num = 0;           % 当前迭代次数计数器
Iteration_Num_max = 50;      % 最大允许迭代次数，防止死循环
Accuracy = 1e-5;             % 收敛精度要求，即功率不平衡量的允许误差

% 开始牛顿-拉夫逊迭代过程
while Iteration_Num <= Iteration_Num_max    
    % 计算功率不平衡量
    [cort,dP,dQ,Pi,Qi] = CalculateDeltaPQ(P,Q,U,Theta,Y,PL); 
    % cort: 功率不平衡量向量
    % dP: 有功功率不平衡量
    % dQ: 无功功率不平衡量
    % Pi,Qi: 当前迭代步计算的注入功率
    
    max_mismatch = cort;  % 记录当前迭代步的最大功率不平衡量
    
    % 判断是否满足收敛条件
    if ( max(abs(cort)) < Accuracy )  
        fprintf('计算收敛\n');
        fprintf('迭代次数：%d 次\n',Iteration_Num);
        break;  % 满足收敛条件，退出迭代循环
    else
        % 未收敛，继续迭代计算
        % 形成雅可比矩阵
        J = FormJacobi(U,Theta,Y,PL);             
        
        % 求解修正方程，更新状态变量
        [U,Theta] = SolveCorrectionEquation(NUM,U,Theta,PL,J,cort);   
        % U: 更新后的节点电压幅值
        % Theta: 更新后的节点电压相角
        
        % 更新迭代次数
        Iteration_Num = Iteration_Num + 1;                                  
    end
end

% 判断是否因超过最大迭代次数而退出循环
if Iteration_Num > Iteration_Num_max
    fprintf('\n潮流计算不收敛\n');
end

time = toc; %结束计时并记录
%运行时间
fprintf('运行时间：%.4f秒',time);

```


我来详细解释这个潮流计算程序的每个步骤：

1. 模块1：读取原始数据
```matlab
[baseMVA, bus, gen, branch, NUM, PL, U, Theta] = ReadData(fileName);
```
- 读取系统基本数据，包括基准容量、母线、发电机、支路信息
- 初始化电压幅值(U)和相角(Theta)
- NUM为系统节点数，PL为节点类型标志

2. Matpower库潮流计算
```matlab
[results, Vm, Va, Pij_AC, Qij_AC, Sbus, Pbus, Qbus] = runMatpowerPF(fileName);
```
- 使用Matpower工具箱进行对比验证

3. 自编牛顿拉夫逊法计算潮流

a) 形成导纳矩阵
```matlab
[Y,G,B] = FormYmatrix(baseMVA,bus,branch,NUM);
```
- Y是节点导纳矩阵
- G是导纳实部（电导）
- B是导纳虚部（电纳）

b) 计算初始节点注入功率
```matlab
[P,Q] = PQ_inject(baseMVA,bus,gen,NUM);
```
- 计算各节点的有功(P)和无功(Q)功率注入值

c) 迭代计算过程：
- 计算功率不平衡量
```matlab
[cort,dP,dQ,Pi,Qi] = CalculateDeltaPQ(P,Q,U,Theta,Y,PL);
```

- 检查收敛条件
  - 如果最大功率不平衡量小于设定精度，则收敛
  - 否则继续迭代

- 形成雅可比矩阵
```matlab
J = FormJacobi(U,Theta,Y,PL);
```

- 求解修正方程，更新状态变量
```matlab
[U,Theta] = SolveCorrectionEquation(NUM,U,Theta,PL,J,cort);
```

迭代过程直到：
- 达到收敛条件
- 或超过最大迭代次数（50次）




# 牛顿-拉夫逊法求解电力潮流的理论过程


潮流计算的求解是基于电路中的节点电压方程：
$$
\dot{\mathbf{I}}_n = \mathbf{Y}_n \dot{\mathbf{U}}_n
$$
其中，节点导纳矩阵 $\mathbf{Y}_n$ 描述了网络中元件特性与网络拓扑的连接关系，而节点电压方程则描述了各个节点之间的电流与电压关系。

潮流计算的边界条件是复功率，因此需要建立功率与电压之间的关系，即功率方程（潮流方程）。可以将节点电流用节点功率和电压表示：
$$
\dot{I}_i = \frac{S_i^*}{U_i^*} = \frac{P_i - jQ_i}{U_i^*}
$$
将电流表达式带入节点电压方程后，可以得到潮流方程：
$$
P_i - jQ_i = U_i^* \sum_{j=1}^n Y_{ij} \dot{U}_j \quad (i = 1, 2, \cdots, n)
$$
其中，$Y_{ij} = G_{ij} + jB_{ij}$，并且
$$
\dot{U}_i = U_i \angle \delta_i = U_i e^{j\delta_i}
$$
将其带入潮流方程后，可以将潮流方程转化为极坐标形式：
$$
P_i - jQ_i = U_i e^{-j\delta_i} \sum_{j=1}^n \left( G_{ij} + jB_{ij} \right) U_j e^{j\delta_j}
$$
$$
= U_i \sum_{j=1}^n U_j \left( G_{ij} + jB_{ij} \right) e^{-j\delta_{ij}}
$$
$$
= U_i \sum_{j=1}^n U_j \left( G_{ij} + jB_{ij} \right) (\cos\delta_{ij} + j\sin\delta_{ij})
$$
将实部和虚部分开，得到潮流计算的求解方程：
$$
\begin{cases}
P_i = U_i \sum_{j=1}^n U_j \left( G_{ij} \cos\delta_{ij} + B_{ij} \sin\delta_{ij} \right) \\
Q_i = U_i \sum_{j=1}^n U_j \left( G_{ij} \sin\delta_{ij} - B_{ij} \cos\delta_{ij} \right)
\end{cases}
$$
从以上分析可以看出，一个节点包含 4 个运行变量（$P$, $Q$, $U$, $\delta$），对应 2 个方程。对于 $n$ 个节点的系统，总共有 4n 个变量和 2n 个方程。如果每个节点给定 2 个变量值，那么可以通过这些方程求解剩余的 2n 个未知量。




电力系统节点根据不同的变量给定方式可以分为PQ节点、PV节点和平衡节点。

1. **PQ节点**：
   给定有功功率 $P_i$ 和无功功率 $Q_i$，待求节点电压幅值 $U_i$ 和电压相位 $\delta_i$。

2. **PV节点**：
   给定有功功率 $P_i$ 和电压幅值 $U_i$，待求无功功率 $Q_i$ 和电压相位 $\delta_i$。

3. **平衡节点**：
   全系统功率必须平衡，功率损耗 $P_{\text{loss}}$ 和 $Q_{\text{loss}}$ 是状态变量的函数，事先未知。需要一个节点不可以给定 $P$ 和 $Q$，但给定电压幅值 $U$ 和相位 $\delta$，用以平衡全系统功率，故称为平衡节点。

由于潮流计算方程是一个非线性方程组，直接求解非常困难，通常采用牛顿-拉夫逊法来求解。

---

### 牛顿-拉夫逊法求解潮流基本步骤：

1. **形成节点导纳矩阵**；
2. **给各节点电压相角赋初值**；
3. **代入修正方程，求常数项向量**；
4. **求雅可比矩阵**；
5. **解修正方程，求解节点电压相角的修正量**；
6. **更新节点电压**；
7. **检查收敛性**，如果不收敛，则用新的节点电压作为初值进行下一次迭代；否则进入下一步；
8. **计算支路功率分布**，包括计算PV节点的无功功率和平衡节点的注入功率。

---

### 功率不平衡计算：

潮流计算中的功率不平衡列向量为：

$$
\Delta S = \begin{bmatrix} \Delta P \\ \Delta Q \end{bmatrix} = \begin{bmatrix} \Delta P_1 & \cdots & \Delta P_{n-m-1} & \Delta Q_1 & \cdots & \Delta Q_m \end{bmatrix}^T
$$
其中，$n$ 是节点数，$m$ 是PQ节点的数量，$n-m-1$ 是PV节点的数量，1个平衡节点。

#### 对于PQ节点的功率不平衡量：
$$
\Delta P_i = P_i - |V_i| \sum_{j=1}^n |V_j| \left( G_{ij} \cos{\theta_{ij}} + B_{ij} \sin{\theta_{ij}} \right)
$$
$$
\Delta Q_i = Q_i - |V_i| \sum_{j=1}^n |V_j| \left( G_{ij} \sin{\theta_{ij}} - B_{ij} \cos{\theta_{ij}} \right)
$$
其中，$i = 1, 2, \dots, m$，$V_i$ 是电压幅值，$\theta_{ij}$ 是电压相位差。

#### 对于PV节点：
电压幅值已给定，因此不作为变量。在迭代过程中，只考虑PV节点的有功功率偏差方程：
$$
\Delta P_i = P_i - |V_i| \sum_{j=1}^n |V_j| \left( G_{ij} \cos{\theta_{ij}} + B_{ij} \sin{\theta_{ij}} \right)
$$
其中，$i = 1, 2, \dots, n-m-1$。

---

### 雅可比矩阵的计算：

雅可比矩阵 $J$ 的元素可以分为4个部分，分别是 $H$、$N$、$J$ 和 $L$，具体计算如下：

#### 非对角元素：
$$
H_{ij} = -V_i V_j \left( G_{ij} \sin{\theta_{ij}} - B_{ij} \sin{\theta_{ij}} \right)
$$
$$
N_{ij} = -V_i V_j \left( G_{ij} \cos{\theta_{ij}} + B_{ij} \sin{\theta_{ij}} \right)
$$
$$
J_{ij} = V_i V_j \left( G_{ij} \cos{\theta_{ij}} + B_{ij} \sin{\theta_{ij}} \right)
$$
$$
L_{ij} = -V_i V_j \left( G_{ij} \sin{\theta_{ij}} - B_{ij} \cos{\theta_{ij}} \right)
$$

#### 对角元素：
$$
H_{ii} = Q_i + B_{ii} V_i^2
$$
$$
N_{ii} = -P_i - G_{ii} V_i^2
$$
$$
J_{ii} = -P_i + G_{ii} V_i^2
$$
$$
L_{ii} = -Q_i + B_{ii} V_i^2
$$

---

### 牛顿-拉夫逊法迭代计算：

在牛顿-拉夫逊法中，通过不断迭代计算，直到所有节点的修正量满足收敛条件。

修正方程为：

$$
\begin{bmatrix} \Delta P \\ \Delta Q \end{bmatrix} = \begin{bmatrix} H & N \\ J & L \end{bmatrix} \begin{bmatrix} \Delta \theta \\ \Delta V^{-1} \Delta V \end{bmatrix}
$$

通过解得修正量 $\Delta \theta$ 和 $\Delta V$，更新节点电压：

$$
\begin{bmatrix} \theta^{(k+1)} \\ V^{(k+1)} \end{bmatrix} = \begin{bmatrix} \theta^{(k)} \\ V^{(k)} \end{bmatrix} + \begin{bmatrix} \Delta \theta^{(k+1)} \\ \Delta V^{(k+1)} \end{bmatrix}
$$

反复迭代，直到满足收敛条件：$\Delta V < \varepsilon$ 和 $\Delta \theta < n$，其中 $\varepsilon$ 是允许的误差，$n$ 是最大迭代次数。

matlab-牛顿拉夫逊法计算潮流

## 推理图片：

```python
import numpy as np
from PIL import Image
import requests
from transformers import AutoProcessor, AutoModel
import torch

# 初始化模型和处理器
processor = AutoProcessor.from_pretrained("/ssd/xiedong/siglip-so400m-patch14-384")
model = AutoModel.from_pretrained("/ssd/xiedong/siglip-so400m-patch14-384")

# 将模型移动到 GPU 上
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# 提取图片特征的函数
def get_image_features(image: Image.Image):
    """
    输入一张图片，输出其特征向量。
    :param image: 输入图片 (PIL.Image)
    :return: 图片特征向量 (list)
    """
    # 处理图像输入，使其可以输入模型
    inputs = processor(images=image, return_tensors="pt").to(device)  # 将输入张量移动到设备上

    # 不计算梯度 (inference 模式)
    with torch.no_grad():
        # 提取图片特征
        image_features = model.get_image_features(**inputs)

    # 对特征进行 L2 归一化
    image_features = image_features / image_features.norm(p=2, dim=-1, keepdim=True)

    # 转换为 CPU 上的 list
    return image_features.cpu().tolist()

# 示例用法
if __name__ == "__main__":
    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
    image = Image.open(requests.get(url, stream=True).raw)
    features = get_image_features(image)
    print(np.asarray(features).shape)
    print("Image Features:", features)
```



## fastapi：


```python
import json

from PIL import Image
import requests
from transformers import AutoProcessor, AutoModel
import torch
import traceback
import time
from typing import Dict, Optional

from fastapi import FastAPI, File, UploadFile, Form
from fastapi.responses import JSONResponse
from fastapi.exceptions import RequestValidationError
from pydantic import BaseModel, Field
from PIL import Image
from io import BytesIO

# 初始化模型和处理器
processor = AutoProcessor.from_pretrained("/ssd/xiedong/siglip-so400m-patch14-384")
model = AutoModel.from_pretrained("/ssd/xiedong/siglip-so400m-patch14-384")

# 将模型移动到 GPU 上
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)


# 提取图片特征的函数
def get_image_features(image: Image.Image):
    """
    输入一张图片，输出其特征向量。
    :param image: 输入图片 (PIL.Image)
    :return: 图片特征向量 (list)
    """
    # 处理图像输入，使其可以输入模型
    inputs = processor(images=image, return_tensors="pt").to(device)  # 将输入张量移动到设备上

    # 不计算梯度 (inference 模式)
    with torch.no_grad():
        # 提取图片特征
        image_features = model.get_image_features(**inputs)

    # 对特征进行 L2 归一化
    image_features = image_features / image_features.norm(p=2, dim=-1, keepdim=True)

    # 转换为 CPU 上的 list
    return image_features.cpu().tolist()


app = FastAPI()


class CustomHTTPException():
    """自定义异常"""

    def __init__(self, description: str, error_code: int, detail: str):
        self.description = description
        self.error_code = error_code
        self.detail = detail

    def to_response_dict(self):
        """格式化响应数据"""
        return {
            "description": self.description,
            "content": {
                "application/json": {
                    "example": {"code": self.error_code,
                                "data": {},
                                "message": self.detail,
                                }
                }
            },
        }

    def __call__(self, extra_detail=None, code=500):
        """自定义异常响应"""
        if extra_detail is not None:
            detailx = json.dumps({"detail": self.detail, "extra_detail": extra_detail},
                                 indent=4, ensure_ascii=False)
        else:
            detailx = self.detail
        return JSONResponse(content={"code": code,
                                     "data": {},
                                     "message": detailx,
                                     },
                            status_code=self.error_code)


@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request, exc):
    """处理请求校验异常"""
    message = ""
    for error in exc.errors():
        message += ".".join(error.get("loc")) + ":" + error.get("msg") + ";"
    return JSONResponse(content={"code": 422,
                                 "data": {},
                                 "message": "输入参数不符合要求: " + str(message)},
                        status_code=422)


ErrorResponseFeatureExtraction = CustomHTTPException("Feature Extraction API Error", 505, "# 图片特征提取出错\n")


class ImageFeatureResponse(BaseModel):
    """图像特征接口返回模型"""
    code: int
    message: str
    features: Optional[Dict] = Field(None, description="提取的图片特征")
    requestId: Optional[str] = Field(None, description="请求 ID")


@app.post("/extract_features", response_model=ImageFeatureResponse,
          responses={505: ErrorResponseFeatureExtraction.to_response_dict()})
async def extract_image_features(
        requestId: Optional[str] = Form(None, description="请求 ID"),
        file: UploadFile = File(..., description="上传的图片文件")
):
    try:
        start_time = time.time()

        # 检查文件格式
        if "image" not in file.content_type:
            return ErrorResponseFeatureExtraction(
                extra_detail=f"# 文件格式不正确，文件类型应为图片，实际为 {file.content_type}"
            )

        # 读取图像数据
        image_bytes = await file.read()
        image = Image.open(BytesIO(image_bytes)).convert("RGB")

        # 提取图像特征
        features = get_image_features(image)

        end_time = time.time()

        return {
            "code": 200,
            "message": "Success",
            "features": {"feature": features},
            "requestId": requestId,
            "data": {
                "processing_time": round(end_time - start_time, 3)
            }
        }

    except Exception as e:
        return ErrorResponseFeatureExtraction(
            extra_detail=f"# 错误信息: {str(traceback.format_exc())}"
        )


if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="0.0.0.0", port=7898)

```


## 客户端请求


```python
import requests
import os

# 定义下载图片和请求接口的函数
def download_image(url, save_path):
    """
    下载图片到本地
    :param url: 图片的URL
    :param save_path: 保存图片的路径
    """
    response = requests.get(url, stream=True)
    if response.status_code == 200:
        with open(save_path, 'wb') as file:
            for chunk in response.iter_content(1024):
                file.write(chunk)
        print(f"图片已保存到: {save_path}")
    else:
        print(f"图片下载失败, 状态码: {response.status_code}")
        raise Exception("图片下载失败")

def send_request(server_url, file_path, request_id=None):
    """
    向特征提取接口发送 POST 请求
    :param server_url: 接口地址
    :param file_path: 本地图片路径
    :param request_id: 请求 ID（可选）
    :return: 服务器返回的响应
    """
    with open(file_path, 'rb') as file:
        files = {'file': (os.path.basename(file_path), file, 'image/jpeg')}
        data = {'requestId': request_id} if request_id else {}
        response = requests.post(server_url, files=files, data=data)

    return response

if __name__ == "__main__":
    # 图片下载 URL 和保存路径
    image_url = "http://images.cocodataset.org/val2017/000000039769.jpg"
    image_path = "./000000039769.jpg"

    # API 接口 URL
    api_url = "http://127.0.0.1:7898/extract_features"  # 根据实际部署地址修改

    try:
        # 1. 下载图片到本地
        download_image(image_url, image_path)

        # 2. 发送请求到接口
        request_id = "example_request_id"
        response = send_request(api_url, image_path, request_id=request_id)

        # 3. 打印服务器返回结果
        if response.status_code == 200:
            print("接口返回结果:")
            print(response.json())
        else:
            print(f"接口请求失败, 状态码: {response.status_code}")
            print("错误信息:", response.text)
    except Exception as e:
        print("发生错误:", str(e))
```

## 接口文档

### 提取图像特征接口 POST /extract_features

- **概述**：提取给定图像的特征向量。
- **描述**：此接口接受上传的图片文件，提取其高维特征向量，用于后续的图像检索及分析。

---

### 请求体  

- **file** (文件): **必须**，通过 `multipart/form-data` 上传的图片文件，支持的图片格式包括 `JPEG`, `PNG` 等。
- **requestId** (字符串, 可选): 每个请求的唯一标识符，接口会原样返回。

**示例请求**：
```bash
curl -X POST "http://<server_ip>:<port>/extract_features" \
-H "Content-Type: multipart/form-data" \
-F "file=@/path/to/example.jpg" \
-F "requestId=feature_extraction_request"
```

---

### 响应  

#### HTTP 状态码==200  
- **响应内容**：  
  - **code** (整数): 固定为 `200`，表示成功。  
  - **message** (字符串): 成功提示，固定为 `"Success"`。  
  - **features** (字典): 包含提取的图像特征向量。  
    - **feature** (数组): 图像的特征向量，每一项为浮点数（高维特征向量，可能包含上百维）。  
  - **requestId** (字符串, 可选): 请求的唯一标识符（如果输入了 `requestId`）。  
  - **data** (字典, 可选):  
    - **processing_time** (浮点数): 处理耗时，单位为秒，表示从接收到请求到返回特征向量所消耗的时间。  

**示例响应（成功）**：
```json
{
  "code": 200,
  "message": "Success",
  "features": {
    "feature": [
      0.245123, 
      0.003452, 
      -0.114215, 
      ..., 
      0.451223
    ]
  },
  "requestId": "feature_extraction_request",
  "data": {
    "processing_time": 0.289
  }
}
```

#### HTTP 状态码==505  
- **响应内容**：  
  - **code** (整数): 固定为 `505`，表示内部错误。  
  - **data** (字典): 固定为空字典 `{}`。  
  - **message** (字符串): 包含错误信息，包括基础错误提示和详细堆栈信息（如果有）。  

**示例响应（异常）**：
```json
{
  "code": 505,
  "data": {},
  "message": "# 图片特征提取出错\n# 错误信息: Traceback (most recent call last):\n    File \"/path/to/app.py\", line 120, in extract_image_features\n    image = Image.open(BytesIO(image_bytes)).convert(\"RGB\")\n  ...\nUnidentifiedImageError: cannot identify image file <_io.BytesIO object at 0x7f8e0b89>",
}
```

#### HTTP 状态码==422  
- **响应内容**：  
  - **code** (整数): 固定为 `422`，表示请求参数校验错误。  
  - **data** (字典): 固定为空字典 `{}`。  
  - **message** (字符串): 输入参数验证失败的详细描述。  

**示例响应（参数错误）**：
```json
{
  "code": 422,
  "data": {},
  "message": "输入参数不符合要求: file：缺少上传的图片; requestId：值应该是字符串;"
}
```

部署siglip-so400m-patch14-384为API

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。

使用 litellm 简化 Azure GPT-4 调用

推理图片：

使用 `litellm` 简化 Azure GPT-4 调用