nomic-embed-text-v2-moe部署教程：GPU显存优化方案，768维嵌入高效运行

nomic-embed-text-v2-moe部署教程：GPU显存优化方案，768维嵌入高效运行

1. 开篇：为什么你需要关注这个嵌入模型？

如果你正在做多语言文本检索、语义搜索或者构建自己的RAG应用，那你肯定遇到过这样的问题：要么模型太大，显存吃不消；要么模型太小，效果不理想；要么支持的语言太少，不够用。

今天要介绍的nomic-embed-text-v2-moe，正好能解决这些痛点。这是一个305M参数的多语言嵌入模型，支持大约100种语言，而且经过Matryoshka嵌入训练，可以在保持性能的同时，把存储成本降低3倍。

简单来说，就是“小而强，多而精”。它用更少的资源，做到了大模型才能做到的事情。

我最近用ollama部署了这个模型，并给它加了个gradio前端，让推理过程变得可视化。更重要的是，我找到了一些显存优化的方法，能让它在消费级GPU上也能流畅运行。下面我就把整个部署过程和优化技巧分享给你。

2. 模型到底有多强？数据说话

在动手之前，我们先看看这个模型到底值不值得折腾。下面这个表格对比了几个主流的多语言嵌入模型：

从表格里你能看到几个关键信息：

1. 性能不错：在BEIR和MIRACL这两个常用的检索评测集上，nomic-embed-v2的表现很有竞争力
2. 参数适中：305M参数，比那些500M+的大模型小了不少，但效果没差多少
3. 完全开源：这是最重要的！模型权重、代码、训练数据全都开源，你可以随便用、随便改
4. 多语言支持：支持约100种语言，这意味着你可以用它做中文、英文、日文、法文...几乎任何语言的文本检索

3. 环境准备：你需要什么？

在开始部署之前，我们先看看需要准备些什么。别担心，要求不高。

3.1 硬件要求

• GPU：至少8GB显存（我用RTX 3070 8G测试通过）
• 内存：16GB以上
• 存储：模型文件大约1.2GB，留出2-3GB空间比较稳妥

3.2 软件环境

• 操作系统：Ubuntu 20.04/22.04，或者Windows WSL2
• Python：3.8以上版本
• CUDA：11.7或12.1（建议用12.1，兼容性更好）
• Docker：可选，但用ollama的话不需要

如果你不确定自己的环境，可以运行下面这些命令检查一下：

# 检查Python版本 python3 --version # 检查CUDA版本 nvcc --version # 检查GPU信息 nvidia-smi

4. 核心部署：用ollama一键搞定

ollama真是个好东西，它让模型部署变得像安装软件一样简单。下面我带你一步步走完整个流程。

4.1 安装ollama

如果你还没安装ollama，先把它装上：

# Linux/macOS安装 curl -fsSL https://ollama.ai/install.sh | sh # Windows安装 # 直接去官网下载安装包：https://ollama.ai/download

安装完成后，启动ollama服务：

# 启动服务 ollama serve # 或者用systemd（Linux） sudo systemctl start ollama

4.2 拉取nomic-embed-v2模型

ollama支持很多模型，nomic-embed-v2也在其中。拉取模型很简单：

# 拉取模型 ollama pull nomic-embed-text:v2 # 查看已安装的模型 ollama list

这个过程会下载大约1.2GB的模型文件，取决于你的网速，可能需要几分钟到十几分钟。

4.3 验证模型是否正常工作

模型下载完成后，我们先做个简单的测试：

# 运行模型测试 ollama run nomic-embed-text:v2 "Hello, world!" # 或者用API方式测试 curl http://localhost:11434/api/embeddings -d '{ "model": "nomic-embed-text:v2", "prompt": "Hello, world!" }'

如果一切正常，你会看到返回的嵌入向量（一个768维的浮点数数组）。

5. 显存优化：让模型跑得更流畅

这是本文的重点！305M的模型听起来不大，但实际运行时，如果处理大量文本或者batch size设得太大，显存还是会爆。下面我分享几个实用的优化技巧。

5.1 调整batch size

这是最直接的优化方法。默认情况下，ollama可能会用比较大的batch size，我们可以手动调整：

