28：【AI工具】Copilot/Claude/Cursor生成代码 GPU跑不动（环境不匹配）

# 环境不匹配错误示例
RuntimeError: CUDA error: no kernel image is available for execution on the device
# 或
ModuleNotFoundError: No module named 'torch'
# 或
ImportError: Could not load dynamic library 'cudart64_110.dll'; dlerror: cudart64_110.dll not found

# 性能问题示例
# 代码运行非常慢，CPU使用率高，GPU使用率低
# 或
# 内存不足错误
RuntimeError: CUDA out of memory. Tried to allocate 20.00 MiB (GPU 0; 8.00 GiB total capacity; 6.50 GiB already allocated; 0 bytes free; 7.00 GiB reserved in total by PyTorch)

# 环境检测代码
import subprocess
import sys

def check_environment():
    """检查当前环境"""
    print("=== 检查当前环境 ===")
    
    # 检查Python版本
    print(f"Python版本: {sys.version}")
    
    # 检查CUDA可用性
    try:
        import torch
        print(f"PyTorch版本: {torch.__version__}")
        print(f"CUDA可用: {torch.cuda.is_available()}")
        if torch.cuda.is_available():
            print(f"GPU名称: {torch.cuda.get_device_name(0)}")
            print(f"GPU内存: {torch.cuda.get_device_properties(0).total_memory / 1e9:.2f} GB")
    except ImportError:
        print("PyTorch未安装")
    
    # 检查其他常见依赖
    common_deps = ["transformers", "diffusers", "tensorflow", "numpy", "pandas", "matplotlib"]
    print("\n常见依赖检查:")
    for dep in common_deps:
        try:
            __import__(dep)
            version = __import__(dep).__version__
            print(f"{dep}: {version}")
        except ImportError:
            print(f"{dep}: 未安装")

if __name__ == "__main__":
    check_environment()

# AI工具代码适配示例
import torch

def adapt_ai_generated_code():
    """适配AI工具生成的代码"""
    # 检测CUDA可用性
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f"使用设备: {device}")
    
    # 适配模型加载
    def load_model(model_path):
        """加载模型，适配本地环境"""
        try:
            # 尝试使用GPU
            model = torch.load(model_path, map_location=device)
            model.to(device)
            return model
        except Exception as e:
            print(f"加载模型失败: {e}")
            return None
    
    # 适配数据处理
    def process_data(data):
        """处理数据，适配本地环境"""
        try:
            # 移至适当设备
            if isinstance(data, torch.Tensor):
                return data.to(device)
            elif isinstance(data, list):
                return [process_data(item) for item in data]
            elif isinstance(data, dict):
                return {k: process_data(v) for k, v in data.items()}
            else:
                return data
        except Exception as e:
            print(f"处理数据失败: {e}")
            return data
    
    return load_model, process_data

if __name__ == "__main__":
    load_model, process_data = adapt_ai_generated_code()
    # 示例使用
    # model = load_model("model.pth")
    # data = process_data(torch.randn(1, 3, 224, 224))

# 内存优化示例
def optimize_memory_usage():
    """优化内存使用"""
    # 设置梯度累积
    accumulation_steps = 4
    
    # 使用混合精度训练
    from torch.cuda.amp import autocast, GradScaler
    scaler = GradScaler()
    
    # 示例训练循环
    def train_loop(model, dataloader, optimizer):
        model.train()
        for i, (inputs, labels) in enumerate(dataloader):
            inputs = inputs.to(device)
            labels = labels.to(device)
            
            # 混合精度
            with autocast():
                outputs = model(inputs)
                loss = loss_fn(outputs, labels)
            
            # 梯度缩放
            scaler.scale(loss).backward()
            
            # 梯度累积
            if (i + 1) % accumulation_steps == 0:
                scaler.step(optimizer)
                scaler.update()
                optimizer.zero_grad()
    
    return train_loop

# 性能优化示例
def optimize_performance():
    """优化性能"""
    # 启用CUDA图
    def enable_cuda_graphs(model, inputs):
        """启用CUDA图"""
        # 预热
        for _ in range(3):
            model(inputs)
        
        # 捕获CUDA图
        g = torch.cuda.CUDAGraph()
        with torch.cuda.graph(g):
            model(inputs)
        
        return g
    
    # 使用通道最后格式
    def use_channels_last(model, inputs):
        """使用通道最后格式"""
        model = model.to(memory_format=torch.channels_last)
        inputs = inputs.to(memory_format=torch.channels_last)
        return model, inputs
    
    # 启用TF32
    torch.backends.cuda.matmul.allow_tf32 = True
    torch.backends.cudnn.allow_tf32 = True
    
    return enable_cuda_graphs, use_channels_last

#!/usr/bin/env python3
"""
AI工具代码环境检测工具
"""
import ast
import os
import sys
import subprocess

