本文将为您介绍如何在 Ubuntu 环境下使用 Docker 拉取 ModelScope 镜像并进行模型推理和微调miniCPM2.6。以下是详细步骤。




#### 环境准备

首先，确保您的环境已经安装了 Docker。然后，拉取指定的 ModelScope 镜像：

```bash
docker pull modelscope-registry.cn-beijing.cr.aliyuncs.com/modelscope-repo/modelscope:ubuntu22.04-cuda12.1.0-py310-torch2.3.0-tf2.16.1-1.16.0
```

#### 启动容器并安装 SWIFT

接下来，启动 Docker 容器并克隆 SWIFT 仓库：

```bash
git clone https://github.com/modelscope/swift.git

docker run -it --gpus device=1 -v /root/xiedong/swift:/root/xiedong/swift modelscope-registry.cn-beijing.cr.aliyuncs.com/modelscope-repo/modelscope:ubuntu22.04-cuda12.1.0-py310-torch2.3.0-tf2.16.1-1.16.0 bash

cd /root/xiedong/swift
pip install -e .[llm]
```

使用 pip 命令安装不同版本的 SWIFT：

```bash
# 全量能力
pip install 'ms-swift[all]' -U
# 仅使用 LLM
pip install 'ms-swift[llm]' -U
# 仅使用 AIGC
pip install 'ms-swift[aigc]' -U
# 仅使用 Adapters
pip install ms-swift -U
```

### 模型推理

在准备好环境之后，您可以使用以下命令进行模型推理：

```bash
CUDA_VISIBLE_DEVICES=0 swift infer \
  --model_type minicpm-v-v2_6-chat \
  --model_id_or_path /root/xiedong/swift/MiniCPM-V-2_6
```

以下是一些推理示例：

```bash
<<< 你好
你好！今天我能为您提供什么帮助？
```

```bash
<<< <image>描述这张图片
Input an image path or URL <<< http://modelscope-open.oss-cn-hangzhou.aliyuncs.com/images/cat.png
```

### 图片微调

我们可以使用 `coco-en-mini` 数据集对模型进行微调，该数据集的任务是对图片内容进行描述。

使用多张 GPU 卡：

```bash
CUDA_VISIBLE_DEVICES=0,1,2,3 NPROC_PER_NODE=4 swift sft \
  --model_type minicpm-v-v2_6-chat \
  --model_id_or_path OpenBMB/MiniCPM-V-2_6 \
  --sft_type lora \
  --dataset coco-en-mini#20000 \
  --deepspeed default-zero2
```

使用单张 GPU 卡：

```bash
CUDA_VISIBLE_DEVICES=0 NPROC_PER_NODE=1 swift sft \
  --model_type minicpm-v-v2_6-chat \
  --model_id_or_path /root/xiedong/swift/MiniCPM-V-2_6 \
  --sft_type lora \
  --dataset coco-en-mini#20000 \
  --deepspeed default-zero2
```

### 自定义数据集

如果要使用自定义数据集，只需按以下方式进行指定：

```bash
  --dataset train.jsonl \
  --val_dataset val.jsonl \
```

自定义数据集支持 JSON 和 JSONL 样式，以下是自定义数据集的样例：

```json
{"query": "<image>55555", "response": "66666", "images": ["image_path"]}
{"query": "eeeee<image>eeeee<image>eeeee", "response": "fffff", "history": [], "images": ["image_path1", "image_path2"]}
{"query": "EEEEE", "response": "FFFFF", "history": [["query1", "response2"], ["query2", "response2"]], "images": []}
```

微调后推理脚本如下：

```bash
CUDA_VISIBLE_DEVICES=0 swift infer \
    --ckpt_dir output/minicpm-v-v2_6-chat/vx-xxx/checkpoint-xxx \
    --load_dataset_config true --merge_lora true
```

### Web UI 操作

启动 Web UI 以进行交互操作：

```bash
docker run -it --gpus device=1 -v /root/xiedong/swift:/root/xiedong/swift --net host kevinchina/deeplearning:swift bash
```

```bash
swift web-ui
```

### Swift SFT 重要参数解释

在进行 LoRA 微调时，以下参数至关重要：