# 创建一个配置文件 import json config = { "model": "nomic-embed-text:v2", "options": { "num_gpu": 1, "num_thread": 4, "batch_size": 16, # 根据你的显存调整 "low_vram": True # 低显存模式 } } with open('nomic_config.json', 'w') as f: json.dump(config, f, indent=2)

batch size建议：

• 8GB显存：batch_size=8-16
• 12GB显存：batch_size=16-32
• 24GB显存：batch_size=32-64

5.2 使用量化版本

如果你显存真的很紧张，可以考虑使用量化版本。量化能大幅减少模型大小和显存占用：

# 拉取4-bit量化版本 ollama pull nomic-embed-text:v2-q4_K_M # 或者8-bit版本 ollama pull nomic-embed-text:v2-q8_0

量化版本的效果会有轻微下降，但显存占用能减少40-70%，对于很多应用来说完全够用。

5.3 分块处理长文本

nomic-embed-v2的最大序列长度是8192，但处理长文本时，我们可以先分块再处理：

def chunk_text(text, chunk_size=512, overlap=50): """将长文本分块，保留重叠部分确保上下文连贯""" words = text.split() chunks = [] for i in range(0, len(words), chunk_size - overlap): chunk = ' '.join(words[i:i + chunk_size]) chunks.append(chunk) if i + chunk_size >= len(words): break return chunks # 使用示例 long_text = "你的长文本内容..." chunks = chunk_text(long_text, chunk_size=512, overlap=50) # 分批处理，避免显存溢出 embeddings = [] for chunk in chunks: embedding = get_embedding(chunk) # 你的嵌入函数 embeddings.append(embedding)

5.4 监控显存使用

实时监控显存使用情况，能帮你找到最优的配置：

import torch import psutil import GPUtil def monitor_resources(): """监控GPU和内存使用情况""" gpus = GPUtil.getGPUs() print("=== 资源监控 ===") for gpu in gpus: print(f"GPU {gpu.id}: {gpu.name}") print(f" 显存使用: {gpu.memoryUsed}MB / {gpu.memoryTotal}MB") print(f" 使用率: {gpu.load * 100:.1f}%") # 内存使用 memory = psutil.virtual_memory() print(f"内存使用: {memory.used / 1024**3:.1f}GB / {memory.total / 1024**3:.1f}GB") # PyTorch显存 if torch.cuda.is_available(): print(f"PyTorch显存: {torch.cuda.memory_allocated() / 1024**2:.1f}MB") print(f"PyTorch缓存: {torch.cuda.memory_reserved() / 1024**2:.1f}MB") # 在关键位置调用监控 monitor_resources()

6. 添加Gradio前端：让推理可视化

命令行用着不直观？加个Web界面就好了。Gradio是个很好的选择，几行代码就能做出不错的界面。

6.1 安装依赖

pip install gradio requests

6.2 创建Gradio应用

