无人机AI缺陷识别（裂缝/渗漏/变形）

无人机AI缺陷识别（裂缝/渗漏/变形）

1. 概述

1.1 适用场景

本文档适用于以下AI缺陷识别场景：

• 桥梁结构裂缝自动检测
• 隧道衬砌渗漏自动识别
• 建筑外墙缺陷检测
• 边坡表面裂缝识别
• 混凝土结构缺陷检测
• 钢结构锈蚀识别
• 管道缺陷检测

1.2 工程背景

传统工程缺陷检测主要依赖人工目视检查，存在效率低、主观性强、危险性高等问题。随着深度学习技术的发展，基于计算机视觉的自动缺陷识别技术已日趋成熟，可实现裂缝、渗漏、变形等缺陷的自动检测和量化分析。

结合无人机巡检平台，AI缺陷识别系统可快速获取大范围高分辨率影像，通过深度学习模型自动识别和定位缺陷，大幅提高检测效率和客观性。

1.3 技术路线

┌─────────────────────────────────────────────────────────────┐
│                      AI缺陷识别系统                          │
├─────────────────────────────────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐    │
│  │ 数据采集  │  │ 数据预处理│  │ 模型推理  │  │ 结果输出  │    │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘    │
│       ↑                                              ↓       │
│  ┌──────────┐                                 ┌──────────┐   │
│  │ 无人机   │                                 │ 报告生成  │   │
│  │ 相机     │                                 │ 预警推送  │   │
│  └──────────┘                                 └──────────┘   │
└─────────────────────────────────────────────────────────────┘

2. 监测内容

2.1 缺陷类型

AI缺陷识别系统可检测以下缺陷类型：

缺陷类型	检测对象	检测精度	识别方法	适用场景
裂缝	混凝土/砖石结构	宽度≥0.1mm	语义分割	桥梁、隧道、建筑
渗漏	隧道衬砌/屋面	面积≥1cm²	语义分割	隧道、地下工程
变形	结构整体	位移≥5mm	三维对比	桥梁、边坡
剥落	混凝土表面	面积≥1cm²	目标检测	桥梁、建筑
锈蚀	钢结构	面积≥1cm²	语义分割	钢桥、钢结构
积水	桥面/屋面	面积≥10cm²	语义分割	桥梁、建筑
植被侵入	结构表面	面积≥10cm²	目标检测	边坡、建筑
垃圾堆积	结构表面	面积≥10cm²	目标检测	桥梁、隧道

提示

检测精度与影像分辨率直接相关。裂缝检测需要亚毫米级分辨率（GSD≤0.5mm），渗漏检测需要毫米级分辨率（GSD≤2mm），变形检测需要厘米级分辨率（GSD≤2cm）。

2.2 检测精度要求

缺陷类型	最小检测尺寸	定位精度	分类准确率	误检率
裂缝	0.1mm宽×10mm长	±2mm	≥90%	≤5%
渗漏	1cm²	±5mm	≥85%	≤10%
变形	5mm	±10mm	≥80%	≤15%
剥落	1cm²	±5mm	≥85%	≤10%
锈蚀	1cm²	±5mm	≥85%	≤10%
积水	10cm²	±10mm	≥90%	≤5%

3. 技术方案

3.1 系统架构

┌─────────────────────────────────────────────────────────────┐
│                    AI缺陷识别系统架构                        │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐   │
│  │  数据采集层  │    │  数据处理层  │    │  应用服务层  │   │
│  └──────┬──────┘    └──────┬──────┘    └──────┬──────┘   │
│         │                  │                  │           │
│  ┌──────┴──────┐    ┌──────┴──────┐    ┌──────┴──────┐   │
│  │ • 无人机     │    │ • 影像预处理│    │ • 缺陷检测  │   │
│  │ • 相机       │    │ • 影像增强  │    │ • 缺陷分类  │   │
│  │ • 激光雷达   │    │ • 影像拼接  │    │ • 缺陷量化  │   │
│  │ • 热红外     │    │ • 三维重建  │    │ • 报告生成  │   │
│  │ • 多光谱     │    │ • 数据标注  │    │ • 预警推送  │   │
│  └─────────────┘    └─────────────┘    └─────────────┘   │
│                                                              │
│  ┌─────────────────────────────────────────────────────┐   │
│  │                    AI模型层                          │   │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │   │
│  │  │裂缝检测 │ │渗漏识别 │ │变形分析 │ │综合评估 │ │   │
│  │  │ 模型    │ │ 模型    │ │ 模型    │ │ 模型    │ │   │
│  │  └─────────┘ └─────────┘ └─────────┘ └─────────┘ │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                              │
└─────────────────────────────────────────────────────────────┘

