SigLIP-SO400M多模态视觉语言模型技术解析与应用实战

SigLIP-SO400M多模态视觉语言模型技术解析与应用实战【免费下载链接】siglip-so400m-patch14-384项目地址: https://ai.gitcode.com/hf_mirrors/google/siglip-so400m-patch14-384在计算机视觉与自然语言处理的交叉领域SigLIP-SO400M代表了Google在多模态人工智能研究中的最新突破。这款基于Sigmoid损失函数优化的视觉语言模型通过4亿参数的规模实现了在零样本图像分类任务中的卓越性能。本文将深入剖析其技术架构、实践应用方法以及性能优化策略为技术开发者和研究人员提供全面的技术参考。理论解析双编码器架构与Sigmoid损失函数SigLIP-SO400M采用了创新的双编码器架构包含独立的视觉编码器和文本编码器两者通过对比学习实现跨模态语义对齐。与传统的CLIP模型相比SigLIP最大的技术突破在于Sigmoid损失函数的应用这一改变使得模型在训练时不再需要全局的pairwise相似度归一化从而实现了更高效的训练过程。核心架构参数解析从配置文件config.json中我们可以提取到模型的关键技术参数隐藏层维度1152维的统一特征空间Transformer层数27层深度编码器注意力头数量16头多头注意力机制图像处理尺寸384×384像素分辨率补丁大小14×14像素的视觉token划分# 模型配置参数提取函数 def extract_model_config(config_path): 从配置文件提取关键模型参数 import json with open(config_path, r) as f: config json.load(f) vision_config config.get(vision_config, {}) text_config config.get(text_config, {}) return { architecture: config.get(architectures, [SiglipModel])[0], hidden_dimension: vision_config.get(hidden_size, 1152), vision_layers: vision_config.get(num_hidden_layers, 27), text_layers: text_config.get(num_hidden_layers, 27), attention_heads: vision_config.get(num_attention_heads, 16), image_size: vision_config.get(image_size, 384), patch_size: vision_config.get(patch_size, 14), intermediate_size: vision_config.get(intermediate_size, 4304) } # 使用示例 model_params extract_model_config(config.json) print(f模型架构: {model_params[architecture]}) print(f隐藏维度: {model_params[hidden_dimension]}维) print(f视觉编码器层数: {model_params[vision_layers]}层)快速上手环境配置与基础推理依赖环境搭建# 环境验证与依赖安装脚本 import subprocess import sys def setup_siglip_environment(): 设置SigLIP模型运行环境 required_packages [ torch2.0.0, transformers4.35.0, Pillow9.0.0, requests2.28.0 ] print(正在验证Python环境...) python_version sys.version_info if python_version.major 3 or (python_version.major 3 and python_version.minor 8): raise RuntimeError(需要Python 3.8或更高版本) print(正在安装依赖包...) for package in required_packages: try: subprocess.check_call([sys.executable, -m, pip, install, package]) print(f✓ 已安装: {package}) except subprocess.CalledProcessError as e: print(f✗ 安装失败: {package}, 错误: {e}) return False print(环境配置完成) return True def verify_gpu_availability(): 验证GPU可用性并设置设备 import torch if torch.cuda.is_available(): device torch.device(cuda) gpu_count torch.cuda.device_count() current_device torch.cuda.current_device() device_name torch.cuda.get_device_name(current_device) print(f检测到GPU: {device_name}) print(f可用GPU数量: {gpu_count}) print(f当前设备索引: {current_device}) # 测试GPU内存 memory_allocated torch.cuda.memory_allocated() / 1024**3 memory_cached torch.cuda.memory_reserved() / 1024**3 print(f已分配显存: {memory_allocated:.2f} GB) print(f缓存显存: {memory_cached:.2f} GB) return device, True else: print(未检测到GPU将使用CPU运行) return torch.device(cpu), False # 执行环境检查 if __name__ __main__: setup_siglip_environment() device, has_gpu verify_gpu_availability()基础推理实现# 基础推理模块 import torch from PIL import Image import requests from typing import List, Dict, Optional import logging logging.basicConfig(levellogging.INFO) logger logging.getLogger(__name__) class SiglipInferenceEngine: SigLIP模型推理引擎 def __init__(self, model_path: str google/siglip-so400m-patch14-384): 初始化推理引擎 Args: model_path: 模型路径或HuggingFace模型ID self.model_path model_path self.device self._setup_device() self.model None self.processor None def _setup_device(self) - torch.device: 设置运行设备 if torch.cuda.is_available(): device torch.device(cuda) logger.info(f使用GPU设备: {torch.cuda.get_device_name(0)}) else: device torch.device(cpu) logger.info(使用CPU设备) return device def load_model(self): 加载模型和处理器 from transformers import AutoModel, AutoProcessor try: logger.info(f开始加载模型: {self.model_path}) self.model AutoModel.from_pretrained(self.model_path) self.processor AutoProcessor.from_pretrained(self.model_path) # 移动到指定设备 self.model self.model.to(self.device) self.model.eval() logger.info(模型加载成功) return True except Exception as e: logger.error(f模型加载失败: {str(e)}) raise def zero_shot_classify( self, image_path: str, candidate_labels: List[str], temperature: float 1.0 ) - List[Dict[str, float]]: 零样本图像分类 Args: image_path: 图像文件路径或URL candidate_labels: 候选标签列表 temperature: 温度参数控制概率分布 Returns: 分类结果列表按置信度排序 if self.model is None or self.processor is None: raise RuntimeError(请先调用load_model()加载模型) try: # 加载图像 if image_path.startswith((http://, https://)): image Image.open(requests.get(image_path, streamTrue).raw) else: image Image.open(image_path) # 准备文本提示 texts [fa photo of {label} for label in candidate_labels] # 预处理输入 inputs self.processor( texttexts, imagesimage, paddingmax_length, return_tensorspt ).to(self.device) # 推理 with torch.no_grad(): outputs self.model(**inputs) # 计算概率 logits_per_image outputs.logits_per_image probs torch.sigmoid(logits_per_image / temperature) # 格式化结果 results [] for i, label in enumerate(candidate_labels): score probs[0][i].item() results.append({ label: label, score: score, confidence: f{score * 100:.2f}% }) # 按置信度排序 results.sort(keylambda x: x[score], reverseTrue) logger.info(f分类完成最高置信度: {results[0][confidence]}) return results except Exception as e: logger.error(f分类失败: {str(e)}) raise # 使用示例 def main(): # 初始化推理引擎 engine SiglipInferenceEngine() engine.load_model() # 示例图像URL image_url http://images.cocodataset.org/val2017/000000039769.jpg # 候选标签 labels [cat, dog, furniture, electronic device, food] # 执行分类 results engine.zero_shot_classify(image_url, labels) print(分类结果:) for i, result in enumerate(results[:3], 1): print(f{i}. {result[label]}: {result[confidence]}) if __name__ __main__: main()实践应用多场景解决方案场景一内容审核系统# 内容安全审核模块 import asyncio from concurrent.futures import ThreadPoolExecutor from dataclasses import dataclass from enum import Enum import time class ContentCategory(Enum): 内容分类枚举 SAFE safe VIOLENCE violence NUDITY nudity HATE_SPEECH hate_speech SPAM spam dataclass class ContentResult: 内容审核结果 category: ContentCategory confidence: float is_safe: bool timestamp: float class ContentModerator: 基于SigLIP的内容审核系统 def __init__(self, engine: SiglipInferenceEngine, threshold: float 0.7): self.engine engine self.threshold threshold self.executor ThreadPoolExecutor(max_workers4) # 定义安全相关标签 self.safety_labels { ContentCategory.SAFE: [safe content, appropriate, family friendly], ContentCategory.VIOLENCE: [violence, weapon, fight, blood], ContentCategory.NUDITY: [nudity, sexual content, explicit], ContentCategory.HATE_SPEECH: [hate speech, discrimination, offensive], ContentCategory.SPAM: [advertisement, spam, commercial] } async def moderate_image_async(self, image_path: str) - ContentResult: 异步内容审核 Args: image_path: 图像路径 Returns: 审核结果 loop asyncio.get_event_loop() # 准备所有标签 all_labels [] category_mapping {} for category, labels in self.safety_labels.items(): for label in labels: all_labels.append(label) category_mapping[label] category # 异步执行分类 results await loop.run_in_executor( self.executor, self.engine.zero_shot_classify, image_path, all_labels ) # 分析结果 category_scores {cat: 0.0 for cat in ContentCategory} for result in results: label result[label] score result[score] category category_mapping.get(label) if category: category_scores[category] max(category_scores[category], score) # 确定主要类别 main_category max(category_scores.items(), keylambda x: x[1]) category_enum, max_score main_category # 判断是否安全 is_safe (category_enum ContentCategory.SAFE or max_score self.threshold) return ContentResult( categorycategory_enum, confidencemax_score, is_safeis_safe, timestamptime.time() ) def batch_moderate(self, image_paths: List[str], batch_size: int 4) - List[ContentResult]: 批量内容审核 Args: image_paths: 图像路径列表 batch_size: 批处理大小 Returns: 审核结果列表 results [] for i in range(0, len(image_paths), batch_size): batch image_paths[i:i batch_size] batch_results [] # 同步处理批次 for img_path in batch: try: # 这里使用同步版本实际生产环境建议使用异步 labels [] for cat_labels in self.safety_labels.values(): labels.extend(cat_labels) classification self.engine.zero_shot_classify(img_path, labels) # 分析分类结果简化版 max_score max(r[score] for r in classification) max_label next(r for r in classification if r[score] max_score) # 确定类别 category ContentCategory.SAFE for cat, cat_labels in self.safety_labels.items(): if max_label[label] in cat_labels: category cat break is_safe (category ContentCategory.SAFE or max_score self.threshold) result ContentResult( categorycategory, confidencemax_score, is_safeis_safe, timestamptime.time() ) batch_results.append(result) except Exception as e: logger.error(f处理图像失败 {img_path}: {str(e)}) continue results.extend(batch_results) logger.info(f已处理批次 {i//batch_size 1}/{(len(image_paths)-1)//batch_size 1}) return results # 使用示例 async def demo_content_moderation(): 内容审核演示 engine SiglipInferenceEngine() engine.load_model() moderator ContentModerator(engine) # 测试图像 test_images [ http://images.cocodataset.org/val2017/000000039769.jpg, http://images.cocodataset.org/val2017/000000039770.jpg ] print(开始内容审核...) # 异步审核 tasks [moderator.moderate_image_async(img) for img in test_images] results await asyncio.gather(*tasks) for i, result in enumerate(results): status 安全 if result.is_safe else 不安全 print(f图像{i1}: 类别{result.category.value}, f置信度{result.confidence:.2%}, 状态{status}) # 运行演示 if __name__ __main__: asyncio.run(demo_content_moderation())场景二智能商品分类系统# 电商商品分类系统 import json from pathlib import Path from typing import Dict, List, Tuple import numpy as np from datetime import datetime class ProductClassifier: 基于SigLIP的智能商品分类系统 def __init__(self, engine: SiglipInferenceEngine, categories_config: str None): 初始化商品分类器 Args: engine: SigLIP推理引擎 categories_config: 分类配置JSON文件路径 self.engine engine self.categories self._load_categories(categories_config) self.performance_stats { total_classifications: 0, correct_predictions: 0, avg_confidence: 0.0, last_updated: datetime.now().isoformat() } def _load_categories(self, config_path: Optional[str]) - Dict[str, List[str]]: 加载商品分类配置 Args: config_path: 配置文件路径 Returns: 分类字典 default_categories { electronics: [ smartphone, laptop, headphones, camera, television, tablet, smartwatch, gaming console ], clothing: [ t-shirt, jeans, dress, jacket, shoes, hat, socks, underwear ], home: [ furniture, kitchen appliance, bedding, decor, lighting, storage ], books: [ fiction, non-fiction, textbook, magazine, comic, childrens book ], sports: [ equipment, clothing, shoes, accessories ] } if config_path and Path(config_path).exists(): try: with open(config_path, r) as f: custom_categories json.load(f) return {**default_categories, **custom_categories} except Exception as e: logger.warning(f加载自定义分类配置失败: {str(e)}使用默认配置) return default_categories def classify_product( self, image_path: str, top_k: int 3, confidence_threshold: float 0.3 ) - Dict: 商品图像分类 Args: image_path: 商品图像路径 top_k: 返回前K个结果 confidence_threshold: 置信度阈值 Returns: 分类结果 # 准备所有候选标签 all_labels [] label_to_category {} for category, labels in self.categories.items(): for label in labels: full_label fa photo of {label} all_labels.append(full_label) label_to_category[full_label] category # 执行分类 try: results self.engine.zero_shot_classify(image_path, all_labels) # 按类别聚合分数 category_scores {} for result in results: label result[label] score result[score] category label_to_category[label] if category not in category_scores: category_scores[category] [] category_scores[category].append(score) # 计算每个类别的平均置信度 category_avg_scores {} for category, scores in category_scores.items(): avg_score np.mean(scores) category_avg_scores[category] avg_score # 过滤并排序 filtered_categories { cat: score for cat, score in category_avg_scores.items() if score confidence_threshold } sorted_categories sorted( filtered_categories.items(), keylambda x: x[1], reverseTrue )[:top_k] # 更新性能统计 self.performance_stats[total_classifications] 1 if sorted_categories: self.performance_stats[avg_confidence] ( self.performance_stats[avg_confidence] * (self.performance_stats[total_classifications] - 1) sorted_categories[0][1] ) / self.performance_stats[total_classifications] # 构建返回结果 classification_result { image: image_path, timestamp: datetime.now().isoformat(), top_categories: [ { category: category, confidence: float(score), confidence_percentage: f{score * 100:.1f}% } for category, score in sorted_categories ], all_categories: { cat: float(score) for cat, score in category_avg_scores.items() } } logger.info(f商品分类完成: {image_path}) return classification_result except Exception as e: logger.error(f商品分类失败 {image_path}: {str(e)}) raise def batch_classify( self, image_paths: List[str], batch_size: int 4 ) - List[Dict]: 批量商品分类 Args: image_paths: 图像路径列表 batch_size: 批处理大小 Returns: 分类结果列表 results [] for i in range(0, len(image_paths), batch_size): batch image_paths[i:i batch_size] logger.info(f处理批次 {i//batch_size 1}: {len(batch)}张图像) for img_path in batch: try: result self.classify_product(img_path) results.append(result) except Exception as e: logger.error(f处理失败 {img_path}: {str(e)}) continue return results def get_performance_report(self) - Dict: 获取性能报告 Returns: 性能统计信息 self.performance_stats[last_updated] datetime.now().isoformat() if self.performance_stats[total_classifications] 0: accuracy ( self.performance_stats[correct_predictions] / self.performance_stats[total_classifications] if self.performance_stats[total_classifications] 0 else 0.0 ) self.performance_stats[accuracy] accuracy return self.performance_stats # 使用示例 def demo_product_classification(): 商品分类演示 # 初始化引擎 engine SiglipInferenceEngine() engine.load_model() # 创建分类器 classifier ProductClassifier(engine) # 测试图像 test_images [ http://images.cocodataset.org/val2017/000000039769.jpg, http://images.cocodataset.org/val2017/000000039770.jpg ] print(开始商品分类...) # 批量分类 results classifier.batch_classify(test_images, batch_size2) for i, result in enumerate(results): print(f\n商品{i1}分类结果:) print(f图像: {result[image]}) print(Top 3分类:) for cat_result in result[top_categories]: print(f - {cat_result[category]}: {cat_result[confidence_percentage]}) # 获取性能报告 report classifier.get_performance_report() print(f\n性能统计:) print(f总分类次数: {report[total_classifications]}) print(f平均置信度: {report[avg_confidence]:.2%}) if __name__ __main__: demo_product_classification()深度探索性能优化与问题解决性能基准测试# 性能基准测试模块 import time from functools import wraps from statistics import mean, stdev from typing import Callable, List, Tuple import psutil import torch class PerformanceBenchmark: SigLIP模型性能基准测试工具 def __init__(self): self.results {} self.memory_records [] def measure_memory_usage(self) - Tuple[float, float]: 测量当前内存使用情况 Returns: (系统内存使用率, GPU内存使用量) # 系统内存 system_memory psutil.virtual_memory() system_usage system_memory.percent # GPU内存 gpu_usage 0.0 if torch.cuda.is_available(): gpu_usage torch.cuda.memory_allocated() / torch.cuda.max_memory_allocated() * 100 return system_usage, gpu_usage def benchmark_inference( self, inference_func: Callable, *args, num_runs: int 10, warmup_runs: int 3, **kwargs ) - Dict: 基准测试推理性能 Args: inference_func: 推理函数 num_runs: 测试运行次数 warmup_runs: 预热运行次数 *args, **kwargs: 函数参数 Returns: 性能指标字典 print(f开始性能基准测试预热 {warmup_runs} 次测试 {num_runs} 次...) # 预热运行 for i in range(warmup_runs): try: inference_func(*args, **kwargs) print(f预热运行 {i1}/{warmup_runs} 完成) except Exception as e: print(f预热运行失败: {str(e)}) break # 正式测试 latencies [] memory_records [] for i in range(num_runs): # 记录开始前内存 start_memory self.measure_memory_usage() # 执行推理并计时 start_time time.perf_counter() result inference_func(*args, **kwargs) end_time time.perf_counter() # 记录结束后内存 end_memory self.measure_memory_usage() latency (end_time - start_time) * 1000 # 转换为毫秒 latencies.append(latency) memory_records.append({ run: i 1, start_system_memory: start_memory[0], start_gpu_memory: start_memory[1], end_system_memory: end_memory[0], end_gpu_memory: end_memory[1], memory_increase_system: end_memory[0] - start_memory[0], memory_increase_gpu: end_memory[1] - start_memory[1] }) print(f运行 {i1}/{num_runs}: {latency:.2f}ms) # 计算统计指标 if latencies: avg_latency mean(latencies) std_latency stdev(latencies) if len(latencies) 1 else 0 min_latency min(latencies) max_latency max(latencies) # 内存使用统计 avg_memory_increase_system mean( [r[memory_increase_system] for r in memory_records] ) avg_memory_increase_gpu mean( [r[memory_increase_gpu] for r in memory_records] ) benchmark_result { test_name: inference_func.__name__, num_runs: num_runs, latency_ms: { average: avg_latency, std_dev: std_latency, min: min_latency, max: max_latency, p95: sorted(latencies)[int(0.95 * len(latencies))] if latencies else 0, all_values: latencies }, memory_usage: { avg_system_increase: avg_memory_increase_system, avg_gpu_increase: avg_memory_increase_gpu, records: memory_records }, throughput_fps: 1000 / avg_latency if avg_latency 0 else 0 } self.results[inference_func.__name__] benchmark_result return benchmark_result return {} def compare_optimizations( self, original_func: Callable, optimized_func: Callable, *args, num_runs: int 10, **kwargs ) - Dict: 比较优化前后的性能差异 Args: original_func: 原始函数 optimized_func: 优化后函数 num_runs: 测试运行次数 Returns: 比较结果 print(开始优化对比测试...) original_result self.benchmark_inference( original_func, *args, num_runsnum_runs, **kwargs ) optimized_result self.benchmark_inference( optimized_func, *args, num_runsnum_runs, **kwargs ) if original_result and optimized_result: improvement { latency_improvement_percent: ( (original_result[latency_ms][average] - optimized_result[latency_ms][average]) / original_result[latency_ms][average] * 100 ), throughput_improvement_percent: ( (optimized_result[throughput_fps] - original_result[throughput_fps]) / original_result[throughput_fps] * 100 ), memory_reduction_percent: ( (original_result[memory_usage][avg_gpu_increase] - optimized_result[memory_usage][avg_gpu_increase]) / original_result[memory_usage][avg_gpu_increase] * 100 if original_result[memory_usage][avg_gpu_increase] 0 else 0 ) } comparison { original: original_result, optimized: optimized_result, improvement: improvement } print(\n优化对比结果:) print(f延迟改进: {improvement[latency_improvement_percent]:.1f}%) print(f吞吐量改进: {improvement[throughput_improvement_percent]:.1f}%) print(f内存使用减少: {improvement[memory_reduction_percent]:.1f}%) return comparison return {} # 优化示例函数 def optimized_inference(engine, image_path, labels): 优化后的推理函数示例 # 使用混合精度推理 with torch.cuda.amp.autocast(): with torch.no_grad(): # 这里可以添加具体的优化逻辑 result engine.zero_shot_classify(image_path, labels) return result # 使用示例 def run_benchmark(): 运行性能基准测试 # 初始化引擎 engine SiglipInferenceEngine() engine.load_model() # 准备测试数据 test_image http://images.cocodataset.org/val2017/000000039769.jpg test_labels [cat, dog, furniture, electronic device, food] # 创建基准测试工具 benchmark PerformanceBenchmark() # 测试原始推理 print(测试原始推理性能...) original_result benchmark.benchmark_inference( engine.zero_shot_classify, test_image, test_labels, num_runs5, warmup_runs2 ) # 测试优化后推理 print(\n测试优化后推理性能...) optimized_result benchmark.benchmark_inference( optimized_inference, engine, test_image, test_labels, num_runs5, warmup_runs2 ) # 比较结果 comparison benchmark.compare_optimizations( engine.zero_shot_classify, optimized_inference, test_image, test_labels, num_runs5 ) return benchmark.results if __name__ __main__: results run_benchmark() print(\n基准测试完成!)常见问题解决方案问题1GPU内存不足错误# 内存优化配置 def configure_memory_optimization(): 配置内存优化策略 import torch optimization_config { gradient_checkpointing: False, # 启用梯度检查点 mixed_precision: True, # 混合精度训练 batch_size_auto_tune: True, # 自动调整批处理大小 cache_cleanup_interval: 10, # 缓存清理间隔 } if torch.cuda.is_available(): # 设置CUDA内存管理策略 torch.cuda.empty_cache() # 启用TensorFloat-32 (仅限Ampere架构以上GPU) if torch.cuda.get_device_capability()[0] 8: torch.backends.cuda.matmul.allow_tf32 True torch.backends.cudnn.allow_tf32 True # 设置内存分配器 torch.cuda.memory.set_per_process_memory_fraction(0.9) return optimization_config # 动态批处理大小调整 class DynamicBatchScheduler: 动态批处理调度器 def __init__(self, initial_batch_size: int 4, max_batch_size: int 32): self.initial_batch_size initial_batch_size self.max_batch_size max_batch_size self.current_batch_size initial_batch_size self.memory_threshold 0.8 # 80%内存使用阈值 def adjust_batch_size(self, memory_usage: float) - int: 根据内存使用情况调整批处理大小 if memory_usage self.memory_threshold: # 内存使用过高减小批处理大小 new_size max(1, int(self.current_batch_size * 0.8)) print(f内存使用率 {memory_usage:.1%}过高批处理大小从{self.current_batch_size}减小到{new_size}) else: # 内存充足尝试增加批处理大小 new_size min(self.max_batch_size, int(self.current_batch_size * 1.2)) if new_size self.current_batch_size: print(f内存充足批处理大小从{self.current_batch_size}增加到{new_size}) self.current_batch_size new_size return new_size问题2推理速度慢# 推理速度优化策略 def apply_inference_optimizations(model): 应用推理速度优化 import torch optimizations_applied [] # 1. 启用CUDA图如果可用 if torch.cuda.is_available() and hasattr(torch, cuda): try: torch.backends.cudnn.benchmark True optimizations_applied.append(CUDA基准测试启用) except: pass # 2. 模型编译PyTorch 2.0 if hasattr(torch, compile): try: model torch.compile(model, modereduce-overhead) optimizations_applied.append(模型编译启用) except: pass # 3. 设置线程数 torch.set_num_threads(4) torch.set_num_interop_threads(4) optimizations_applied.append(线程数优化) # 4. 禁用梯度计算 for param in model.parameters(): param.requires_grad False optimizations_applied.append(梯度计算禁用) print(f已应用优化: {, .join(optimizations_applied)}) return model总结与最佳实践SigLIP-SO400M作为先进的视觉语言模型在零样本图像分类任务中展现出卓越性能。通过本文的技术解析和实践应用示例我们可以看到核心优势Sigmoid损失函数避免了全局归一化需求支持更大批处理规模统一特征空间1152维确保视觉和文本表示的良好对齐深度Transformer架构27层提供强大的特征提取能力最佳实践建议环境配置使用Python 3.8确保CUDA版本与PyTorch兼容内存管理根据GPU内存动态调整批处理大小启用混合精度推理性能优化使用模型编译、CUDA图和适当的线程配置错误处理实现完善的异常处理和日志记录机制生产部署考虑使用异步处理提高并发性能实现请求队列和负载均衡添加监控和告警机制定期更新模型权重和依赖库通过合理的架构设计和性能优化SigLIP-SO400M可以在实际生产环境中发挥最大效能为图像理解、内容审核、智能推荐等应用场景提供强大的技术支持。【免费下载链接】siglip-so400m-patch14-384项目地址: https://ai.gitcode.com/hf_mirrors/google/siglip-so400m-patch14-384创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考