import gradio as gr import requests import json import numpy as np from typing import List class NomicEmbeddingApp: def __init__(self, ollama_url="http://localhost:11434"): self.ollama_url = ollama_url self.model_name = "nomic-embed-text:v2" def get_embedding(self, text: str) -> List[float]: """获取文本嵌入""" try: response = requests.post( f"{self.ollama_url}/api/embeddings", json={ "model": self.model_name, "prompt": text }, timeout=30 ) if response.status_code == 200: result = response.json() return result.get("embedding", []) else: print(f"请求失败: {response.status_code}") return [] except Exception as e: print(f"获取嵌入时出错: {e}") return [] def calculate_similarity(self, text1: str, text2: str) -> float: """计算两个文本的余弦相似度""" emb1 = self.get_embedding(text1) emb2 = self.get_embedding(text2) if not emb1 or not emb2: return 0.0 # 转换为numpy数组 vec1 = np.array(emb1) vec2 = np.array(emb2) # 计算余弦相似度 similarity = np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2)) return float(similarity) def batch_embedding(self, texts: List[str]) -> List[List[float]]: """批量获取嵌入（优化版）""" embeddings = [] # 分批处理，避免显存溢出 batch_size = 8 # 根据你的显存调整 for i in range(0, len(texts), batch_size): batch = texts[i:i + batch_size] batch_embeddings = [] for text in batch: emb = self.get_embedding(text) if emb: batch_embeddings.append(emb) embeddings.extend(batch_embeddings) # 显示进度 progress = min((i + len(batch)) / len(texts) * 100, 100) print(f"处理进度: {progress:.1f}%") return embeddings def create_interface(): """创建Gradio界面""" app = NomicEmbeddingApp() with gr.Blocks(title="Nomic Embedding Demo", theme=gr.themes.Soft()) as demo: gr.Markdown("# 🚀 Nomic Embed Text v2 MOE 演示") gr.Markdown("输入文本，获取768维嵌入向量，或计算文本相似度") with gr.Tab("单文本嵌入"): with gr.Row(): with gr.Column(): input_text = gr.Textbox( label="输入文本", placeholder="请输入要嵌入的文本...", lines=5 ) embed_btn = gr.Button("生成嵌入", variant="primary") with gr.Column(): output_embedding = gr.Textbox( label="嵌入向量（前50维）", lines=10, interactive=False ) vector_info = gr.Markdown() def process_single_text(text): if not text.strip(): return "", "请输入有效文本" embedding = app.get_embedding(text) if embedding: # 只显示前50维，避免界面卡顿 preview = ", ".join([f"{x:.6f}" for x in embedding[:50]]) info = f"**向量信息**\n- 维度: {len(embedding)}\n- 范数: {np.linalg.norm(np.array(embedding)):.4f}" return preview, info else: return "", "获取嵌入失败" embed_btn.click( process_single_text, inputs=[input_text], outputs=[output_embedding, vector_info] ) with gr.Tab("文本相似度"): with gr.Row(): with gr.Column(): text1 = gr.Textbox( label="文本1", placeholder="第一段文本...", lines=3 ) text2 = gr.Textbox( label="文本2", placeholder="第二段文本...", lines=3 ) similarity_btn = gr.Button("计算相似度", variant="primary") with gr.Column(): similarity_score = gr.Number( label="余弦相似度", precision=4 ) similarity_bar = gr.Slider( minimum=0, maximum=1, label="相似度可视化", interactive=False ) interpretation = gr.Markdown() def calculate_similarity_ui(t1, t2): if not t1.strip() or not t2.strip(): return 0, 0, "请输入两段文本" score = app.calculate_similarity(t1, t2) # 相似度解释 if score > 0.8: interpretation_text = "**高度相似**：两段文本语义非常接近" elif score > 0.6: interpretation_text = "**中度相似**：两段文本有较强关联" elif score > 0.4: interpretation_text = "**轻度相似**：两段文本有一定关联" elif score > 0.2: interpretation_text = "**弱相似**：两段文本关联较弱" else: interpretation_text = "**不相似**：两段文本语义差异较大" return score, score, interpretation_text similarity_btn.click( calculate_similarity_ui, inputs=[text1, text2], outputs=[similarity_score, similarity_bar, interpretation] ) with gr.Tab("批量处理"): with gr.Row(): with gr.Column(): batch_input = gr.Textbox( label="批量文本（每行一段）", placeholder="第一段文本...\n第二段文本...\n第三段文本...", lines=8 ) batch_btn = gr.Button("批量嵌入", variant="primary") with gr.Column(): batch_output = gr.Dataframe( label="嵌入矩阵预览", headers=["文本索引", "向量维度", "前3维值"], interactive=False ) batch_info = gr.Markdown() def process_batch(texts): if not texts.strip(): return pd.DataFrame(), "请输入文本" text_list = [t.strip() for t in texts.split('\n') if t.strip()] if not text_list: return pd.DataFrame(), "没有有效文本" embeddings = app.batch_embedding(text_list) # 准备预览数据 preview_data = [] for i, emb in enumerate(embeddings): if i < 10: # 只显示前10个 preview_data.append([ f"文本{i+1}", len(emb), f"[{emb[0]:.4f}, {emb[1]:.4f}, {emb[2]:.4f}]" ]) info_text = f"**处理完成**\n- 文本数量: {len(text_list)}\n- 成功嵌入: {len(embeddings)}\n- 向量维度: 768" return pd.DataFrame(preview_data), info_text batch_btn.click( process_batch, inputs=[batch_input], outputs=[batch_output, batch_info] ) # 添加使用说明 with gr.Accordion("使用说明", open=False): gr.Markdown(""" ### 📖 使用指南 1. **单文本嵌入**：输入任意文本，获取768维嵌入向量 2. **文本相似度**：输入两段文本，计算它们的语义相似度（0-1之间） 3. **批量处理**：每行输入一段文本，批量获取嵌入向量 ### ⚙️ 优化建议 - 单次处理文本不要过长（建议<1000字） - 批量处理时，建议一次不要超过50段文本 - 如果遇到显存不足，请减少批量大小或使用量化版本 ### 🔧 技术参数 - 模型：nomic-embed-text:v2 - 维度：768 - 最大序列长度：8192 - 支持语言：约100种 """) return demo if __name__ == "__main__": # 创建并启动应用 demo = create_interface() demo.launch( server_name="0.0.0.0", server_port=7860, share=False # 设置为True可以生成公共链接 )