3.2 深度学习模型

3.2.1 裂缝检测模型

# 裂缝检测模型示例（PyTorch）
import torch
import torch.nn as nn
from torchvision import models

class CrackDetectionModel(nn.Module):
    """
    基于U-Net的裂缝检测模型
    """
    def __init__(self, num_classes=2):
        super(CrackDetectionModel, self).__init__()

        # 使用ResNet50作为编码器
        self.encoder = models.resnet50(pretrained=True)

        # 解码器（U-Net结构）
        self.decoder = nn.ModuleList([
            self._upblock(2048, 1024),
            self._upblock(1024, 512),
            self._upblock(512, 256),
            self._upblock(256, 128),
            self._upblock(128, 64)
        ])

        # 输出层
        self.final = nn.Conv2d(64, num_classes, kernel_size=1)

    def _upblock(self, in_channels, out_channels):
        return nn.Sequential(
            nn.ConvTranspose2d(in_channels, out_channels, kernel_size=2, stride=2),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )

    def forward(self, x):
        # 编码
        features = []
        x = self.encoder.conv1(x)
        x = self.encoder.bn1(x)
        x = self.encoder.relu(x)
        x = self.encoder.maxpool(x)

        x = self.encoder.layer1(x)
        features.append(x)
        x = self.encoder.layer2(x)
        features.append(x)
        x = self.encoder.layer3(x)
        features.append(x)
        x = self.encoder.layer4(x)
        features.append(x)

        # 解码
        for i, upblock in enumerate(self.decoder):
            x = upblock(x)
            if i < len(features):
                x = torch.cat([x, features[-(i+1)]], dim=1)

        # 输出
        x = self.final(x)
        return x

# 模型实例化
model = CrackDetectionModel(num_classes=2)
print(f"模型参数数量: {sum(p.numel() for p in model.parameters()):,}")

3.2.2 渗漏识别模型

# 渗漏识别模型示例（PyTorch）
class LeakageDetectionModel(nn.Module):
    """
    基于DeepLabV3+的渗漏识别模型
    """
    def __init__(self, num_classes=2):
        super(LeakageDetectionModel, self).__init__()

        # 使用ResNet101作为骨干网络
        self.backbone = models.resnet101(pretrained=True)

        # ASPP模块
        self.aspp = nn.ModuleList([
            nn.Conv2d(2048, 256, kernel_size=1),
            nn.Conv2d(2048, 256, kernel_size=3, padding=6, dilation=6),
            nn.Conv2d(2048, 256, kernel_size=3, padding=12, dilation=12),
            nn.Conv2d(2048, 256, kernel_size=3, padding=18, dilation=18)
        ])

        # 解码器
        self.decoder = nn.Sequential(
            nn.Conv2d(1280, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True)
        )

        # 输出层
        self.final = nn.Conv2d(256, num_classes, kernel_size=1)

    def forward(self, x):
        # 骨干网络
        x = self.backbone.conv1(x)
        x = self.backbone.bn1(x)
        x = self.backbone.relu(x)
        x = self.backbone.maxpool(x)

        x = self.backbone.layer1(x)
        x = self.backbone.layer2(x)
        x = self.backbone.layer3(x)
        x = self.backbone.layer4(x)

        # ASPP
        aspp_features = []
        for aspp in self.aspp:
            aspp_features.append(aspp(x))
        x = torch.cat(aspp_features, dim=1)

        # 解码
        x = self.decoder(x)
        x = self.final(x)

        return x