- --model_type 模型类型
- --model_id_or_path 模型ID或路径
- --model_revision 模型版本
- --sft_type SFT类型（可选：lora, full, longlora, adalora, ia3, llamapro, adapter, vera, boft, fourierft, reft）
- --freeze_parameters 冻结参数
- --tuner_backend 调优器后端（可选：swift, peft, unsloth）
- --output_dir 输出目录
- --seed 随机种子
- --resume_from_checkpoint 从检查点恢复
- --dtype 数据类型（可选：bf16, fp16, fp32, AUTO）
- --train_backend 训练后端（可选：transformers, megatron）
- --min_lr 最小学习率
- --loss_name 损失名称
- --dataset 数据集
- --val_dataset 验证数据集
- --sequence_parallel 序列并行
- --lora_rank LoRA 排名
- --lora_alpha LoRA Alpha
- --lora_dropout LoRA丢弃率
- --adam_beta1 Adam Beta1
- --adam_beta2 Adam Beta2
- --learning_rate 学习率
- --weight_decay 权重衰减
- --num_train_epochs 训练轮数
- --max_steps 最大步骤
- --lr_scheduler_type 学习率调度类型
- --save_steps 保存步骤
- --eval_steps 验证步骤
- --logging_steps 日志记录步骤
- --per_device_train_batch_size 每设备训练批量大小
- --per_device_eval_batch_size 每设备验证批量大小


### 训练实例

以下是使用一张 GPU 卡进行训练的示例：

```bash
CUDA_VISIBLE_DEVICES=0 NPROC_PER_NODE=1 swift sft \
  --model_type minicpm-v-v2_6-chat \
  --model_id_or_path /root/xiedong/swift/MiniCPM-V-2_6 \
  --sft_type lora \
  --dataset coco-en-mini#20000 \
  --deepspeed default-zero2 --lora_rank 512 --lora_alpha 256
```

### 印章数据制作

（待补充）

## 训练效果

（待补充）

以上即为在 Ubuntu 环境下使用 ModelScope 进行模型推理与微调的全过程。希望本博客能够对您有所帮助！

【深度学习】miniCPM2.6，微调sft训练用于印章识别

在本篇博客中，我将详细介绍如何使用 Docker Compose 在服务器上部署 WordPress，包括 Docker Compose 的安装、基础使用方法，以及如何管理 WordPress 容器。





## 1. 环境准备

### Docker Compose 安装

#### 在 Ubuntu 系统上安装

```bash
sudo apt-get update
sudo apt-get install -y docker-compose-plugin
```

#### 在 Red Hat 系统上安装

```bash
sudo yum update -y
sudo yum install -y docker-compose-plugin
```

安装完成后，您可以使用以下命令验证安装是否成功：

```bash
docker compose version
```

如果成功安装，会显示 Docker Compose 的版本信息。

## 2. 项目配置

### 目录和文件准备

在服务器上创建一个目录来存放 WordPress 相关文件：

```bash
mkdir -p /root/WordPress/
cd /root/WordPress/
```

### 创建 `docker-compose.yml` 文件

在 `/root/WordPress/` 目录下创建一个名为 `docker-compose.yml` 的文件，并写入以下内容：

```yaml
version: '3.8'

services:
  wordpress:
    build: .
    container_name: wordpress
    ports:
      - "80:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: root
      WORDPRESS_DB_PASSWORD: "mX5sL2dP-kl"
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - /root/WordPress/wp-data:/var/www/html
    depends_on:
      - db

  db:
    image: mysql:8.0
    container_name: mysql
    environment:
      MYSQL_ROOT_PASSWORD: "mX5sL2dP-kl"
      MYSQL_DATABASE: wordpress
    volumes:
      - /root/WordPress/mysql-data:/var/lib/mysql
    healthcheck:
      test: ["CMD-SHELL", "mysqladmin ping -h 127.0.0.1 -u root -p${MYSQL_ROOT_PASSWORD} || exit 1"]
      interval: 10s
      timeout: 5s
      retries: 5
```

### 创建 `Dockerfile` 文件

在同一目录下创建一个名为 `Dockerfile` 的文件，并写入以下内容：

```Dockerfile
FROM wordpress:latest

RUN apt-get update && apt-get install -y nano

# 修改 php.ini 配置
RUN echo "upload_max_filesize = 64M" >> /usr/local/etc/php/php.ini
RUN echo "post_max_size = 64M" >> /usr/local/etc/php/php.ini
```

这个 Dockerfile 将基于官方的 WordPress 镜像构建，并在其中安装 `nano` 编辑器，同时修改 PHP 的配置文件以增加上传文件的大小限制。

## 3. 使用 Docker Compose 部署 WordPress

### 启动 WordPress

在 `/root/WordPress/` 目录下运行以下命令来构建并启动容器：

