突破模态壁垒：CLIP模型驱动的跨域图像转换全指南

突破模态壁垒：CLIP模型驱动的跨域图像转换全指南

【免费下载链接】CLIP CLIP (Contrastive Language-Image Pretraining), Predict the most relevant text snippet given an image 项目地址: https://gitcode.com/GitHub_Trending/cl/CLIP

引言：当图像不再沉默，文本不再抽象

你是否曾遇到这样的困境：设计师需要将"未来主义城市夜景"的文本描述转化为视觉图像，却因创意差异反复修改？摄影师想将"清晨薄雾中的山间小屋"的意境凝固在照片中，却受限于现实场景难以实现？传统图像生成技术要么依赖大量标注数据，要么需要专业的设计技能，而CLIP（Contrastive Language-Image Pretraining，对比语言-图像预训练） 模型的出现，彻底改变了这一现状。

本文将系统揭示CLIP模型如何打破视觉与语言的模态壁垒，实现从文本到图像、风格到内容的跨域转换。通过阅读本文，你将获得：

• 理解CLIP模型的双编码器架构及其跨模态对齐机制
• 掌握3种基于CLIP的图像转换核心技术（风格迁移/内容重构/域适应）
• 获取5个实战案例的完整代码实现（含艺术风格迁移、文本引导修复等）
• 规避模型部署中的8个常见陷阱（含性能优化与显存管理方案）

一、CLIP模型架构：跨模态理解的基石

1.1 模型总览：双编码器设计

CLIP模型创新性地采用了双编码器架构，通过对比学习实现视觉与语言模态的深度对齐。其核心由图像编码器和文本编码器组成，两者通过共享嵌入空间（Embedding Space）建立语义关联。

1.2 图像编码器：从像素到语义向量

CLIP提供两种图像编码器选择：Vision Transformer (ViT) 和改良版ResNet。以ViT-B/32为例，其工作流程如下：

1. 图像分块：将224×224图像分割为16×16个32×32像素的图像块（Patch）
2. 线性投影：每个图像块通过卷积层转换为768维特征向量
3. 位置编码：添加可学习的位置嵌入（Positional Embedding）
4. Transformer编码：通过12层Transformer提取全局特征
5. 特征投影：经LayerNorm和线性层投影至512维嵌入空间