# 模型实例化
model = LeakageDetectionModel(num_classes=2)
print(f"模型参数数量: {sum(p.numel() for p in model.parameters()):,}")

3.2.3 变形分析模型

# 变形分析模型示例（Python + Open3D）
import open3d as o3d
import numpy as np

def analyze_deformation(point_cloud_t1, point_cloud_t2):
    """
    基于点云对比的变形分析

    Args:
        point_cloud_t1: 时期1的点云数据
        point_cloud_t2: 时期2的点云数据

    Returns:
        deformation_map: 变形分析结果
    """
    # 点云配准
    reg_p2p = o3d.pipelines.registration.RegistrationICP(
        point_cloud_t2, point_cloud_t1, 0.02, np.eye(4),
        o3d.pipelines.registration.TransformationEstimationPointToPoint()
    )

    # 变换点云
    point_cloud_t2_aligned = point_cloud_t2.transform(reg_p2p.transformation)

    # 计算点云距离
    distances = point_cloud_t1.compute_point_cloud_distance(point_cloud_t2_aligned)

    # 变形分析
    deformation_map = {
        "max_deformation": np.max(distances),
        "mean_deformation": np.mean(distances),
        "deformation_distribution": np.histogram(distances, bins=50)
    }

    return deformation_map

# 使用示例
# deformation = analyze_deformation(pcd_t1, pcd_t2)

4. 数据预处理

4.1 影像预处理

# 影像预处理示例（Python + OpenCV）
import cv2
import numpy as np

def preprocess_image(image_path, target_size=(1024, 1024)):
    """
    影像预处理

    Args:
        image_path: 影像路径
        target_size: 目标尺寸

    Returns:
        preprocessed_image: 预处理后的影像
    """
    # 读取影像
    image = cv2.imread(image_path)

    # 调整尺寸
    image = cv2.resize(image, target_size)

    # 归一化
    image = image.astype(np.float32) / 255.0

    # 标准化（ImageNet均值和标准差）
    mean = np.array([0.485, 0.456, 0.406])
    std = np.array([0.229, 0.224, 0.225])
    image = (image - mean) / std

    # 转置为CHW格式
    image = np.transpose(image, (2, 0, 1))

    return image

# 影像增强
def augment_image(image):
    """
    影像增强

    Args:
        image: 输入影像

    Returns:
        augmented_image: 增强后的影像
    """
    # 随机翻转
    if np.random.random() > 0.5:
        image = np.flip(image, axis=2)

    # 随机旋转
    angle = np.random.uniform(-15, 15)
    h, w = image.shape[1:]
    M = cv2.getRotationMatrix2D((w/2, h/2), angle, 1)
    image = cv2.warpAffine(image.transpose(1, 2, 0), M, (w, h))
    image = image.transpose(2, 0, 1)

    # 随机亮度调整
    brightness = np.random.uniform(0.8, 1.2)
    image = image * brightness
    image = np.clip(image, 0, 1)

    return image

4.2 数据标注

# 数据标注示例（Python + PIL）
from PIL import Image, ImageDraw
import json

def annotate_image(image_path, defects):
    """
    影像标注

    Args:
        image_path: 影像路径
        defects: 缺陷列表（包含位置和类型）

    Returns:
        annotation: 标注结果
    """
    image = Image.open(image_path)
    draw = ImageDraw.Draw(image)

    annotation = {
        "image_path": image_path,
        "image_size": image.size,
        "defects": []
    }

    for defect in defects:
        # 绘制边界框
        bbox = defect["bbox"]
        draw.rectangle(bbox, outline="red", width=2)

        # 添加标注信息
        annotation["defects"].append({
            "type": defect["type"],
            "bbox": bbox,
            "confidence": defect.get("confidence", 1.0)
        })

    return annotation

