Python

## 快捷介绍

```python
www.gpt516.com
https://one.aiskt.com/token
```



代码：

```python
from openai import OpenAI
api_key = "sk-189I1Oj2NleZ3tbg4d32D3D9E2Ab4525Bd84A492"
api_base = "https://api.aiskt.com/v1"
client = OpenAI(api_key=api_key, base_url=api_base)
completion = client.chat.completions.create(
  model="gpt-3.5-turbo-16k-0613",
  messages=[
    {"role": "system", "content": "你好，你是什么模型，你叫什么名字，你是被谁开发的"},
    # {"role": "user", "content": "你好，你是什么模型"}
  ]
)
print(completion.choices[0].message)
```

## 详细介绍
要使用 Python 访问 OpenAI 的 GPT-4 API，您可以按照以下步骤操作。以下是详细的指南和示例代码。

### 步骤指南：

1. **注册并获取 API 密钥**：
   - 前往 [OpenAI](https://platform.openai.com/) 平台，注册或登录您的账户。
   - 进入 API 部分，生成一个 API 密钥。这个密钥用于验证您的 API 请求。

2. **安装 OpenAI 的 Python 库**：
   - 使用 `pip` 来安装 OpenAI 的 Python SDK：
     ```bash
     pip install openai
     ```

3. **编写 Python 代码**：
   - 在您的脚本中使用生成的 API 密钥进行身份验证，并通过 API 发送请求给 GPT-4 模型。

下面是一个示例代码：

```python
import openai

# 设置您的 API 密钥
openai.api_key = '你的API密钥'

# 向 GPT-4 模型发送请求
response = openai.ChatCompletion.create(
  model="gpt-4",  # 指定您要使用的模型
  messages=[
    {"role": "system", "content": "你是一个乐于助人的助手。"},
    {"role": "user", "content": "如何用 Python 访问 GPT-4 API？"}
  ]
)

# 提取并打印 GPT-4 的响应
message = response['choices'][0]['message']['content']
print(message)
```

### 代码解析：
- `openai.api_key`: 将其设置为您从 OpenAI 平台生成的 API 密钥。
- `openai.ChatCompletion.create`: 该函数用于发送对话给 GPT-4 模型，`messages` 参数包含对话内容。通常需要包括用户的提问（"user"），也可以选择性地添加系统消息（"system"）来指导助手的行为。
- `model`: 该参数应设置为 `"gpt-4"`，以调用 GPT-4 模型。

### 示例输出：
当您运行这段代码时，GPT-4 模型会根据提供的对话返回一个响应，您可以打印该响应，或者将其集成到您的应用程序中。

### 重要说明：
- **速率限制**：OpenAI 对每分钟的请求数量有限制，建议查看 [API 文档](https://platform.openai.com/docs/) 以了解最新的限制和计费详情。
- **错误处理**：建议您使用 `try-except` 块来处理网络问题或无效 API 密钥等错误情况。

### 附加功能：
您还可以根据具体需求调整请求参数，如：
- `max_tokens`: 控制返回内容的长度。
- `temperature`: 控制生成文本的随机性。较高的值（如 0.8）会生成更随机的输出，较低的值（如 0.2）则生成更确定的结果。

通过这段代码，您应该能够成功使用 Python 访问 GPT-4 的 API。如果有更多需求，还可以根据 OpenAI 文档进一步自定义您的 API 请求。

如何使用Python语言访问ChatGPT样式的接口？

# 方案一览





本篇博客将介绍如何在Docker容器中打开SSH连接服务，以及如何使用JetBrains Gateway软件进行代码调试。

## Gateway软件介绍

JetBrains Gateway是一款紧凑型桌面应用，可让您通过 JetBrains IDE 远程工作，甚至无需下载这些IDE。通过在桌面端安装这款软件，您可以直接调试服务器上的代码。

![JetBrains Gateway](/static/img/images/03665.png)

## 启动容器

使用以下命令启动容器，其中 `--net host` 参数是为了让容器使用宿主机的网络。

```bash
docker run -it --net host --gpus all kevinchina/deeplearning:cu11.8ubuntu22.04 bash
```

您也可以指定端口，比如将宿主机的2024端口映射到容器的22端口：

```bash
docker run -it -p 2024:22 --gpus all kevinchina/deeplearning:cu11.8ubuntu22.04 bash
```

## 配置apt源

详细配置apt源，请参考博客：[https://qq742971636.blog.csdn.net/article/details/134291339](https://qq742971636.blog.csdn.net/article/details/134291339)

对于Ubuntu 22.04，配置文件如下：

```bash
vim /etc/apt/sources.list
```

```bash
deb http://mirrors.aliyun.com/ubuntu/ jammy main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-security main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-backports main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu/ jammy main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu/ jammy-security main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu/ jammy-updates main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu/ jammy-backports main restricted universe multiverse
## Pre-released source, not recommended.
# deb http://mirrors.aliyun.com/ubuntu/ jammy-proposed main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu/ jammy-proposed main restricted universe multiverse
```

## 在容器中安装SSH服务器

在容器内运行以下命令来安装SSH服务器，确保已经安装了openssh-server：

```bash
apt-get update
apt-get install -y openssh-server
```

## 配置SSH服务器

编辑SSH服务器配置文件 `/etc/ssh/sshd_config`，确保以下行被设置为合适的值：

```bash
Port 2024 # 根据需求设置，容器Linux开启SSH服务的默认端口是22
PermitRootLogin yes  # 允许root用户登录（可选，根据需要设置）
PasswordAuthentication yes  # 允许密码身份验证
```

## 生成SSH密钥

如果还没有SSH密钥对，可以生成一个：

```bash
ssh-keygen -t rsa -b 2048
```

## 启动SSH服务

启动SSH服务：

```bash
service ssh start
```

或者，如果容器中使用`systemd`，使用以下命令：

```bash
systemctl start ssh
```

## 为root创建密码

为root创建密码，例如设为 `nihao123`：

```bash
passwd root
nihao123
```

## 连接到容器

现在，可以使用SSH连接到Docker容器。在另一台服务器上执行以下命令：

```bash
ssh -p 2024 user@your_docker_host_ip
```

也可以直接使用root登录：

```bash
ssh -p 2024 root@101.20.31.31
```

请注意，出于安全考虑，建议使用SSH密钥进行身份验证，并将 `PasswordAuthentication` 设置为 `no`。确保防火墙允许通过所选的SSH端口的流量。


## 使用Gateway

这个就比较轻松了，别的服务器都可以ssh连接到容器里面了，此时，Gateway或者其他ssh工具就当然也是可以直接用ssh连接到容器中去。

【Python编程工具】【ssh连接Docker容器】如何使用Docker容器里的python环境，如何调试在容器中的代码

![在这里插入图片描述](/static/img/images/03756.png)






泊松图像混合（Poisson Image Editing）的原理基于泊松方程。该方法旨在保持图像中的梯度一致性，从而在图像编辑中实现平滑和无缝的混合。以下是泊松图像混合的基本原理和公式：

### 泊松方程

泊松方程是一个偏微分方程，通常用于描述物理和数学中的一些现象。在图像处理中，泊松方程的形式如下：

\[\nabla^2 u = f\]

其中，\(\nabla^2\) 是拉普拉斯算子，\(u\) 是图像中的像素值，\(f\) 是输入图像中的梯度。

### 泊松图像混合

在图像编辑中，泊松图像混合的目标是将源图像 \(S\) 中的内容（包含一些掩码区域）融合到目标图像 \(T\) 中。设混合结果为 \(R\)。

1. **定义泊松方程**

   泊松图像混合的目标是找到一个图像 \(R\)，使得在掩码区域内，\(R\) 的梯度与源图像 \(S\) 中的梯度相匹配，并且在掩码区域外，\(R\) 等于目标图像 \(T\)。

   \[\nabla^2 R = \nabla^2 S \quad \text{在掩码区域内}\]

   \[R = T \quad \text{在掩码区域外}\]

2. **离散化泊松方程**

   将泊松方程离散化，得到以下方程：

   \[4R_{i,j} - R_{i-1,j} - R_{i+1,j} - R_{i,j-1} - R_{i,j+1} = S_{i,j} \quad \text{在掩码区域内}\]

   \[R_{i,j} = T_{i,j} \quad \text{在掩码区域外}\]

   其中，\(R_{i,j}\) 是混合图像中像素 \((i,j)\) 处的值，\(S_{i,j}\) 是源图像中像素 \((i,j)\) 处的值，\(T_{i,j}\) 是目标图像中像素 \((i,j)\) 处的值。

3. **求解泊松方程**

   这是一个线性方程组，可以通过迭代求解、矩阵求逆等方法来得到混合图像 \(R\)。

在实际应用中，为了更好地处理边界和获得高质量的混合结果，通常会采用一些改进的算法，如高斯-赛德尔方法、共轭梯度法等。

请注意，上述是泊松图像混合的基本思想和公式，实际实现可能涉及到更多的细节和优化。希望这能帮助理解泊松图像混合的原理。

什么是泊松图像混合

chrome浏览器拖拽图片到本地文件夹，名字是乱的或者重名，那么我们将之前在本地的图片都命名好，就不会存在这个问题。






用python写一个程序，不断监测C:\Users\xjsd\Desktop\outpainting_test_data内的文件名（不算后缀），如果命名不满足f0001【0001是递增的】，就将该文件名改为满足规范的（后缀保持原样）。

python

```python
import os
import re
import time
def rename_files(directory_path):
    # Get a list of existing file names in the directory
    existing_files = [f for f in os.listdir(directory_path) if os.path.isfile(os.path.join(directory_path, f))]
    # Sort the existing file names
    existing_files.sort()
    # Initialize a counter for the new names
    counter = len(existing_files)
    # Iterate through existing files
    for filename in existing_files:
        base_name, file_extension = os.path.splitext(filename)
        # Define the expected pattern f0001
        pattern = re.compile(r'f(\d{4})')
        # Check if the current filename matches the pattern
        match = re.match(pattern, base_name)
        if not match:
            while 1:
                # If not, generate a new filename following the pattern
                new_filename = f'f{str(counter).zfill(4)}{file_extension}'
                # Update the counter
                counter += 1
                # Check if the new filename already exists
                if new_filename not in existing_files:
                    break
            # Rename the file
            old_file_path = os.path.join(directory_path, filename)
            new_file_path = os.path.join(directory_path, new_filename)
            os.rename(old_file_path, new_file_path)
            print(f'Renamed: {filename} -> {new_filename}')
# Replace 'C:\\Users\\xjsd\\Desktop\\outpainting_test_data' with your actual directory path
directory_path = r'C:\Users\xjsd\Desktop\outpainting_test_data'
while 1:
    # Run the rename_files function
    rename_files(directory_path)
    time.sleep(1)
```

【python】chrome浏览器，拖拽图片自动命名文件

# GET方法 StreamingResponse





服务器：

```clike
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from starlette.responses import FileResponse
from pydantic import BaseModel
app = FastAPI()
# 创建一个 Base 模型，用于表示其他的 JSON 信息
class AdditionalInfo(BaseModel):
    message: str
    status: str
@app.get("/get_demo_image_with_json")
async def get_demo_image_with_json():
    # 从文件中读取字节流
    file_path = "face.png"
    file_like = open(file_path, mode="rb")
    # 模拟其他的 JSON 信息
    json_info = AdditionalInfo(message="Image loaded successfully", status="OK")
    # 使用 StreamingResponse 返回字节流和其他的 JSON 信息
    return StreamingResponse(file_like, media_type="image/jpeg",
                             headers={"Additional-Info": json_info.model_dump_json()})
if __name__ == '__main__':
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
```

客户端：

```clike
import requests
url = "http://127.0.0.1:8000/get_demo_image_with_json"
response = requests.get(url)
# 检查请求是否成功
if response.status_code == 200:
    # 获取文件的字节流
    image_data = response.content
    # 处理其他的 JSON 信息
    additional_info = response.headers.get("Additional-Info")
    # 在此处添加您的处理逻辑，例如保存字节流到文件，解析 JSON 信息等
    # ...
    print("Image loaded successfully.")
    print(f"Additional Info: {additional_info}")
else:
    print(f"Failed to fetch image. Status code: {response.status_code}")
```

# POST方法 StreamingResponse

服务器代码：

```clike
import io
from fastapi import FastAPI, File, UploadFile
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
app = FastAPI()
# 创建一个 Base 模型，用于表示其他的 JSON 信息
class AdditionalInfo(BaseModel):
    message: str
    status: str
@app.post("/get_demo_image_with_json")
async def get_demo_image_with_json():
    #  读取face.png
    image_data = open("face.png", "rb").read()
    # 模拟其他的 JSON 信息
    json_info = AdditionalInfo(message="Image loaded successfully", status="OK")
    # 使用 StreamingResponse 返回字节流和其他的 JSON 信息
    return StreamingResponse(io.BytesIO(image_data), media_type="image/png",
                             headers={"Additional-Info": json_info.model_dump_json()})
if __name__ == '__main__':
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
```

客户端参数：

```clike
import requests
url = "http://127.0.0.1:8000/get_demo_image_with_json"
response = requests.post(url)
# 检查请求是否成功
if response.status_code == 200:
    # 获取文件的字节流
    image_data = response.content
    # 写入文件
    with open("demo_image_with_json.png", "wb") as fp:
        fp.write(image_data)
    # 打印其他参数
    print(response.headers["Additional-Info"])
else:
    print(f"Failed to fetch image. Status code: {response.status_code}")
```

# 其他

还有FileResponse、base64。

FileResponse太肤浅，base64对于大文件来说太大。


在 FastAPI 中，返回文件字节流的主要方式包括使用 `StreamingResponse` 和 `FileResponse`。这两者都可以用于返回二进制数据，例如图像文件。

1. **StreamingResponse:** 适用于以流式方式发送数据，对于大型文件特别有用，因为它允许在数据生成时就开始发送，而不必等到整个数据集都可用。

    ```python
    from fastapi.responses import StreamingResponse
    @app.get("/get_demo_image")
    async def get_demo_image():
        image_data = open("face.png", "rb").read()
        return StreamingResponse(io.BytesIO(image_data), media_type="image/png")
    ```

2. **FileResponse:** 适用于返回文件，可以从文件系统路径中读取文件内容，也可以通过 `content` 参数直接传递文件内容。

    ```python
    from fastapi.responses import FileResponse
    @app.get("/get_demo_image")
    async def get_demo_image():
        image_data = open("face.png", "rb").read()
        return FileResponse(content=image_data, media_type="image/png")
    ```

这两种方法都是有效的，并且具体的选择可能取决于你的应用程序的需求和性能考虑。如果你希望以异步方式发送文件，你可能会更喜欢 `StreamingResponse`。如果你只是从文件系统中返回文件，`FileResponse` 是一个更简单的选择。

# 上传文件，返回文件的一个示例程序

```clike
from fastapi.responses import StreamingResponse
from fastapi import Depends, FastAPI, Header, Query, Response, UploadFile, Form
# 字节流
@app.post("/image_upscaler_bytes", summary="Image Upscaler Bytes",
          responses={image_upscaler_CustomErrorResponse.error_code:
                         image_upscaler_CustomErrorResponse.to_response_dict()})
def image_upscaler_bytes(image: UploadFile = File(..., title="图像字节流", description="图像字节流"),
                         outscale: float = Form(2, ge=1.0, le=5.0, title="图像超分倍率",
                                                description="图像超分倍率"),
                         requestId: str = Form("", title="Request Id", description="requestId to be returned")):
    """
    Image Upscaler.
    """
    try:
        img = cv2.imdecode(np.fromstring(image.file.read(), np.uint8), cv2.IMREAD_COLOR)
        output, _ = upsampler.enhance(img, outscale=outscale)
        # output = enhance_image(img, outscale=outscale)
        if output is None:
            return image_upscaler_CustomErrorResponse()
        else:
            # 返回字节流
            return StreamingResponse(io.BytesIO(cv2.imencode('.png', output)[1].tobytes()), media_type="image/png",
                                     headers={'requestId': requestId})
    except:
        traceback.print_exc()
        return image_upscaler_CustomErrorResponse(str(traceback.format_exc()))
```

# 关于压缩

```clike
FastAPI本身没有直接支持响应内容压缩的中间件，但你可以通过使用 Starlette 的中间件来实现这一功能。具体来说，Starlette 提供了 `Middleware` 类，你可以使用它来定义自定义中间件。以下是一个简单的例子，演示如何使用 Gzip 中间件来压缩响应内容：
```python

from fastapi import FastAPI

from fastapi.responses import StreamingResponse

from starlette.responses import FileResponse

from starlette.middleware.gzip import GZipMiddleware

from pydantic import BaseModel

app = FastAPI()

# 使用 Gzip 中间件

app.add_middleware(GZipMiddleware, minimum_size=1000, compress_level=6)

# 创建一个 Base 模型，用于表示其他的 JSON 信息

class AdditionalInfo(BaseModel):

    message: str

    status: str

@app.get("/get_demo_image_with_json")

async def get_demo_image_with_json():

    # 从文件中读取字节流

    file_path = "face.png"

    file_like = open(file_path, mode="rb")

    # 模拟其他的 JSON 信息

    json_info = AdditionalInfo(message="Image loaded successfully", status="OK")

    # 使用 StreamingResponse 返回字节流和其他的 JSON 信息

    return StreamingResponse(file_like, media_type="image/jpeg",

                             headers={"Additional-Info": json_info.json()})
```

在上述代码中，通过添加 `GZipMiddleware` 到 FastAPI 应用中，你启用了 Gzip 压缩。在 `StreamingResponse` 中返回的字节流会在传输过程中被压缩。请注意，Gzip 压缩可能会增加 CPU 使用，但通常可以显著减小传输的数据量，提高性能。你可以根据需求调整 `minimum_size` 和 `compress_level` 参数。

FastAPI如何返回文件字节流？并且附带一些json参数

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