# 图像编码核心代码（源自model.py）
def forward(self, x: torch.Tensor):
    x = self.conv1(x)  # shape = [*, width, grid, grid]
    x = x.reshape(x.shape[0], x.shape[1], -1)  # shape = [*, width, grid ** 2]
    x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]
    x = torch.cat([self.class_embedding.to(x.dtype) + torch.zeros(
        x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x], dim=1)  # [*, grid**2+1, width]
    x = x + self.positional_embedding.to(x.dtype)
    x = self.ln_pre(x)
    
    x = x.permute(1, 0, 2)  # NLD -> LND
    x = self.transformer(x)
    x = x.permute(1, 0, 2)  # LND -> NLD
    
    x = self.ln_post(x[:, 0, :])  # 提取[CLS] token特征
    
    if self.proj is not None:
        x = x @ self.proj  # 投影至嵌入空间
    
    return x

1.3 文本编码器：从字符到语义向量

文本编码器采用Transformer架构，处理流程包括：

1. 分词：使用BPE（Byte-Pair Encoding）分词器将文本转换为token序列
2. 词嵌入：通过嵌入层将token转换为512维向量
3. 位置编码：添加固定长度（77）的位置嵌入
4. Transformer编码：通过12层Transformer提取上下文特征
5. 特征投影：经LayerNorm和线性层投影至512维嵌入空间

# 文本编码核心代码（源自model.py）
def encode_text(self, text):
    x = self.token_embedding(text).type(self.dtype)  # [batch_size, n_ctx, d_model]
    
    x = x + self.positional_embedding.type(self.dtype)
    x = x.permute(1, 0, 2)  # NLD -> LND
    x = self.transformer(x)
    x = x.permute(1, 0, 2)  # LND -> NLD
    x = self.ln_final(x).type(self.dtype)
    
    # 提取EOT token特征（序列中最高编号的token）
    x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection
    
    return x

1.4 对比学习：构建跨模态关联

CLIP通过对比损失函数（Contrastive Loss）训练，使相似的图像-文本对在嵌入空间中距离更近。训练时，模型对N个图像和N个文本的所有可能配对（共N²对）进行评分，其中N对为真实匹配，N²-N对为负样本。

二、核心技术：基于CLIP的跨域图像转换方法

2.1 技术原理：嵌入空间的模态转换

CLIP实现跨域图像转换的核心原理是：不同模态的语义相似性可以通过嵌入空间中的距离度量。对于图像转换任务，我们可以：

1. 定义目标：将源图像特征引导至目标域特征分布
2. 构建桥梁：利用CLIP嵌入空间作为中介表示
3. 优化映射：通过损失函数最小化源特征与目标特征的距离

常见的转换范式包括：

• 文本引导转换：文本描述 → CLIP文本特征 → 图像特征优化
• 风格迁移：风格图像特征 → 内容图像特征 → 融合特征重构
• 域适应：源域图像 → 目标域特征分布 → 目标域图像生成

2.2 文本引导的图像转换

文本引导转换通过优化图像像素，使其CLIP特征与目标文本特征尽可能接近。核心公式为：

$$\mathcal{L} = |\text{CLIP}{\text{image}}(I) - \text{CLIP}{\text{text}}(T)|_2^2 + \lambda \cdot \text{TV}(I)$$

其中$I$是生成图像，$T$是目标文本，$\text{TV}(I)$是总变差损失（用于保持图像平滑性），$\lambda$是平衡参数。

def text_guided_image_translation(image, text, model, preprocess, lr=0.01, iterations=100):
    # 预处理图像并转为可优化变量
    input_image = preprocess(image).unsqueeze(0).cuda()
    input_image.requires_grad = True
    
    # 编码目标文本
    text_tokens = clip.tokenize([text]).cuda()
    with torch.no_grad():
        target_text_feature = model.encode_text(text_tokens)
        target_text_feature = target_text_feature / target_text_feature.norm(dim=-1, keepdim=True)
    
    # 优化器
    optimizer = torch.optim.Adam([input_image], lr=lr)
    
    for i in range(iterations):
        # 编码图像
        image_feature = model.encode_image(input_image)
        image_feature = image_feature / image_feature.norm(dim=-1, keepdim=True)
        
        # 计算损失
        similarity_loss = ((image_feature - target_text_feature) ** 2).mean()
        tv_loss = total_variation_loss(input_image)
        loss = similarity_loss + 1e-4 * tv_loss
        
        # 反向传播与优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        # 投影至有效像素范围
        with torch.no_grad():
            input_image.data.clamp_(0, 1)
            
        if i % 20 == 0:
            print(f"Iteration {i}, Loss: {loss.item()}")
    
    return input_image.detach().cpu().squeeze(0).permute(1, 2, 0).numpy()

2.3 基于CLIP的风格迁移

传统风格迁移方法需要在内容图像和风格图像上分别预训练特征提取器，而CLIP可以直接提供跨模态的风格理解能力：

1. 内容损失：保持原始图像的内容特征（使用CLIP较深层特征）
2. 风格损失：匹配目标风格的纹理特征（使用CLIP较浅层特征）
3. 文本约束：可选的文本提示引导风格方向（如"梵高风格"）

def clip_style_transfer(content_image, style_image, 
                       content_prompt=None, style_prompt=None,
                       model=None, preprocess=None,
                       content_weight=1, style_weight=100, text_weight=0.1,
                       iterations=200):
    # 预处理图像
    content_tensor = preprocess(content_image).unsqueeze(0).cuda()
    style_tensor = preprocess(style_image).unsqueeze(0).cuda()
    generated = content_tensor.clone().requires_grad_(True)
    
    # 编码参考图像
    with torch.no_grad():
        content_features = model.encode_image(content_tensor)
        style_features = model.encode_image(style_tensor)
        
        # 编码文本提示（如提供）
        content_text_feature = None
        if content_prompt:
            content_tokens = clip.tokenize([content_prompt]).cuda()
            content_text_feature = model.encode_text(content_tokens)
            content_text_feature /= content_text_feature.norm(dim=-1, keepdim=True)
            
        style_text_feature = None
        if style_prompt:
            style_tokens = clip.tokenize([style_prompt]).cuda()
            style_text_feature = model.encode_text(style_tokens)
            style_text_feature /= style_text_feature.norm(dim=-1, keepdim=True)
    
    # 优化器
    optimizer = torch.optim.LBFGS([generated], lr=1)
    
    # 迭代优化
    for i in range(iterations):
        def closure():
            optimizer.zero_grad()
            generated_features = model.encode_image(generated)
            
            # 内容损失
            content_loss = F.mse_loss(generated_features, content_features) * content_weight
            
            # 风格损失
            style_loss = F.mse_loss(generated_features, style_features) * style_weight
            
            # 文本损失（如提供）
            text_loss = 0
            if content_text_feature is not None:
                text_loss += F.mse_loss(generated_features / generated_features.norm(), 
                                      content_text_feature) * text_weight
            if style_text_feature is not None:
                text_loss += F.mse_loss(generated_features / generated_features.norm(), 
                                      style_text_feature) * text_weight
            
            # 总损失
            loss = content_loss + style_loss + text_loss
            loss.backward()
            return loss
        
        optimizer.step(closure)
        
        # 投影至有效范围
        with torch.no_grad():
            generated.data.clamp_(0, 1)
            
        if i % 50 == 0:
            print(f"Iteration {i}")
    
    return generated.detach().cpu().squeeze(0).permute(1, 2, 0).numpy()

2.4 零样本域适应：跨数据集迁移

CLIP的零样本识别能力使其非常适合域适应任务，即无需目标域标注数据，仅通过文本描述即可将模型适应新领域。实现方法包括：

1. 特征对齐：将源域图像特征向目标域文本特征对齐
2. 分布匹配：最小化源域与目标域特征分布的Wasserstein距离
3. 自训练：利用CLIP对目标域图像进行伪标注，训练分类器

def clip_domain_adaptation(source_images, target_texts, model, preprocess, 
                          num_epochs=10, batch_size=8):
    # 准备数据
    source_loader = DataLoader(source_images, batch_size=batch_size, shuffle=True)
    
    # 编码目标文本
    with torch.no_grad():
        target_tokens = clip.tokenize(target_texts).cuda()
        target_features = model.encode_text(target_tokens)
        target_features /= target_features.norm(dim=-1, keepdim=True)
    
    # 定义适应网络（轻量级映射器）
    adapter = nn.Sequential(
        nn.Linear(512, 512),
        nn.ReLU(),
        nn.Linear(512, 512)
    ).cuda()
    
    optimizer = torch.optim.Adam(adapter.parameters(), lr=1e-4)
    criterion = nn.CrossEntropyLoss()
    
    # 训练适应网络
    for epoch in range(num_epochs):
        total_loss = 0
        
        for batch in source_loader:
            # 预处理并编码源图像
            images = torch.stack([preprocess(img) for img in batch]).cuda()
            with torch.no_grad():
                source_features = model.encode_image(images)
            
            # 通过适应网络
            adapted_features = adapter(source_features)
            adapted_features /= adapted_features.norm(dim=-1, keepdim=True)
            
            # 计算与目标文本的相似度
            logits = (adapted_features @ target_features.T) * model.logit_scale.exp()
            
            # 构建伪标签（最近邻文本）
            pseudo_labels = logits.argmax(dim=1)
            
            # 训练适应网络
            loss = criterion(logits, pseudo_labels)
            
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
        
        avg_loss = total_loss / len(source_loader)
        print(f"Epoch {epoch}, Average Loss: {avg_loss:.4f}")
    
    return adapter

三、实战案例：从理论到应用

3.1 案例一：文本引导的图像修复

任务描述：修复图像中的缺失区域，用户通过文本描述缺失内容。

技术路线：

1. 掩码图像输入（缺失区域为黑色）
2. 文本描述引导修复内容（如"一只坐在树枝上的红色小鸟"）
3. 联合优化CLIP特征损失和图像重构损失

def text_guided_inpainting(masked_image, mask, text_prompt, 
                          model, preprocess, generator=None,
                          iterations=150, lr=0.01):
    # 准备输入
    image_tensor = preprocess(masked_image).unsqueeze(0).cuda()
    mask_tensor = (preprocess(mask.convert('L')) > 0).float().cuda()
    
    # 初始生成图像（掩码区域用随机噪声填充）
    generated = image_tensor.clone()
    noise = torch.randn_like(generated)
    generated = (1 - mask_tensor) * generated + mask_tensor * noise
    generated.requires_grad = True
    
    # 编码目标文本
    with torch.no_grad():
        text_tokens = clip.tokenize([text_prompt]).cuda()
        target_feature = model.encode_text(text_tokens)
        target_feature /= target_feature.norm(dim=-1, keepdim=True)
    
    optimizer = torch.optim.Adam([generated], lr=lr)
    
    for i in range(iterations):
        # 编码生成图像
        gen_feature = model.encode_image(generated)
        gen_feature /= gen_feature.norm(dim=-1, keepdim=True)
        
        # 计算损失
        clip_loss = ((gen_feature - target_feature) ** 2).mean()
        tv_loss = total_variation_loss(generated * mask_tensor)
        l1_loss = F.l1_loss(generated * mask_tensor, image_tensor * mask_tensor)
        
        # 总损失
        loss = clip_loss + 1e-4 * tv_loss + 0.1 * l1_loss
        
        # 优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        # 保持非掩码区域不变
        with torch.no_grad():
            generated.data = (1 - mask_tensor) * image_tensor.data + mask_tensor * generated.data
            generated.data.clamp_(0, 1)
        
        if i % 30 == 0:
            print(f"Iteration {i}, Loss: {loss.item()}")
    
    # 转换为图像格式
    result = generated.detach().cpu().squeeze(0).permute(1, 2, 0).numpy()
    result = (result * 255).astype(np.uint8)
    
    return Image.fromarray(result)

3.2 案例二：跨域图像检索与生成

任务描述：根据文本查询从图像库中检索相似图像，并生成新的混合图像。

技术路线：

1. 预处理图像库并提取CLIP特征
2. 编码文本查询并与图像特征比对
3. 检索Top-K相似图像
4. 融合相似图像特征生成新图像

def clip_image_retrieval_and_blending(text_query, image_database, model, preprocess,
                                     top_k=3, blend_weight=0.5, iterations=100):
    # 编码文本查询
    with torch.no_grad():
        text_tokens = clip.tokenize([text_query]).cuda()
        text_feature = model.encode_text(text_tokens)
        text_feature /= text_feature.norm(dim=-1, keepdim=True)
        
        # 编码图像库
        db_features = []
        for img in image_database:
            tensor = preprocess(img).unsqueeze(0).cuda()
            feat = model.encode_image(tensor)
            db_features.append(feat / feat.norm(dim=-1, keepdim=True))
        
        db_features = torch.cat(db_features)
    
    # 检索相似图像
    similarities = (db_features @ text_feature.T).squeeze()
    top_indices = similarities.topk(top_k).indices
    
    # 获取Top-K图像
    top_images = [image_database[i] for i in top_indices]
    top_tensors = [preprocess(img).unsqueeze(0).cuda() for img in top_images]
    
    # 混合图像
    blended = torch.zeros_like(top_tensors[0]).requires_grad_(True)
    optimizer = torch.optim.Adam([blended], lr=0.01)
    
    # 目标特征（文本特征与Top-K图像特征的混合）
    with torch.no_grad():
        top_features = torch.cat([db_features[i:i+1] for i in top_indices])
        target_feature = text_feature * blend_weight + top_features.mean(dim=0) * (1 - blend_weight)
        target_feature /= target_feature.norm(dim=-1, keepdim=True)
    
    # 优化混合图像
    for i in range(iterations):
        gen_feature = model.encode_image(blended)
        gen_feature /= gen_feature.norm(dim=-1, keepdim=True)
        
        loss = ((gen_feature - target_feature) ** 2).mean()
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        with torch.no_grad():
            blended.data.clamp_(0, 1)
        
        if i % 20 == 0:
            print(f"Iteration {i}, Loss: {loss.item()}")
    
    # 转换结果
    result = blended.detach().cpu().squeeze(0).permute(1, 2, 0).numpy()
    result = (result * 255).astype(np.uint8)
    
    return Image.fromarray(result), top_images

3.3 案例三：CLIP驱动的图像超分辨率

传统超分辨率方法仅关注像素级重构，而CLIP可以引入语义级约束，使放大后的图像不仅清晰，还更符合视觉语义。

def clip_super_resolution(lr_image, upscale_factor=4, text_prompt=None,
                         model=None, preprocess=None, iterations=100):
    # 低分辨率图像
    lr_tensor = preprocess(lr_image).unsqueeze(0).cuda()
    
    # 初始化高分辨率图像（随机噪声或双三次上采样）
    hr_size = (lr_image.size[1] * upscale_factor, lr_image.size[0] * upscale_factor)
    hr_init = torch.randn(1, 3, hr_size[0], hr_size[1]).cuda().requires_grad_(True)
    
    # 上采样器（固定）
    upsample = nn.Upsample(scale_factor=upscale_factor, mode='bicubic').cuda()
    
    # 目标特征（低分辨率图像特征或文本特征）
    with torch.no_grad():
        lr_feature = model.encode_image(lr_tensor)
        
        target_feature = lr_feature
        if text_prompt:
            # 文本提示增强
            text_tokens = clip.tokenize([text_prompt]).cuda()
            text_feature = model.encode_text(text_tokens)
            target_feature = (lr_feature + text_feature) / 2
            target_feature /= target_feature.norm(dim=-1, keepdim=True)
    
    optimizer = torch.optim.Adam([hr_init], lr=1e-3)
    
    for i in range(iterations):
        # 上采样至目标分辨率
        hr_upsampled = upsample(hr_init)
        
        # 预处理以匹配CLIP输入尺寸
        hr_preprocessed = F.interpolate(hr_upsampled, size=(224, 224), mode='bicubic')
        
        # 编码高分辨率图像
        hr_feature = model.encode_image(hr_preprocessed)
        hr_feature /= hr_feature.norm(dim=-1, keepdim=True)
        
        # 计算损失
        clip_loss = ((hr_feature - target_feature) ** 2).mean()
        tv_loss = total_variation_loss(hr_init)
        loss = clip_loss + 1e-5 * tv_loss
        
        # 优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        with torch.no_grad():
            hr_init.data.clamp_(0, 1)
        
        if i % 20 == 0:
            print(f"Iteration {i}, Loss: {loss.item()}")
    
    # 获取最终高分辨率图像
    with torch.no_grad():
        hr_result = upsample(hr_init).squeeze(0).permute(1, 2, 0).cpu().numpy()
    
    hr_result = (hr_result * 255).astype(np.uint8)
    return Image.fromarray(hr_result)

四、部署与优化：从实验到产品

4.1 模型选择与性能权衡

CLIP提供多种预训练模型，需根据应用场景选择：

模型	输入分辨率	参数规模	特征维度	推理速度(ms)	零样本性能
ViT-B/32	224×224	151M	512	12	76.2%
ViT-B/16	224×224	151M	512	13	78.0%
ViT-L/14	224×224	303M	768	20	81.2%
RN50	224×224	102M	1024	15	76.4%
RN50x4	288×288	193M	1024	25	79.0%

表：CLIP模型性能对比（ImageNet零样本准确率，NVIDIA T4 GPU）

4.2 显存优化策略

处理高分辨率图像时，显存占用可能成为瓶颈，可采用以下策略：

1. 梯度检查点：牺牲部分计算速度换取显存节省

# 启用梯度检查点
torch.utils.checkpoint.checkpoint_sequential(clip_model.transformer.resblocks, 4, x)

2. 混合精度训练：使用FP16减少显存占用

# 混合精度训练
scaler = torch.cuda.amp.GradScaler()
with torch.cuda.amp.autocast():
    features = model.encode_image(images)
    loss = compute_loss(features, targets)
scaler.scale(loss).backward()

3. 图像分块处理：对超大图像分块编码后融合特征

def chunked_image_encoding(image, model, preprocess, chunk_size=224, overlap=32):
    """分块编码大图像"""
    img_tensor = preprocess(image).unsqueeze(0).cuda()
    _, _, H, W = img_tensor.shape
    
    features = []
    
    # 滑动窗口分块
    for i in range(0, H, chunk_size - overlap):
        for j in range(0, W, chunk_size - overlap):
            # 提取块
            chunk = img_tensor[:, :, i:min(i+chunk_size, H), j:min(j+chunk_size, W)]
            
            # 编码块
            with torch.no_grad():
                feat = model.encode_image(chunk)
            features.append(feat)
    
    # 平均特征
    return torch.stack(features).mean(dim=0)

4.3 部署加速技术

1. 模型量化：将FP32模型量化为INT8，减少75%显存占用

# 使用PyTorch量化
clip_model = torch.quantization.quantize_dynamic(
    clip_model, {torch.nn.Linear}, dtype=torch.qint8
)

2. ONNX导出与优化：

# 导出ONNX模型
dummy_image = torch.randn(1, 3, 224, 224).cuda()
torch.onnx.export(
    clip_model.visual, dummy_image, "clip_visual.onnx",
    input_names=["image"], output_names=["features"],
    dynamic_axes={"image": {0: "batch_size"}, "features": {0: "batch_size"}},
    opset_version=12
)

# 使用ONNX Runtime优化
import onnxruntime as ort
session = ort.InferenceSession("clip_visual.onnx", providers=["CUDAExecutionProvider"])

3. TensorRT加速：进一步优化推理速度

# TensorRT转换（需要TensorRT安装）
import tensorrt as trt
TRT_LOGGER = trt.Logger(trt.Logger.WARNING)
builder = trt.Builder(TRT_LOGGER)
network = builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH))
parser = trt.OnnxParser(network, TRT_LOGGER)
with open("clip_visual.onnx", "rb") as f:
    parser.parse(f.read())