# 标注格式转换（COCO格式）
def convert_to_coco_format(annotations, categories):
    """
    转换为COCO格式

    Args:
        annotations: 标注列表
        categories: 类别列表

    Returns:
        coco_data: COCO格式数据
    """
    coco_data = {
        "images": [],
        "annotations": [],
        "categories": categories
    }

    for i, ann in enumerate(annotations):
        coco_data["images"].append({
            "id": i,
            "file_name": ann["image_path"],
            "width": ann["image_size"][0],
            "height": ann["image_size"][1]
        })

        for j, defect in enumerate(ann["defects"]):
            bbox = defect["bbox"]
            coco_data["annotations"].append({
                "id": i * 1000 + j,
                "image_id": i,
                "category_id": categories.index(defect["type"]),
                "bbox": [bbox[0], bbox[1], bbox[2]-bbox[0], bbox[3]-bbox[1]],
                "area": (bbox[2]-bbox[0]) * (bbox[3]-bbox[1]),
                "iscrowd": 0
            })

    return coco_data

5. 模型训练

5.1 训练流程

# 模型训练示例（PyTorch）
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import transforms

def train_model(model, train_loader, val_loader, num_epochs=100, lr=0.001):
    """
    训练模型

    Args:
        model: 模型
        train_loader: 训练数据加载器
        val_loader: 验证数据加载器
        num_epochs: 训练轮数
        lr: 学习率

    Returns:
        model: 训练后的模型
        history: 训练历史
    """
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = model.to(device)

    # 损失函数
    criterion = nn.CrossEntropyLoss()

    # 优化器
    optimizer = optim.Adam(model.parameters(), lr=lr)

    # 学习率调度
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)

    history = {"train_loss": [], "val_loss": [], "val_acc": []}

    for epoch in range(num_epochs):
        # 训练
        model.train()
        train_loss = 0.0

        for images, labels in train_loader:
            images = images.to(device)
            labels = labels.to(device)

            # 前向传播
            outputs = model(images)
            loss = criterion(outputs, labels)

            # 反向传播
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            train_loss += loss.item()

        # 验证
        model.eval()
        val_loss = 0.0
        val_correct = 0
        val_total = 0

        with torch.no_grad():
            for images, labels in val_loader:
                images = images.to(device)
                labels = labels.to(device)

                outputs = model(images)
                loss = criterion(outputs, labels)
                val_loss += loss.item()

                _, predicted = torch.max(outputs, 1)
                val_total += labels.size(0)
                val_correct += (predicted == labels).sum().item()

        val_acc = val_correct / val_total

        # 记录历史
        history["train_loss"].append(train_loss / len(train_loader))
        history["val_loss"].append(val_loss / len(val_loader))
        history["val_acc"].append(val_acc)

        # 更新学习率
        scheduler.step()

        # 打印进度
        if (epoch + 1) % 10 == 0:
            print(f"Epoch [{epoch+1}/{num_epochs}], "
                  f"Train Loss: {history['train_loss'][-1]:.4f}, "
                  f"Val Loss: {history['val_loss'][-1]:.4f}, "
                  f"Val Acc: {val_acc:.4f}")

    return model, history

# 使用示例
# model, history = train_model(model, train_loader, val_loader, num_epochs=100)

5.2 模型评估

# 模型评估示例
def evaluate_model(model, test_loader):
    """
    评估模型

    Args:
        model: 模型
        test_loader: 测试数据加载器

    Returns:
        metrics: 评估指标
    """
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = model.to(device)
    model.eval()

    all_preds = []
    all_labels = []

    with torch.no_grad():
        for images, labels in test_loader:
            images = images.to(device)
            labels = labels.to(device)

            outputs = model(images)
            _, predicted = torch.max(outputs, 1)

            all_preds.extend(predicted.cpu().numpy())
            all_labels.extend(labels.cpu().numpy())

    # 计算指标
    from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix

    metrics = {
        "accuracy": accuracy_score(all_labels, all_preds),
        "precision": precision_score(all_labels, all_preds, average="weighted"),
        "recall": recall_score(all_labels, all_preds, average="weighted"),
        "f1": f1_score(all_labels, all_preds, average="weighted"),
        "confusion_matrix": confusion_matrix(all_labels, all_preds)
    }

    return metrics