```bash
docker-compose up --build -d
```

这个命令会构建 WordPress 容器并在后台运行（`-d` 参数）。构建过程会根据 `Dockerfile` 和 `docker-compose.yml` 文件中的配置进行。

### 停止所有服务

如果需要停止所有运行的容器，可以使用以下命令：

```bash
docker-compose down
```

这将停止并删除所有与 `docker-compose.yml` 文件相关的容器和网络。

### 重启服务

如果需要重启容器，可以使用以下命令：

```bash
docker-compose restart
```

这个命令会重新启动所有已停止的容器。

## 4. 访问 WordPress

容器启动后，您可以通过服务器的 IP 地址在浏览器中访问 WordPress 网站。例如，如果您的服务器 IP 是 `192.168.1.100`，则可以在浏览器中输入 `http://192.168.1.100` 来访问。

## 5. 总结

通过 Docker Compose，您可以轻松地在服务器上部署 WordPress 网站，管理 MySQL 数据库，并根据需要进行自定义配置。Docker Compose 的安装和使用过程简单明了，是构建和管理容器化应用的强大工具。希望这篇教程能帮助您顺利部署并管理您的 WordPress 网站。

【建站教程】如何用Docker compose直接部署启动WordPress建站？

在提升网站的SEO表现时，使用Baidu分析工具可以帮助您更好地理解用户行为并优化网站。然而，要使这一切顺利进行，您需要获取并正确配置Baidu分析ID。下面我将一步步讲解如何获取Baidu分析ID并将其添加到您的服务器上。




### 1. 注册或登录百度统计账号