6.3 运行Gradio应用

保存上面的代码为app.py，然后运行：

python app.py

打开浏览器，访问http://localhost:7860，你就能看到这样的界面：

界面分为三个主要部分：

1. 单文本嵌入：输入一段文本，获取它的嵌入向量
2. 文本相似度：输入两段文本，计算它们的语义相似度
3. 批量处理：一次性处理多段文本

6.4 相似度验证功能

在“文本相似度”标签页，你可以测试模型的理解能力。比如：

• 输入“我喜欢吃苹果”和“苹果是一种水果”，相似度会很高（0.8以上）
• 输入“我喜欢吃苹果”和“今天天气真好”，相似度会很低（0.2以下）

成功运行后，你会看到类似这样的结果：

7. 实际应用：几个实用场景

部署好了，优化也做了，界面也有了，现在来看看它能做什么。

7.1 语义搜索

import numpy as np from typing import List, Tuple class SemanticSearch: def __init__(self, embedding_app): self.app = embedding_app self.documents = [] self.embeddings = [] def add_documents(self, docs: List[str]): """添加文档到搜索库""" self.documents.extend(docs) # 批量获取嵌入 new_embeddings = self.app.batch_embedding(docs) self.embeddings.extend(new_embeddings) def search(self, query: str, top_k: int = 5) -> List[Tuple[str, float]]: """语义搜索""" query_embedding = self.app.get_embedding(query) if not query_embedding: return [] query_vec = np.array(query_embedding) # 计算相似度 similarities = [] for i, doc_vec in enumerate(self.embeddings): if len(doc_vec) == len(query_vec): doc_array = np.array(doc_vec) similarity = np.dot(query_vec, doc_array) / ( np.linalg.norm(query_vec) * np.linalg.norm(doc_array) ) similarities.append((i, similarity)) # 排序并返回top_k similarities.sort(key=lambda x: x[1], reverse=True) results = [] for idx, score in similarities[:top_k]: results.append((self.documents[idx], float(score))) return results # 使用示例 search_engine = SemanticSearch(NomicEmbeddingApp()) # 添加文档 docs = [ "机器学习是人工智能的一个分支", "深度学习使用神经网络进行学习", "Python是一种流行的编程语言", "Java在企业开发中广泛应用", "TensorFlow是谷歌开发的深度学习框架" ] search_engine.add_documents(docs) # 搜索 results = search_engine.search("人工智能技术", top_k=3) for doc, score in results: print(f"相似度: {score:.4f} - {doc[:50]}...")

7.2 文本分类

from sklearn.linear_model import LogisticRegression from sklearn.model_selection import train_test_split import numpy as np class TextClassifier: def __init__(self, embedding_app): self.app = embedding_app self.model = LogisticRegression(max_iter=1000) def train(self, texts: List[str], labels: List[int]): """训练分类器""" # 获取文本嵌入 embeddings = self.app.batch_embedding(texts) # 转换为numpy数组 X = np.array(embeddings) y = np.array(labels) # 划分训练测试集 X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42 ) # 训练模型 self.model.fit(X_train, y_train) # 评估 train_score = self.model.score(X_train, y_train) test_score = self.model.score(X_test, y_test) print(f"训练准确率: {train_score:.4f}") print(f"测试准确率: {test_score:.4f}") return train_score, test_score def predict(self, texts: List[str]) -> List[int]: """预测文本类别""" embeddings = self.app.batch_embedding(texts) X = np.array(embeddings) return self.model.predict(X).tolist()

7.3 文本聚类