def analyze_code_dependencies(code):
    """分析代码依赖"""
    dependencies = set()
    
    # 解析代码
    tree = ast.parse(code)
    
    # 查找import语句
    for node in ast.walk(tree):
        if isinstance(node, ast.Import):
            for alias in node.names:
                dependencies.add(alias.name.split('.')[0])
        elif isinstance(node, ast.ImportFrom):
            if node.module:
                dependencies.add(node.module.split('.')[0])
    
    return dependencies

def check_local_dependencies(dependencies):
    """检查本地依赖"""
    installed = {}
    missing = []
    
    for dep in dependencies:
        try:
            __import__(dep)
            version = __import__(dep).__version__
            installed[dep] = version
        except ImportError:
            missing.append(dep)
    
    return installed, missing

def check_gpu_environment():
    """检查GPU环境"""
    gpu_info = {}
    
    # 检查CUDA可用性
    try:
        import torch
        gpu_info["cuda_available"] = torch.cuda.is_available()
        if torch.cuda.is_available():
            gpu_info["gpu_name"] = torch.cuda.get_device_name(0)
            gpu_info["gpu_memory"] = torch.cuda.get_device_properties(0).total_memory / 1e9
            gpu_info["cuda_version"] = torch.version.cuda
    except ImportError:
        gpu_info["cuda_available"] = False
    
    return gpu_info

def generate_environment_report(installed, missing, gpu_info):
    """生成环境报告"""
    print("=== AI工具代码环境检测报告 ===")
    
    # 依赖检查结果
    print("\n1. 依赖检查结果:")
    print("已安装的依赖:")
    for dep, version in installed.items():
        print(f"  - {dep}: {version}")
    
    if missing:
        print("\n缺失的依赖:")
        for dep in missing:
            print(f"  - {dep}")
    else:
        print("\n所有依赖均已安装")
    
    # GPU环境检查结果
    print("\n2. GPU环境检查结果:")
    if gpu_info["cuda_available"]:
        print(f"CUDA可用: 是")
        print(f"GPU名称: {gpu_info['gpu_name']}")
        print(f"GPU内存: {gpu_info['gpu_memory']:.2f} GB")
        print(f"CUDA版本: {gpu_info['cuda_version']}")
    else:
        print("CUDA可用: 否")
        print("将使用CPU运行")
    
    # 生成安装建议
    if missing:
        print("\n3. 安装建议:")
        install_cmd = "pip install " + " ".join(missing)
        print(f"  {install_cmd}")
        print("\n或使用uv安装（推荐）:")
        uv_cmd = "uv pip install " + " ".join(missing)
        print(f"  {uv_cmd}")
    
    # 生成GPU优化建议
    if gpu_info["cuda_available"]:
        print("\n4. GPU优化建议:")
        print("  - 启用混合精度训练")
        print("  - 使用梯度累积减少内存使用")
        print("  - 启用CUDA图加速推理")
        print("  - 使用通道最后格式")

if __name__ == "__main__":
    # 读取代码文件
    if len(sys.argv) != 2:
        print("用法: python ai_code_env_checker.py <code_file.py>")
        sys.exit(1)
    
    code_file = sys.argv[1]
    if not os.path.exists(code_file):
        print(f"文件不存在: {code_file}")
        sys.exit(1)
    
    # 读取代码
    with open(code_file, 'r', encoding='utf-8') as f:
        code = f.read()
    
    # 分析依赖
    dependencies = analyze_code_dependencies(code)
    
    # 检查本地依赖
    installed, missing = check_local_dependencies(dependencies)
    
    # 检查GPU环境
    gpu_info = check_gpu_environment()
    
    # 生成报告
    generate_environment_report(installed, missing, gpu_info)

#!/bin/bash

# 检查当前环境
echo "=== 检查当前环境 ==="
python -c "
import sys
print('Python版本:', sys.version)
try:
    import torch
    print('PyTorch版本:', torch.__version__)
    print('CUDA可用:', torch.cuda.is_available())
    if torch.cuda.is_available():
        print('GPU名称:', torch.cuda.get_device_name(0))
except ImportError:
    print('PyTorch未安装')
"

# 安装uv（如果未安装）
echo "\n=== 安装uv ==="
pip install uv

# 创建虚拟环境
echo "\n=== 创建虚拟环境 ==="
uv venv
uv activate

# 安装常见依赖
echo "\n=== 安装常见依赖 ==="
uv pip install torch torchvision transformers diffusers numpy pandas matplotlib

# 验证安装结果
echo "\n=== 验证安装结果 ==="
python -c "
import torch
import transformers
import diffusers
import numpy
import pandas
import matplotlib
print('PyTorch版本:', torch.__version__)
print('transformers版本:', transformers.__version__)
print('diffusers版本:', diffusers.__version__)
print('numpy版本:', numpy.__version__)
print('pandas版本:', pandas.__version__)
print('matplotlib版本:', matplotlib.__version__)
print('CUDA可用:', torch.cuda.is_available())
"

echo "\n=== 环境配置完成 ==="