首先，您需要访问[百度统计官网](https://tongji.baidu.com/)，并使用您的百度账号进行登录。如果您还没有账号，可以快速注册一个。登录后，您就可以开始管理您的网站项目。

### 2. 创建新的网站项目

登录后，导航到“管理”部分，然后点击“添加网站”。按照提示填写您的网站信息，包括网站名称、URL、行业等内容。填写完毕后，点击保存，系统会为您生成一段用于网站统计的代码。

### 3. 获取百度统计代码

成功添加网站后，百度统计系统会生成一段统计代码。这段代码包含了您的Baidu分析ID，通常是以`hm.baidu.com/h.js%3F`开头，后面跟随一串数字和字母。

例如，您可能会得到如下代码：
```html
<script>
var _hmt = _hmt || [];
(function() {
  var hm = document.createElement("script");
  hm.src = "https://hm.baidu.com/hm.js?9f52487dbcaf597ff3732d3a160467c";
  var s = document.getElementsByTagName("script")[0]; 
  s.parentNode.insertBefore(hm, s);
})();
</script>
```
在这段代码中，您的Baidu分析ID是`9f52487dbcaf597ff3732d3a160467c`。这个ID在百度统计系统中唯一标识您的网站项目，用于数据的收集和分析。

### 4. 将百度统计代码添加到您的服务器

接下来，您需要将这段代码添加到您的网站上。具体来说，您应该将代码粘贴到每个网页的`<head>`标签内。确保每次页面加载时，这段代码都能被正确加载。这样，百度统计就可以跟踪到用户的所有行为。

### 5. 验证和优化

代码部署后，您可以通过百度统计后台查看数据是否被成功采集。如果数据开始呈现，说明Baidu分析ID已正确部署。您还可以根据数据表现来不断优化SEO策略，从而提升网站的搜索引擎排名。

我的网站是否加入SEO，手动检查代码的方法：
https://tongji.baidu.com/web/help/article?id=93&type=0

### 总结

获取并正确配置Baidu分析ID对于提升网站的SEO表现至关重要。通过注册百度统计账号、创建网站项目、获取统计代码并将其添加到网站，您可以轻松实现这一目标。记得定期查看统计数据，并根据分析结果进行持续优化。

如何获取并使用Baidu分析ID提升SEO效果

黑客是很疯狂的，只要能登录你的服务器，就可以窃取你的数据，然后用数据要挟你给钱，我的服务器一晚上被尝试这么多次：




Last failed login: Thu Aug 29 20:25:51 EDT 2024 from 39.155.215.179 on ssh:notty
There were 1827 failed login attempts since the last successful login.
Last login: Thu Aug 29 10:02:13 2024 from 120.244.236.133

如图：
![image.png](/static/img/520fd4d352efdeb60dfe47926817d13f.image.webp)


为了有效防止黑客，就一定要保护好自己打开的端口。用ss -tuln指令查看自己打开了哪些端口，如下图，可以看到我的80、443、22都是打开的。


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

网站服务的80和443端口，用Docker启动，要以非root用户的身份运行Docker容器，可以在Dockerfile中创建和使用非root用户，或者在启动容器时指定用户。这一点不强求，毕竟很多东西是需要Docker里也是root的。

宿主机ssh登录的22端口，这个端口非常重要了，一定要保护好。保护措施：

为了保护你的服务器的22端口SSH登录，你可以采取以下措施：

1. **使用强密码或SSH密钥认证**：
   - 确保所有用户使用强密码登录，或更好的是，禁用密码登录，使用SSH密钥认证。SSH密钥认证更安全，不容易被暴力破解。

这里介绍ssh密钥对登录，目前我采用的也是如此方式，首先在服务器执行：
ssh-keygen -t rsa -b 4096 -C "742971636@qq.com"
生成了密钥对。

把私钥文件/root/.ssh/id_rsa下载到windows本地C:\Users\Administrator\moba_ssh_rsa\id_rsa。确保私钥文件的安全性，不要泄露给他人。服务器的私钥可以删除掉。

本地可以用指令连接服务器：ssh -i C:\Users\Administrator\moba_ssh_rsa\id_rsa user@your_server_ip

或者用 mobaxterm 连接服务器，打开mobaxterm，如下图，使用密钥对登录：

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



2. **更改默认SSH端口**：
   - 将SSH服务的默认端口22更改为一个非标准端口，这可以减少被攻击的机会。

   具体步骤：
   - 编辑`/etc/ssh/sshd_config`文件，找到`Port 22`行并将其更改为一个非标准端口，例如`Port 2222`。
   - 重启SSH服务：`sudo systemctl restart sshd`

如下图：

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



3. **使用防火墙限制访问**：
   - 使用防火墙如`ufw`或`iptables`限制对SSH端口的访问，仅允许特定IP地址访问。

   具体步骤（使用ufw为例）：
   - 允许特定IP访问SSH：`sudo ufw allow from <your_ip> to any port 22`
   - 如果更改了端口，允许新端口：`sudo ufw allow <new_port>`
   - 启用ufw：`sudo ufw enable`


4. **启用Fail2Ban防止暴力破解**：
   - 安装并配置Fail2Ban，它会监控登录失败的尝试，并在多次失败后自动封锁可疑IP。

   具体步骤：
   - 安装Fail2Ban：`sudo apt install fail2ban`
   - 配置Fail2Ban：编辑`/etc/fail2ban/jail.local`，添加如下配置：
     ```ini
     [sshd]
     enabled = true
     port = 22
     filter = sshd
     logpath = /var/log/auth.log
     maxretry = 3
     bantime = 3600
     ```
   - 重启Fail2Ban：`sudo systemctl restart fail2ban`


5. **禁用Root用户SSH登录**：
   - 禁用root用户直接通过SSH登录，增加安全性。

   具体步骤：
   - 编辑`/etc/ssh/sshd_config`文件，找到`PermitRootLogin`行，并将其更改为`no`。
   - 重启SSH服务：`sudo systemctl restart sshd`

通过以上步骤，你可以显著提高SSH服务的安全性，减少被攻击的风险。

【建站】网络安防，如何有效保护你的服务器

使用selenium模拟浏览器行为，免得导出自己的文章还要一篇一篇点击。



下载：

https://googlechromelabs.github.io/chrome-for-testing/


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

python3.10以上，安装：


```bash
pip install selenium
```

在最后一句话打断点登录到博客管理页面。

```python
# encoding: utf-8
import time
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
import json

# 创建ChromeOptions对象
chrome_options = Options()
# chrome_options.add_argument("--headless")  # 启动无头模式
chrome_options.add_argument("--disable-gpu")

# 创建Service对象
service = Service(executable_path='chromedriver.exe')

# 创建WebDriver对象并启动浏览器
driver = webdriver.Chrome(options=chrome_options, service=service)

# 访问网页
driver.get("https://mp.csdn.net/mp_blog/manage/article?spm=3001.5298")

# 关闭浏览器
driver.quit()

```

手动在断点期间执行这个代码可以保留下来某个页面下的所有博客信息。

```python
all_blogs = []
pagex = 5
for page in range(1, pagex + 1):
    # 获取当前页面的博客数量（注意最后一页可能少于20个）
    blogs_on_page = driver.find_elements(By.XPATH,
                                         '//*[@id="view-containe"]/div/div/div[3]/div[2]/div/div[1]/div[1]/p[1]/a')
    for i, blog in enumerate(blogs_on_page, start=1):
        try:
            blog_xpath = f'//*[@id="view-containe"]/div/div/div[3]/div[2]/div[{i}]/div[1]/div[1]/p[1]/a'
            blog_name = driver.find_element(By.XPATH, blog_xpath).text
            blog_link = driver.find_element(By.XPATH, blog_xpath).get_attribute('href')
            all_blogs.append({"name": blog_name, "link": blog_link})
        except Exception as e:
            print(f"Error extracting blog on page {page}, index {i}: {e}")
    if page < pagex:
        try:
            driver.find_element(By.CLASS_NAME, "btn-next").click()
            time.sleep(2)
        except Exception as e:
            print(f"Error navigating to page {page + 1}: {e}")
            break
with open('caogaoxiang.json', 'w', encoding='utf-8') as f:
    json.dump(all_blogs, f, ensure_ascii=False, indent=4)
```

有了json信息后，依靠这个代码可以拿到自己的博客原始内容：


```python
with open('all_blogs.json', 'r', encoding='utf-8') as f:
    blogs = json.load(f)
for index, blog in enumerate(blogs, start=1):
    file_name = f"output/{index:03}.md"
    if os.path.exists(file_name):
        continue
    try:
        driver.get(blog['link'])
        time.sleep(1)
        markdown_element = driver.find_element(By.XPATH, '/html/body/div[1]/div[1]/div[2]/div/div[2]/div[1]')
        markdown_content = markdown_element.text
        with open(file_name, 'w', encoding='utf-8') as f:
            f.write(markdown_content)
        print(f"成功保存 {blog['name']} 到 {file_name}")
    except Exception as e:
        print(f"处理 {blog['name']} 时出错: {e}")
```

通过这个代码可以拿到自己博客的所有图片：


```python

import os
import re
import uuid
import requests
import markdown
from bs4 import BeautifulSoup
from urllib.parse import urlparse


# 创建一个函数来解析Markdown文件，下载图片并更新链接
def process_markdown_file(md_file, output_dir, img_cntx, dst_md):
    with open(md_file, 'r', encoding='utf-8') as f:
        markdown_content = f.read()

    # 将Markdown解析为HTML
    html = markdown.markdown(markdown_content)

    # 使用BeautifulSoup解析HTML以查找图片标签
    soup = BeautifulSoup(html, 'html.parser')
    images = soup.find_all('img')

    # 初始化一个字典来存储旧链接和新链接的映射
    img_url_mapping = {}

    # 自定义请求头来伪装为浏览器
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36'
    }
    # 遍历所有的图片标签并处理
    for img in images:
        img_url = img['src']

        try:
            # 获取图片扩展名
            parsed_url = urlparse(img_url)
            img_extension = os.path.splitext(parsed_url.path)[-1]

            # img_extension不是png jpg jpeg gif webp就

            # 生成UUID作为图片文件名
            img_name = f'{img_cntx:05d}{img_extension}'
            img_cntx += 1
            img_path = os.path.join(output_dir, img_name)

            if os.path.exists(img_path):
                img_url_mapping[img_url] = img_path
            else:
                # 下载图片
                img_data = requests.get(img_url, headers=headers).content
                # 保存图片到本地
                with open(img_path, 'wb') as img_file:
                    img_file.write(img_data)

                # 更新链接映射
                img_url_mapping[img_url] = img_path

            # print(f"成功下载图片 {img_url} 并保存为 {img_path}")
        except Exception as e:
            print(f"下载图片 {img_url} 时出错: {e}")

    # 从文件中读取正则表达式
    with open('pat.txt', 'r', encoding='utf-8') as file:
        pattern_str = file.read()

    # 编译正则表达式
    pattern = re.compile(pattern_str)

    # 替换Markdown中的图片URL
    for old_url, new_path in img_url_mapping.items():
        # 将路径中的反斜杠替换为正斜杠
        corrected_path = new_path.replace("\\", "/")
        # 使用编译后的正则表达式进行替换
        # markdown_content = pattern.sub(r'![image](' + corrected_path + r')', markdown_content)
        corrected_path = "/" + corrected_path
        markdown_content = markdown_content.replace(old_url, corrected_path)

    # 将更新后的Markdown内容保存回文件
    with open(dst_md, 'w', encoding='utf-8') as f:
        f.write(markdown_content)

    # print(f"更新后的Markdown文件已保存为 {dst_md}")

    return img_cntx


if __name__ == '__main__':
    img_cnt = 1
    srcp = "output"
    files = os.listdir(srcp)
    dst = "output_mdwebsite"
    os.makedirs(dst, exist_ok=True)
    output_dir = 'static/img/images'  # 替换为你希望保存图片的文件夹
    os.makedirs(output_dir, exist_ok=True)
    for md_file in files:
        try:
            dst_md = os.path.join(dst, md_file)
            md_file = os.path.join(srcp, md_file)
            img_cnt = process_markdown_file(md_file, output_dir, img_cnt, dst_md)
        except:
            print(md_file)

```

用这个代码取出所有tags：


```python
# encoding: utf-8
import time

from bs4 import BeautifulSoup
from fontTools.misc.psOperators import ps_string
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
import json
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# 创建ChromeOptions对象
chrome_options = Options()
# chrome_options.add_argument("--headless")  # 启动无头模式
chrome_options.add_argument("--disable-gpu")

# 创建Service对象
service = Service(executable_path='chromedriver.exe')

# 创建WebDriver对象并启动浏览器
driver = webdriver.Chrome(options=chrome_options, service=service)

# 访问网页
driver.get("https://mp.csdn.net/mp_blog/manage/article?spm=3001.5298")

# 打开all_blogs2.json文件并加载数据
with open('all_blogs2.json', 'r', encoding='utf-8') as f:
    all_blogs = json.load(f)

# 定义等待条件
wait = WebDriverWait(driver, 10)  # 设置最长等待时间为10秒


for blogdata in all_blogs:
    name = blogdata['name']
    link = blogdata['link']
    # 提取出文章ID
    get_qianzhui = "https://qq742971636.blog.csdn.net/article/details/"
    articleId = link.replace("https://editor.csdn.net/md/?articleId=", "")
    link = get_qianzhui + articleId
    blogdata['link'] = link

    # 等待元素加载
    try:
        driver.get(link)
        time.sleep(1)

        cls_name = 'blog-tags-box'

        # 等待直到指定的元素可见
        element = wait.until(EC.visibility_of_element_located((By.CLASS_NAME, cls_name)))

        elements = driver.find_elements(By.CLASS_NAME, cls_name)
        html_contents = [element.get_attribute('outerHTML') for element in elements]
        html_content = ''.join(html_contents)
        soup = BeautifulSoup(html_content, 'lxml')
        category_links = soup.select('.tags-box .label + a')
        categories = [link.text.strip() for link in category_links]
        tag_links = soup.select('.tags-box a[rel="nofollow"]')
        tags = [link.text.strip() for link in tag_links]
        blogdata['categories'] = categories
        blogdata['tags'] = tags
    except:
        print(f"Error extracting categories for blog: {name}")

    try:
        cls_name = 'time'
        time_element = driver.find_element(By.CLASS_NAME, cls_name)
        time_text = time_element.text
        blogdata['time'] = time_text
    except:
        print(f"Error extracting time for blog: {name}")

# 将所有数据保存到一个JSON文件中
with open('all_blogs3.json', 'w', encoding='utf-8') as f:
    json.dump(all_blogs, f, ensure_ascii=False, indent=4)

# 关闭浏览器
driver.quit()

```


最终用这个代码进行传输博客到自己服务器：


```python
import json
import os

import re
import time
from datetime import datetime, timezone, timedelta
import requests


def adjust_markdown_line_breaks(input_file, output_file):
    with open(input_file, 'r', encoding='utf-8') as file:
        content = file.read()

    # 使用正则表达式替换不在代码块中的单个换行符为双换行符
    adjusted_content = re.sub(r'(?<!\n)\n(?!\n|```)', '\n\n', content)

    with open(output_file, 'w', encoding='utf-8') as file:
        file.write(adjusted_content)