config = builder.create_builder_config()
config.max_workspace_size = 1 << 30  # 1GB
serialized_engine = builder.build_serialized_network(network, config)

# 保存引擎
with open("clip_visual.engine", "wb") as f:
    f.write(serialized_engine)

五、挑战与未来方向

5.1 当前局限

尽管CLIP在跨模态理解方面表现出色，但在图像转换任务中仍存在以下局限：

1. 分辨率限制：原生CLIP模型输入分辨率固定（通常224×224），难以处理高分辨率细节
2. 生成能力弱：CLIP本身不具备生成能力，需与GAN等生成模型配合
3. 语义对齐噪声：复杂场景下文本与图像特征对齐可能不准确
4. 计算成本高：Transformer架构计算量较大，实时应用受限

5.2 前沿研究方向

1. 扩散模型集成：CLIP与Stable Diffusion等扩散模型结合，提升生成质量
2. 多尺度特征融合：设计跨分辨率特征提取，保留细节信息
3. 提示工程优化：自动优化文本提示，减少人工设计需求
4. 高效架构设计：轻量级CLIP变体（如MobileCLIP）适合边缘设备

5.3 实用建议

对于实际应用，建议：

1. 优先使用预训练模型：避免从头训练，利用开源预训练权重
2. 组合专用模型：CLIP负责语义理解，专用模型负责图像生成/修复
3. 渐进式优化：先快速原型验证，再逐步优化性能和效果
4. 关注社区进展：CLIP生态发展迅速，及时跟进最新技术

结语：跨模态AI的新时代

CLIP模型不仅是一个图像-文本匹配工具，更开创了**"以语义为中心"**的图像理解范式。通过将视觉内容与语言描述统一到共享的嵌入空间，CLIP为跨域图像转换提供了强大的语义锚点。从文本引导的艺术创作到智能图像编辑，从跨域检索到视觉无障碍，CLIP正在重塑我们与视觉内容交互的方式。

随着研究的深入，我们有理由相信，CLIP及其后续模型将继续突破模态壁垒，为计算机视觉带来更自然、更智能的交互方式。掌握这些技术，将使我们站在跨模态AI浪潮的前沿，创造出更具想象力的视觉应用。

行动建议：

• 从简单文本引导的图像修改开始实践
• 尝试组合CLIP与现有图像编辑工具
• 关注提示工程（Prompt Engineering）技巧
• 参与开源社区，贡献创新应用案例

祝你的跨域图像转换之旅充满创意与突破！

【免费下载链接】CLIP CLIP (Contrastive Language-Image Pretraining), Predict the most relevant text snippet given an image 项目地址: https://gitcode.com/GitHub_Trending/cl/CLIP