# 使用示例
# metrics = evaluate_model(model, test_loader)
# print(f"准确率: {metrics['accuracy']:.4f}")
# print(f"精确率: {metrics['precision']:.4f}")
# print(f"召回率: {metrics['recall']:.4f}")
# print(f"F1分数: {metrics['f1']:.4f}")

6. 缺陷量化

6.1 裂缝量化

# 裂缝量化示例（Python + OpenCV）
import cv2
import numpy as np

def quantify_crack(image, crack_mask):
    """
    裂缝量化分析

    Args:
        image: 原始影像
        crack_mask: 裂缝分割掩膜

    Returns:
        crack_info: 裂缝量化信息
    """
    # 提取裂缝骨架
    skeleton = cv2.ximgproc.thinning(crack_mask.astype(np.uint8))

    # 计算裂缝长度
    crack_length = np.sum(skeleton > 0) * pixel_size  # 像素尺寸转换为实际长度

    # 计算裂缝宽度
    distances = cv2.distanceTransform(crack_mask.astype(np.uint8), cv2.DIST_L2, 5)
    crack_width = np.max(distances) * 2 * pixel_size  # 最大宽度
    avg_width = np.mean(distances[crack_mask > 0]) * 2 * pixel_size  # 平均宽度

    # 计算裂缝面积
    crack_area = np.sum(crack_mask > 0) * pixel_size ** 2

    # 裂缝连通性分析
    num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(
        crack_mask.astype(np.uint8), connectivity=8
    )

    crack_info = {
        "length": crack_length,
        "max_width": crack_width,
        "avg_width": avg_width,
        "area": crack_area,
        "num_segments": num_labels - 1,
        "segment_stats": stats[1:].tolist()
    }

    return crack_info

# 使用示例
# crack_info = quantify_crack(image, crack_mask)
# print(f"裂缝长度: {crack_info['length']:.2f}mm")
# print(f"最大宽度: {crack_info['max_width']:.2f}mm")
# print(f"平均宽度: {crack_info['avg_width']:.2f}mm")

6.2 渗漏量化

# 渗漏量化示例
def quantify_leakage(image, leakage_mask):
    """
    渗漏量化分析

    Args:
        image: 原始影像
        leakage_mask: 渗漏分割掩膜

    Returns:
        leakage_info: 渗漏量化信息
    """
    # 计算渗漏面积
    leakage_area = np.sum(leakage_mask > 0) * pixel_size ** 2

    # 渗漏严重程度评估
    if leakage_area < 10:  # cm²
        severity = "轻微"
    elif leakage_area < 50:
        severity = "中等"
    else:
        severity = "严重"

    # 渗漏位置分析
    num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(
        leakage_mask.astype(np.uint8), connectivity=8
    )

    leakage_info = {
        "area": leakage_area,
        "severity": severity,
        "num_regions": num_labels - 1,
        "region_stats": stats[1:].tolist()
    }

    return leakage_info

7. 报告生成

7.1 检测报告模板

# 检测报告生成示例
def generate_report(image_path, detections, output_path):
    """
    生成检测报告

    Args:
        image_path: 原始影像路径
        detections: 检测结果列表
        output_path: 报告输出路径
    """
    import matplotlib.pyplot as plt
    from matplotlib.patches import Rectangle

    # 读取影像
    image = cv2.imread(image_path)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

    # 创建报告
    fig, axes = plt.subplots(1, 2, figsize=(16, 8))

    # 原始影像
    axes[0].imshow(image)
    axes[0].set_title("原始影像")
    axes[0].axis("off")

    # 检测结果
    axes[1].imshow(image)
    for det in detections:
        bbox = det["bbox"]
        rect = Rectangle((bbox[0], bbox[1]), bbox[2]-bbox[0], bbox[3]-bbox[1],
                         linewidth=2, edgecolor="red", facecolor="none")
        axes[1].add_patch(rect)
        axes[1].text(bbox[0], bbox[1]-5, f"{det['type']}: {det['confidence']:.2f}",
                    color="red", fontsize=10, weight="bold")
    axes[1].set_title("缺陷检测结果")
    axes[1].axis("off")

    # 保存报告
    plt.tight_layout()
    plt.savefig(output_path, dpi=300, bbox_inches="tight")
    plt.close()

    print(f"报告已保存至: {output_path}")