# chuli_wenzhang = './danpianji.json'
# categoriesx = '单片机ban'

# chuli_wenzhang = './shenduxuexi.json'
# categoriesx = '深度学习ban'

# chuli_wenzhang = './linuxyunwei.json'
# categoriesx = 'Linux运维'

chuli_wenzhang = './taobaozuopin.json'
categoriesx = '售卖作品'

jinwokejian_wenzhang = 'jinwokejian.json'
caogaoxiang_wenzhang = 'caogaoxiang.json'
all_wenzhang_xinxi = "all_blogs3.json"

src = r"C:\Users\Administrator\Downloads\csdn-blog-export-main"
src_md_path = r"C:\Users\Administrator\Downloads\csdn-blog-export-main\output_mdwebsite"

dst_md = r"C:\Users\Administrator\Downloads\csdn-blog-export-main\md"
os.makedirs(dst_md, exist_ok=True)

with open(chuli_wenzhang, 'r', encoding='utf-8') as f:
    linuxyunwei_data = json.load(f)

with open(jinwokejian_wenzhang, 'r', encoding='utf-8') as f:
    jinwokejian_data = json.load(f)

with open(caogaoxiang_wenzhang, 'r', encoding='utf-8') as f:
    caogaoxiang_data = json.load(f)

with open(all_wenzhang_xinxi, 'r', encoding='utf-8') as f:
    all_blogs = json.load(f)