from sklearn.cluster import KMeans from sklearn.decomposition import PCA import matplotlib.pyplot as plt class TextClustering: def __init__(self, embedding_app): self.app = embedding_app def cluster(self, texts: List[str], n_clusters: int = 3): """文本聚类""" # 获取嵌入 embeddings = self.app.batch_embedding(texts) X = np.array(embeddings) # 使用KMeans聚类 kmeans = KMeans(n_clusters=n_clusters, random_state=42) labels = kmeans.fit_predict(X) # 降维可视化（可选） if X.shape[1] > 2: pca = PCA(n_components=2) X_2d = pca.fit_transform(X) else: X_2d = X # 绘制结果 plt.figure(figsize=(10, 8)) scatter = plt.scatter(X_2d[:, 0], X_2d[:, 1], c=labels, cmap='viridis', alpha=0.6) plt.colorbar(scatter) plt.title(f"文本聚类结果 (n_clusters={n_clusters})") plt.xlabel("PCA Component 1") plt.ylabel("PCA Component 2") plt.tight_layout() plt.show() return labels

8. 性能调优与监控

要让模型在生产环境中稳定运行，还需要一些监控和调优技巧。

8.1 性能监控脚本

import time import psutil import GPUtil from datetime import datetime import json class PerformanceMonitor: def __init__(self, log_file="performance.log"): self.log_file = log_file self.start_time = time.time() def log_performance(self, operation: str, batch_size: int = 1): """记录性能数据""" # 收集系统信息 gpus = GPUtil.getGPUs() memory = psutil.virtual_memory() log_entry = { "timestamp": datetime.now().isoformat(), "operation": operation, "batch_size": batch_size, "gpu_usage": [{ "id": gpu.id, "name": gpu.name, "memory_used": gpu.memoryUsed, "memory_total": gpu.memoryTotal, "load": gpu.load } for gpu in gpus] if gpus else [], "memory_usage": { "used_gb": memory.used / 1024**3, "total_gb": memory.total / 1024**3, "percent": memory.percent }, "uptime_seconds": time.time() - self.start_time } # 写入日志 with open(self.log_file, 'a') as f: f.write(json.dumps(log_entry) + '\n') return log_entry def analyze_performance(self): """分析性能日志""" try: with open(self.log_file, 'r') as f: logs = [json.loads(line) for line in f] if not logs: return "暂无性能数据" # 计算平均GPU使用率 avg_gpu_load = 0 gpu_count = 0 for log in logs: for gpu in log.get("gpu_usage", []): avg_gpu_load += gpu.get("load", 0) gpu_count += 1 if gpu_count > 0: avg_gpu_load /= gpu_count # 计算平均内存使用 avg_memory_percent = sum( log.get("memory_usage", {}).get("percent", 0) for log in logs ) / len(logs) return { "total_operations": len(logs), "avg_gpu_load": avg_gpu_load, "avg_memory_usage": avg_memory_percent, "first_operation": logs[0]["timestamp"], "last_operation": logs[-1]["timestamp"] } except FileNotFoundError: return "日志文件不存在" # 使用示例 monitor = PerformanceMonitor() # 在关键操作前后记录性能 monitor.log_performance("batch_embedding", batch_size=16) # ... 执行嵌入操作 ... monitor.log_performance("batch_embedding_complete", batch_size=16) # 分析性能 stats = monitor.analyze_performance() print(f"平均GPU负载: {stats['avg_gpu_load']:.2%}") print(f"平均内存使用: {stats['avg_memory_usage']:.1f}%")

8.2 缓存优化

对于重复的查询，可以使用缓存来提高性能：

from functools import lru_cache import hashlib class CachedEmbedding: def __init__(self, embedding_app, max_cache_size=1000): self.app = embedding_app self.max_cache_size = max_cache_size @lru_cache(maxsize=1000) def get_cached_embedding(self, text: str) -> List[float]: """带缓存的嵌入获取""" return self.app.get_embedding(text) def get_embedding_with_cache(self, text: str) -> List[float]: """获取嵌入，自动使用缓存""" # 生成文本的哈希作为缓存键 text_hash = hashlib.md5(text.encode()).hexdigest() # 检查缓存 if hasattr(self, '_cache'): if text_hash in self._cache: return self._cache[text_hash] # 获取新嵌入 embedding = self.app.get_embedding(text) # 更新缓存 if not hasattr(self, '_cache'): self._cache = {} if len(self._cache) >= self.max_cache_size: # 简单的LRU策略：删除第一个键 first_key = next(iter(self._cache)) del self._cache[first_key] self._cache[text_hash] = embedding return embedding def clear_cache(self): """清空缓存""" if hasattr(self, '_cache'): self._cache.clear() self.get_cached_embedding.cache_clear()