8. 系统集成

8.1 RAILWISE-CLI集成

# RAILWISE-CLI 缺陷识别命令示例

# 1. 影像上传
railwise-cli upload --project "bridge_inspection" --images ./photos/

# 2. 缺陷检测
railwise-cli detect --project "bridge_inspection" --model "crack_detection_v2" --output ./results/

# 3. 结果查看
railwise-cli report --project "bridge_inspection" --format pdf --output ./report.pdf

# 4. 批量处理
railwise-cli batch-detect --project "bridge_inspection" --model "all" --output ./results/

8.2 API接口

# API接口示例（FastAPI）
from fastapi import FastAPI, File, UploadFile
from fastapi.responses import JSONResponse
import uvicorn

app = FastAPI(title="AI缺陷识别API")

# 加载模型
model = CrackDetectionModel(num_classes=2)
model.load_state_dict(torch.load("crack_model.pth"))
model.eval()

@app.post("/detect/crack")
async def detect_crack(file: UploadFile = File(...)):
    """
    裂缝检测API

    Args:
        file: 上传的影像文件

    Returns:
        JSONResponse: 检测结果
    """
    # 读取影像
    image = Image.open(file.file)

    # 预处理
    preprocessed = preprocess_image(image)

    # 推理
    with torch.no_grad():
        output = model(preprocessed.unsqueeze(0))

    # 后处理
    mask = torch.argmax(output, dim=1).squeeze().numpy()

    # 量化
    crack_info = quantify_crack(image, mask)

    return JSONResponse({
        "status": "success",
        "crack_info": crack_info,
        "mask": mask.tolist()
    })

@app.post("/detect/leakage")
async def detect_leakage(file: UploadFile = File(...)):
    """渗漏检测API"""
    pass

@app.post("/detect/all")
async def detect_all(file: UploadFile = File(...)):
    """综合缺陷检测API"""
    pass

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

9. 相关案例

• 案例：绕城高速管廊盾构侧穿3号线桥墩监测（2024-2025）
• 案例：某基坑邻近地铁保护区监测（2023）

10. 附录

附录A：检查清单

模型部署前检查

• 模型训练完成，验证准确率满足要求
• 模型量化优化（如需要）
• 推理速度测试通过
• API接口测试通过
• 数据安全审查完成

运行中检查

• 影像数据质量检查
• 模型推理结果检查
• 缺陷量化结果检查
• 报告生成检查
• 预警推送检查

附录B：常见问题

Q1：AI缺陷识别的准确率如何？

A：AI缺陷识别准确率与以下因素相关：

1. 训练数据质量和数量
2. 影像分辨率和质量
3. 缺陷类型和特征
4. 模型架构和训练策略

一般准确率：

• 裂缝检测：≥90%
• 渗漏识别：≥85%
• 剥落检测：≥85%
• 变形分析：≥80%

Q2：如何提高识别准确率？

A：提高识别准确率的方法：

1. 增加训练数据量
2. 提高数据标注质量
3. 使用数据增强技术
4. 优化模型架构
5. 使用集成学习
6. 结合传统图像处理方法

Q3：AI识别结果如何与人工检查结合？

A：AI与人工结合的工作流程：

1. AI自动识别，筛选疑似缺陷
2. 人工复核AI识别结果
3. 对AI漏检进行补充
4. 对AI误检进行修正
5. 反馈修正结果，优化AI模型

附录C：参考资料

1. GB 50344-2019 《建筑结构检测技术标准》
2. GB 50911-2013 《城市轨道交通工程监测技术标准》
3. JGJ 8-2016 《建筑变形测量规范》
4. GB 50026-2020 《工程测量标准》
5. 《深度学习与计算机视觉》（人民邮电出版社）
6. 《PyTorch深度学习实战》（人民邮电出版社）

---

本文档由RailWise技术团队编写，最后更新于2025-01-20。如有疑问，请联系技术支持。