# 用文章id做key，文章信息做value，all_blogs
all_blogs_dict = {}
for index, blog_dict in enumerate(all_blogs):
    blog_dict['index'] = index + 1
    id = blog_dict['link'].replace('https://qq742971636.blog.csdn.net/article/details/', '')
    if id in all_blogs_dict:
        print('id重复', id)
    all_blogs_dict[id] = blog_dict

# 仅我可见的文章要从chuli_wenzhang删除，先整上id
chuli_wenzhang_dict = {}
for blog_dict in linuxyunwei_data:
    id = blog_dict['link'].replace('https://editor.csdn.net/md/?articleId=', '')
    chuli_wenzhang_dict[id] = blog_dict

# jinwokejian_wenzhang
jinwokejian_wenzhang_dict = {}
for blog_dict in jinwokejian_data:
    id = blog_dict['link'].replace('https://editor.csdn.net/md/?articleId=', '')
    jinwokejian_wenzhang_dict[id] = blog_dict

# caogaoxiang
caogaoxiang_wenzhang_dict = {}
for blog_dict in caogaoxiang_data:
    id = blog_dict['link'].replace('https://editor.csdn.net/md/?articleId=', '')
    caogaoxiang_wenzhang_dict[id] = blog_dict

# 删除chuli_wenzhang_dict中的仅我可见的文章
for id in jinwokejian_wenzhang_dict:
    if id in chuli_wenzhang_dict:
        del chuli_wenzhang_dict[id]
        print('删除了', id)