9. 常见问题与解决方案

在实际使用中，你可能会遇到一些问题。这里我整理了一些常见问题和解决方法。

9.1 显存不足问题

问题：运行模型时出现CUDA out of memory错误。

解决方案：

1. 减小batch size（参考第5.1节）
2. 使用量化版本模型（参考第5.2节）
3. 启用梯度检查点（如果训练时）
4. 使用CPU模式（速度慢，但显存要求低）

# 使用CPU模式 config = { "model": "nomic-embed-text:v2", "options": { "num_gpu": 0, # 设置为0使用CPU "num_thread": 8 # 使用多线程加速 } }

9.2 速度慢问题

问题：推理速度太慢。

解决方案：

1. 确保使用GPU而不是CPU
2. 适当增加batch size（在显存允许范围内）
3. 使用更快的量化版本（如q4_K_M）
4. 启用CUDA Graph（如果支持）

# 启用CUDA Graph（如果ollama支持） config = { "model": "nomic-embed-text:v2", "options": { "num_gpu": 1, "use_cuda_graph": True # 启用CUDA Graph } }

9.3 安装问题

问题：ollama安装或模型拉取失败。

解决方案：

1. 检查网络连接，特别是访问GitHub和HuggingFace
2. 使用镜像源（如果有）
3. 手动下载模型文件

# 手动下载模型（如果自动拉取失败） # 1. 从HuggingFace下载模型文件 # 2. 放到ollama的模型目录 # 3. 创建Modelfile # 示例Modelfile内容： FROM ./nomic-embed-text-v2.gguf PARAMETER num_gpu 1 PARAMETER num_thread 4

9.4 Gradio界面问题

问题：Gradio界面无法访问或报错。

解决方案：

1. 检查端口是否被占用
2. 检查防火墙设置
3. 更新Gradio到最新版本

# 更换端口 demo.launch(server_port=7861) # 使用7861端口 # 或者指定host demo.launch(server_name="127.0.0.1", server_port=7860)

10. 总结与下一步建议

通过这篇教程，你应该已经掌握了nomic-embed-text-v2-moe模型的完整部署流程，包括：

1. 模型选择：了解了为什么这个模型适合多语言检索任务
2. 环境部署：用ollama一键部署，简单快捷
3. 显存优化：学会了多种优化技巧，让模型在有限资源下也能运行
4. 界面开发：用Gradio构建了可视化推理界面
5. 实际应用：实现了语义搜索、文本分类、文本聚类等实用功能
6. 性能监控：建立了完整的性能监控和调优体系

这个模型的优势很明显：开源免费、多语言支持、性能不错、资源要求相对较低。特别适合中小型项目或者个人开发者使用。

10.1 下一步可以做什么？

如果你已经成功部署并运行了这个模型，我建议你可以尝试：

1. 微调模型：在自己的数据集上微调，让模型更适应你的特定领域
2. 构建生产系统：添加API接口、数据库集成、用户认证等功能
3. 优化性能：尝试模型量化、推理优化、批量处理优化
4. 扩展应用：结合其他AI服务，构建更复杂的应用

10.2 资源推荐

• 官方文档：https://github.com/nomic-ai/nomic-embed-text-v2
• HuggingFace模型：https://huggingface.co/nomic-ai/nomic-embed-text-v2
• Ollama文档：https://github.com/ollama/ollama
• Gradio文档：https://www.gradio.app/docs/

10.3 最后的建议

技术总是在不断进步，今天的最优方案明天可能就有更好的替代。重要的是掌握方法而不是死记步骤。这个部署流程中涉及的很多思路——比如显存优化、性能监控、缓存策略——在其他模型部署时也同样适用。

多动手实践，多尝试不同的配置，多关注社区的最新动态。只有这样，你才能在这个快速发展的领域保持竞争力。

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。