# 删除chuli_wenzhang_dict中的草稿文章
for id in caogaoxiang_wenzhang_dict:
    if id in chuli_wenzhang_dict:
        del chuli_wenzhang_dict[id]
        print('删除了', id)

# 用id读取md文件，然后写入到dst_md
for id in chuli_wenzhang_dict:
    blog_dict = all_blogs_dict[id]
    name = blog_dict['name']
    index = blog_dict['index']
    src_md_file = os.path.join(src_md_path, f'{index:03}.md')
    dst_md_file = os.path.join(dst_md, f'{index:03}.md')
    adjust_markdown_line_breaks(src_md_file, dst_md_file)


def remove_first_newline(directory):
    # 遍历指定目录下的所有文件
    for filename in os.listdir(directory):
        if filename.endswith(".md"):
            file_path = os.path.join(directory, filename)
            with open(file_path, 'r', encoding='utf-8') as file:
                lines = file.readlines()

            # 如果第一行是空行，移除它
            if lines and lines[0].strip() == '':
                lines.pop(0)
                print(f'Removed first newline in {file_path}')

            # 重新写入文件
            with open(file_path, 'w', encoding='utf-8') as file:
                file.writelines(lines)


for i in range(6):
    # 调用函数，传入你的md文件所在的目录路径
    remove_first_newline(dst_md)

import os


def add_prefix_if_codeblock(directory):
    # 遍历指定目录下的所有文件
    for filename in os.listdir(directory):
        if filename.endswith(".md"):
            file_path = os.path.join(directory, filename)
            with open(file_path, 'r', encoding='utf-8') as file:
                lines = file.readlines()

            # 检查文件是否以```开头
            if lines and lines[0].strip().startswith("```"):
                # 在文件开头添加"运维信息："
                lines.insert(0, chuli_wenzhang)
                print(f'Added prefix in {file_path}')

            # 重新写入文件
            with open(file_path, 'w', encoding='utf-8') as file:
                file.writelines(lines)


# 调用函数，传入你的md文件所在的目录路径
add_prefix_if_codeblock(dst_md)


def add_more_marker(directory):
    # 遍历指定目录下的所有文件
    for filename in os.listdir(directory):
        if filename.endswith(".md"):
            file_path = os.path.join(directory, filename)
            with open(file_path, 'r', encoding='utf-8') as file:
                lines = file.readlines()

            # 检查文件中是否含有
            if "" not in "".join(lines):
                # 如果第一行后不存在，插入在第二行
                lines.insert(1, "\n\n\n\n")

            # 重新写入文件
            with open(file_path, 'w', encoding='utf-8') as file:
                file.writelines(lines)


# 调用函数，传入你的md文件所在的目录路径
add_more_marker(dst_md)

import os
import re


def remove_blank_lines_in_code_blocks(md_content):
    # 正则表达式匹配代码块
    code_block_pattern = r'(```[\s\S]*?```)'  # 匹配以 ``` 开始和结束的代码块

    def remove_blank_lines(match):
        # 获取匹配的代码块内容
        code_block = match.group(0)
        # 去掉代码块中的空行
        code_block = re.sub(r'\n\s*\n', '\n', code_block)
        return code_block

    # 使用sub方法替换代码块中的内容
    modified_content = re.sub(code_block_pattern, remove_blank_lines, md_content)

    return modified_content


def process_md_files_in_directory(directory):
    # 遍历指定目录下的所有文件
    for filename in os.listdir(directory):
        if filename.endswith('.md'):
            filepath = os.path.join(directory, filename)
            # 读取Markdown文件内容
            with open(filepath, 'r', encoding='utf-8') as file:
                content = file.read()

            # 去掉代码块中的空行
            modified_content = remove_blank_lines_in_code_blocks(content)

            # 将修改后的内容写回原文件
            with open(filepath, 'w', encoding='utf-8') as file:
                file.write(modified_content)

            print(f"已处理文件: {filename}")


# 处理目录下的所有Markdown文件
process_md_files_in_directory(dst_md)

chuli_wenzhang_dict_rev = []
for id in chuli_wenzhang_dict:
    chuli_wenzhang_dict_rev.append(id)
chuli_wenzhang_dict_rev = chuli_wenzhang_dict_rev[::-1]

jiezhe = "139426685"

lueguo = True
# 将chuli_wenzhang_dict上传到api
for id in chuli_wenzhang_dict_rev:
    if jiezhe == id:
        lueguo = False
    if lueguo is True:
        continue
    print("=======================================")
    print(id)
    blog_dict = all_blogs_dict[id]
    name = blog_dict['name']
    link = blog_dict['link']

    categories = blog_dict['categories']
    tags = blog_dict['tags']
    original_time_str = blog_dict['time']
    index = blog_dict['index']

    categories = 'OpenCV'
    tags = list(set(tags))

    original_time_str = re.sub(r'[\u4e00-\u9fff]', '', original_time_str)
    # 将字符串转换为 datetime 对象，并设定为中国时间（UTC+8）
    dt = datetime.strptime(original_time_str.strip(), '%Y-%m-%d %H:%M:%S')
    dt = dt.replace(tzinfo=timezone(timedelta(hours=8)))
    # 转换为 UTC 时间
    utc_dt = dt.astimezone(timezone.utc)
    # 转换为 ISO 8601 格式字符串，带毫秒和Z时区标志
    iso_time_str = utc_dt.strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'

    # md
    md_filename = f"{index:03d}.md"
    md_filepath = os.path.join(dst_md, md_filename)
    content = open(md_filepath, 'r', encoding='utf-8').read()

    a = 1

    # API 端点
    url = "http://19.31.11.10/api/admin/article"

    # 设置请求头
    headers = {
        "accept": "application/json",
        "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyIsImlhdCI6MTcyNTE1NzI1MCwiZXhwIjo0ODc4NzU3MjUwfQ.",
        "Content-Type": "application/json"
    }

    # 请求体
    data = {
        "title": name,
        # "hidden": False,
        # "private": False,
        "content": content,
        "tags": tags,
        "category": categoriesx,
        # "updatedAt": iso_time_str,
        # "createdAt": iso_time_str,
    }

    max_attempts = 3  # 最大尝试次数
    attempt = 0
    while attempt < max_attempts:
        attempt += 1
        response = requests.post(url, headers=headers, json=data)

        if response.status_code == 201:
            print("Article published successfully.")
            break  # 请求成功，跳出循环
        else:
            print(f"Attempt {attempt}: Failed to publish article. Status code: {response.status_code}")
            if attempt < max_attempts:
                print("Retrying...")
                time.sleep(1)  # 等待2秒后重试（你可以根据需要调整等待时间）
    else:
        print("Failed to publish article after 3 attempts.")

print(len(chuli_wenzhang_dict))

```