EmbeddingGemma-300m入门：手把手教你做文本分类

EmbeddingGemma-300m入门：手把手教你做文本分类

1. 引言：为什么你需要EmbeddingGemma？

如果你正在处理文本数据，比如用户评论、新闻文章或者客服对话，你肯定遇到过这样的问题：怎么才能让计算机理解这些文字，并自动把它们分门别类？

传统方法要么依赖复杂的规则，要么需要庞大的模型在云端运行，既费时又费钱。今天，我要给你介绍一个游戏规则的改变者——EmbeddingGemma-300m。

这是一个只有3亿参数的“小个子”，但它干起活来却像个“大力士”。最棒的是，它小到可以直接在你的笔记本电脑甚至手机上运行，不需要连接网络，你的数据完全安全。想象一下，你可以用它来：

• 自动给电商评论打上“好评”、“中评”、“差评”的标签
• 把新闻文章自动归类到“科技”、“体育”、“娱乐”等板块
• 识别客服对话中的紧急程度，优先处理用户投诉

这篇文章，我会手把手地带你从零开始，用EmbeddingGemma-300m搭建一个完整的文本分类系统。你不需要是AI专家，只要会一点Python，就能跟着我一起做。

2. 环境准备：5分钟快速部署

2.1 理解EmbeddingGemma的核心

在动手之前，我们先花一分钟搞清楚EmbeddingGemma是干什么的。简单来说，它是个“文本翻译官”。

它能把一段文字（比如“这个手机拍照真清晰”）转换成一串数字（我们叫它“向量”或“嵌入”）。这串数字就像是这段文字的“数字指纹”，包含了它的核心含义。语义相近的文字，它们的“数字指纹”也会很接近。

我们的文本分类任务，就是先让EmbeddingGemma把所有文本都转换成“数字指纹”，然后训练一个简单的分类器，学会哪种“指纹”对应哪种标签。

2.2 一键获取与部署

得益于CSDN星图镜像广场，部署变得极其简单。我们使用的是基于Ollama的embeddinggemma-300m镜像。

方法一：通过CSDN星图镜像广场（推荐）这是最省事的方法，适合绝大多数开发者。

1. 访问 CSDN星图镜像广场。
2. 在搜索框中输入embeddinggemma-300m或ollama进行查找。
3. 找到名为【ollama】embeddinggemma-300m的镜像。
4. 点击“一键部署”或类似按钮，按照引导完成环境创建。平台会自动为你配置好所需的运行环境。

方法二：本地通过Ollama部署（适合进阶用户）如果你已经在本地安装了Ollama，可以通过命令行快速拉取并运行：

# 拉取embeddinggemma-300m模型 ollama pull embeddinggemma-300m # 运行模型服务 ollama run embeddinggemma-300m

运行后，Ollama会在本地启动一个API服务（默认端口11434），等待我们调用。

2.3 验证服务是否正常

部署完成后，我们需要确认模型服务已经就绪。打开你的浏览器或使用命令行工具（如curl）进行测试。

如果你通过CSDN星图镜像部署，通常平台会提供一个Web UI访问地址。打开后，你应该能看到一个简单的界面。

使用Python进行验证：创建一个简单的Python脚本test_connection.py：

import requests import json # 假设你的Ollama服务地址是下面这个（根据你的实际部署情况修改） OLLAMA_API_URL = "http://localhost:11434/api/embeddings" # 准备请求数据 payload = { "model": "embeddinggemma-300m", "prompt": "Hello, EmbeddingGemma!" } try: response = requests.post(OLLAMA_API_URL, json=payload) if response.status_code == 200: result = response.json() embedding = result.get("embedding") print(" 连接成功！") print(f"生成的向量维度：{len(embedding)}") print(f"向量前5个值：{embedding[:5]}") else: print(f" 请求失败，状态码：{response.status_code}") print(response.text) except Exception as e: print(f" 连接异常：{e}")

运行这个脚本，如果看到输出了向量的维度和前几个数值，恭喜你，环境搭建成功！

3. 实战第一步：构建文本分类数据集

任何机器学习项目都始于数据。为了让教程更贴近实际，我们创建一个模拟的“电商产品评论”数据集，目标是自动将评论分类为电子产品、服装、食品和家居。

3.1 创建模拟数据集

我们将用Python快速生成一个包含400条评论的小数据集，每条评论都有对应的类别标签。

import pandas as pd import numpy as np # 设定随机种子，确保每次生成的数据一样 np.random.seed(42) # 定义类别和对应的关键词/句式 categories = { "电子产品": [ "电池续航", "屏幕清晰度", "运行速度", "拍照效果", "系统流畅", "充电速度", "指纹解锁", "内存大小", "玩游戏卡顿", "音质好坏" ], "服装": [ "面料舒适", "尺码标准", "颜色色差", "做工细节", "款式设计", "透气性好", "是否起球", "厚度合适", "洗涤后变形", "穿着体验" ], "食品": [ "口感味道", "新鲜程度", "包装完好", "甜度适中", "香气浓郁", "配料干净", "生产日期", "分量足不足", "回购多次", "孩子爱吃" ], "家居": [ "安装简便", "材质结实", "设计美观", "储物空间", "颜色搭配", "没有异味", "尺寸合适", "实用性高", "清洁方便", "性价比高" ] } # 生成评论的模板函数 def generate_review(category, keywords): templates = [ f"这款产品的{np.random.choice(keywords)}非常出色，值得推荐。", f"总体来说不错，但{np.random.choice(keywords)}还有提升空间。", f"对{np.random.choice(keywords)}很满意，符合我的预期。", f"不太满意，感觉{np.random.choice(keywords)}比较一般。", f"{np.random.choice(keywords)}是最大的亮点，其他方面中规中矩。" ] return np.random.choice(templates) # 生成数据 data = [] for category, keywords in categories.items(): for _ in range(100): # 每个类别100条 review = generate_review(category, keywords) data.append({"text": review, "label": category}) # 创建DataFrame并打乱顺序 df = pd.DataFrame(data) df = df.sample(frac=1, random_state=42).reset_index(drop=True) # 查看数据 print("数据集预览：") print(df.head()) print(f"\n数据集形状：{df.shape}") print("类别分布：") print(df['label'].value_counts()) # 保存到CSV文件（可选） df.to_csv("product_reviews.csv", index=False, encoding='utf-8-sig') print("\n 数据集已生成并保存为 'product_reviews.csv'")

运行这段代码，你会得到一个包含400条评论的CSV文件，数据已经打乱，适合直接用于训练。

3.2 数据探索与理解

在投入训练前，花几分钟看看你的数据长什么样总是好的。

import matplotlib.pyplot as plt # 统计评论长度 df['text_length'] = df['text'].apply(len) print("评论长度统计：") print(df['text_length'].describe()) # 绘制类别分布图 plt.figure(figsize=(10, 5)) plt.subplot(1, 2, 1) df['label'].value_counts().plot(kind='bar', color='skyblue') plt.title('评论类别分布') plt.xlabel('类别') plt.ylabel('数量') # 绘制评论长度分布图 plt.subplot(1, 2, 2) plt.hist(df['text_length'], bins=20, color='lightcoral', edgecolor='black') plt.title('评论长度分布') plt.xlabel('字符数') plt.ylabel('频次') plt.tight_layout() plt.show()

这个步骤能帮你发现潜在问题，比如某个类别的数据太少，或者评论长度差异过大。

4. 核心环节：用EmbeddingGemma生成文本向量

这是整个流程的灵魂所在。我们将调用部署好的EmbeddingGemma服务，把每一条文本评论转换成高维向量。

4.1 编写向量生成函数

我们需要一个函数，能够稳定、高效地调用Ollama API，并将文本转化为向量。

import requests import time from typing import List import logging # 设置日志 logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) class EmbeddingGenerator: def __init__(self, api_url: str = "http://localhost:11434/api/embeddings", model: str = "embeddinggemma-300m"): self.api_url = api_url self.model = model def get_embedding(self, text: str, max_retries: int = 3) -> List[float]: """ 获取单条文本的嵌入向量 """ payload = { "model": self.model, "prompt": text } for attempt in range(max_retries): try: response = requests.post(self.api_url, json=payload, timeout=30) if response.status_code == 200: result = response.json() return result.get("embedding", []) else: logger.warning(f"请求失败，状态码：{response.status_code}，尝试重试 ({attempt+1}/{max_retries})") time.sleep(1) # 等待1秒后重试 except requests.exceptions.RequestException as e: logger.warning(f"网络异常：{e}，尝试重试 ({attempt+1}/{max_retries})") time.sleep(2) logger.error(f"获取文本嵌入失败：{text[:50]}...") return [] # 返回空列表，后续处理 def batch_get_embeddings(self, texts: List[str], batch_size: int = 10, delay: float = 0.1) -> List[List[float]]: """ 批量获取文本嵌入向量，加入延迟避免请求过载 """ all_embeddings = [] total = len(texts) for i in range(0, total, batch_size): batch = texts[i:i+batch_size] batch_embeddings = [] for text in batch: embedding = self.get_embedding(text) if embedding: # 只添加成功的 batch_embeddings.append(embedding) time.sleep(delay) # 请求间延迟 all_embeddings.extend(batch_embeddings) # 打印进度 processed = min(i + batch_size, total) logger.info(f"处理进度：{processed}/{total} ({processed/total*100:.1f}%)") return all_embeddings # 使用示例 if __name__ == "__main__": # 初始化生成器 generator = EmbeddingGenerator() # 测试单条文本 test_text = "这款手机的电池续航能力很强，屏幕也很清晰。" embedding = generator.get_embedding(test_text) print(f"测试文本：{test_text}") print(f"向量维度：{len(embedding)}") print(f"向量前5个值：{embedding[:5]}")

4.2 为整个数据集生成向量

现在，让我们用这个类来处理之前创建的所有评论数据。

# 加载之前创建的数据集 df = pd.read_csv("product_reviews.csv") # 初始化嵌入生成器 embedding_gen = EmbeddingGenerator() # 提取文本列表 texts = df['text'].tolist() labels = df['label'].tolist() print(f"开始为 {len(texts)} 条评论生成嵌入向量...") start_time = time.time() # 批量生成嵌入向量（这里为了演示，先处理前50条，实际使用时可以处理全部） sample_texts = texts[:50] # 先处理50条作为演示 sample_labels = labels[:50] embeddings = embedding_gen.batch_get_embeddings(sample_texts, batch_size=5, delay=0.2) end_time = time.time() print(f" 向量生成完成！耗时：{end_time - start_time:.2f}秒") print(f"成功生成 {len(embeddings)} 个向量") # 检查向量维度是否一致 if embeddings: dim = len(embeddings[0]) print(f"向量统一维度：{dim}") # 可以检查是否所有向量维度相同 all_same_dim = all(len(emb) == dim for emb in embeddings) print(f"所有向量维度一致：{all_same_dim}")

重要提示：在实际项目中，如果你的数据集很大（比如上万条），批量处理所有数据可能需要较长时间。建议：

1. 先在小样本上（如100-200条）跑通整个流程。
2. 使用batch_size和delay参数控制请求频率，避免压垮服务。
3. 考虑将生成的向量保存到文件，避免重复计算。

# 保存生成的向量和标签，供后续使用 import pickle # 构建保存的数据结构 data_to_save = { 'embeddings': embeddings, 'labels': sample_labels, 'texts': sample_texts } with open('embeddings_data.pkl', 'wb') as f: pickle.dump(data_to_save, f) print(" 向量数据已保存到 'embeddings_data.pkl'")

5. 训练分类模型：让机器学习识别模式

现在我们有了文本的“数字指纹”（向量）和对应的标签，下一步就是训练一个分类器，让它学会根据“指纹”判断类别。

我们将使用经典的机器学习算法——支持向量机（SVM）和随机森林（Random Forest）来演示，并比较它们的效果。

5.1 准备训练数据

首先，加载我们保存的向量数据，并将其划分为训练集和测试集。

import pickle from sklearn.model_selection import train_test_split from sklearn.preprocessing import LabelEncoder # 加载之前保存的向量数据 with open('embeddings_data.pkl', 'rb') as f: data = pickle.load(f) embeddings = data['embeddings'] labels = data['labels'] texts = data['texts'] print(f"加载数据：{len(embeddings)} 个样本") # 将文本标签转换为数字（机器学习模型需要数字输入） label_encoder = LabelEncoder() encoded_labels = label_encoder.fit_transform(labels) print("类别编码映射：") for i, class_name in enumerate(label_encoder.classes_): print(f" {class_name} -> {i}") # 划分训练集和测试集（80%训练，20%测试） X_train, X_test, y_train, y_test, texts_train, texts_test = train_test_split( embeddings, encoded_labels, texts, test_size=0.2, random_state=42, stratify=encoded_labels ) print(f"\n数据划分结果：") print(f" 训练集样本数：{len(X_train)}") print(f" 测试集样本数：{len(X_test)}")

5.2 训练与评估SVM分类器

支持向量机在小样本、高维数据上通常表现不错，很适合我们现在的场景。

from sklearn.svm import SVC from sklearn.metrics import classification_report, confusion_matrix, accuracy_score import seaborn as sns # 初始化SVM分类器（使用线性核，适合高维数据） svm_classifier = SVC(kernel='linear', random_state=42) print("开始训练SVM分类器...") svm_classifier.fit(X_train, y_train) print(" SVM训练完成！") # 在测试集上进行预测 y_pred_svm = svm_classifier.predict(X_test) # 评估性能 accuracy_svm = accuracy_score(y_test, y_pred_svm) print(f"\nSVM分类器准确率：{accuracy_svm:.4f}") # 详细的分类报告 print("\n分类报告（SVM）：") print(classification_report(y_test, y_pred_svm, target_names=label_encoder.classes_)) # 可视化混淆矩阵 cm_svm = confusion_matrix(y_test, y_pred_svm) plt.figure(figsize=(8, 6)) sns.heatmap(cm_svm, annot=True, fmt='d', cmap='Blues', xticklabels=label_encoder.classes_, yticklabels=label_encoder.classes_) plt.title('SVM分类器混淆矩阵') plt.ylabel('真实标签') plt.xlabel('预测标签') plt.tight_layout() plt.show()

5.3 训练与评估随机森林分类器

随机森林是另一个强大的算法，让我们看看它的表现如何。

from sklearn.ensemble import RandomForestClassifier # 初始化随机森林分类器 rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42) print("开始训练随机森林分类器...") rf_classifier.fit(X_train, y_train) print(" 随机森林训练完成！") # 在测试集上进行预测 y_pred_rf = rf_classifier.predict(X_test) # 评估性能 accuracy_rf = accuracy_score(y_test, y_pred_rf) print(f"\n随机森林分类器准确率：{accuracy_rf:.4f}") # 详细的分类报告 print("\n分类报告（随机森林）：") print(classification_report(y_test, y_pred_rf, target_names=label_encoder.classes_)) # 比较两个模型的准确率 print("\n模型性能比较：") print(f" SVM准确率：{accuracy_svm:.4f}") print(f" 随机森林准确率：{accuracy_rf:.4f}") print(f" 准确率差异：{abs(accuracy_svm - accuracy_rf):.4f}")

5.4 模型选择与保存

根据测试结果，选择一个表现更好的模型保存下来，供后续使用。

# 选择性能更好的模型 if accuracy_svm >= accuracy_rf: best_classifier = svm_classifier best_model_name = "SVM" print(f"\n选择SVM作为最佳模型，准确率：{accuracy_svm:.4f}") else: best_classifier = rf_classifier best_model_name = "随机森林" print(f"\n选择随机森林作为最佳模型，准确率：{accuracy_rf:.4f}") # 保存整个分类流水线（包括标签编码器和分类器） import joblib pipeline = { 'label_encoder': label_encoder, 'classifier': best_classifier, 'model_name': best_model_name } joblib.dump(pipeline, 'text_classifier_pipeline.joblib') print(" 分类流水线已保存到 'text_classifier_pipeline.joblib'")

6. 构建完整应用：从文本输入到分类结果

现在，我们已经有了训练好的模型和EmbeddingGemma服务，是时候把它们组合成一个完整的、可用的文本分类应用了。

6.1 创建端到端分类函数

这个函数接受一段新的文本，调用EmbeddingGemma生成向量，然后用我们训练好的模型进行预测。

class TextClassifierApp: def __init__(self, embedding_api_url="http://localhost:11434/api/embeddings", model_path='text_classifier_pipeline.joblib'): """ 初始化文本分类应用 """ # 加载训练好的分类流水线 self.pipeline = joblib.load(model_path) self.label_encoder = self.pipeline['label_encoder'] self.classifier = self.pipeline['classifier'] self.model_name = self.pipeline['model_name'] # 初始化嵌入生成器 self.embedding_gen = EmbeddingGenerator(api_url=embedding_api_url) print(f" 文本分类应用初始化完成！") print(f" 使用模型：{self.model_name}") print(f" 支持类别：{list(self.label_encoder.classes_)}") def classify_text(self, text: str, return_probability: bool = False): """ 对单条文本进行分类 """ # 1. 生成文本嵌入向量 embedding = self.embedding_gen.get_embedding(text) if not embedding: return {"error": "无法生成文本向量", "text": text} # 2. 使用分类器进行预测 # 注意：embedding需要是二维数组（即使只有一个样本） embedding_2d = [embedding] if hasattr(self.classifier, 'predict_proba'): probabilities = self.classifier.predict_proba(embedding_2d)[0] predicted_label_encoded = self.classifier.predict(embedding_2d)[0] else: predicted_label_encoded = self.classifier.predict(embedding_2d)[0] probabilities = None # 3. 将数字标签转换回文本标签 predicted_label = self.label_encoder.inverse_transform([predicted_label_encoded])[0] # 4. 构建返回结果 result = { "text": text, "predicted_label": predicted_label, "confidence": None } # 如果有概率信息，添加置信度 if probabilities is not None: confidence = probabilities[predicted_label_encoded] result["confidence"] = float(confidence) # 添加所有类别的概率（可选） result["all_probabilities"] = { self.label_encoder.inverse_transform([i])[0]: float(prob) for i, prob in enumerate(probabilities) } return result def batch_classify(self, texts: List[str]): """ 批量分类文本 """ results = [] for text in texts: result = self.classify_text(text) results.append(result) return results # 测试完整应用 if __name__ == "__main__": # 初始化应用 app = TextClassifierApp() # 测试一些新的评论 test_texts = [ "手机电池用一天没问题，屏幕显示效果很棒。", "衣服面料很舒服，就是尺码有点偏大。", "饼干口感酥脆，甜度刚好，孩子很喜欢。", "书架安装简单，材质很厚实，能放很多书。", "这个软件运行速度很快，界面设计也很美观。" # 这个可能不太好分类 ] print("\n 开始测试文本分类应用：") for text in test_texts: result = app.classify_text(text, return_probability=True) print(f"\n文本：{text}") print(f"预测类别：{result['predicted_label']}") if result.get('confidence'): print(f"置信度：{result['confidence']:.2%}") # 如果有错误信息，打印出来 if 'error' in result: print(f"错误：{result['error']}")

6.2 创建简单的Web界面（可选）

如果你想让非技术人员也能使用这个分类器，可以创建一个简单的Web界面。这里使用Flask框架创建一个最小化的Web应用。

# 文件：app.py from flask import Flask, request, jsonify, render_template_string import json # 假设上面的TextClassifierApp类在同一个文件或已导入 # from your_module import TextClassifierApp app = Flask(__name__) # 初始化分类器应用 classifier_app = TextClassifierApp() # 简单的HTML模板 HTML_TEMPLATE = ''' <!DOCTYPE html> <html> <head> <title>文本分类器</title> <style> body { font-family: Arial, sans-serif; max-width: 800px; margin: 40px auto; padding: 20px; } .container { background: #f5f5f5; padding: 20px; border-radius: 10px; } textarea { width: 100%; height: 100px; margin: 10px 0; padding: 10px; } button { background: #4CAF50; color: white; padding: 10px 20px; border: none; border-radius: 5px; cursor: pointer; } .result { margin-top: 20px; padding: 15px; background: white; border-radius: 5px; } .label { font-weight: bold; color: #2196F3; } .confidence { color: #4CAF50; } </style> </head> <body> <div class="container"> <h1>🔤 文本分类器</h1> <p>输入一段文本，系统会自动判断它属于哪个类别。</p> <form id="classifyForm"> <textarea name="text" placeholder="请输入要分类的文本...">{{ text if text else '' }}</textarea> <br> <button type="submit">开始分类</button> </form> {% if result %} <div class="result"> <h3>分类结果：</h3> <p><strong>输入文本：</strong> {{ result.text }}</p> <p><strong>预测类别：</strong> <span class="label">{{ result.predicted_label }}</span></p> {% if result.confidence %} <p><strong>置信度：</strong> <span class="confidence">{{ "%.1f"|format(result.confidence*100) }}%</span></p> {% endif %} </div> {% endif %} <div style="margin-top: 30px; font-size: 0.9em; color: #666;"> <p><strong>支持的类别：</strong> {{ categories|join(', ') }}</p> <p><strong>当前模型：</strong> {{ model_name }}</p> </div> </div> </body> </html> ''' @app.route('/', methods=['GET', 'POST']) def index(): result = None text = "" if request.method == 'POST': text = request.form.get('text', '') if text: result = classifier_app.classify_text(text, return_probability=True) return render_template_string( HTML_TEMPLATE, text=text, result=result, categories=list(classifier_app.label_encoder.classes_), model_name=classifier_app.model_name ) @app.route('/api/classify', methods=['POST']) def api_classify(): """提供JSON API接口""" data = request.get_json() if not data or 'text' not in data: return jsonify({'error': '请提供text参数'}), 400 text = data['text'] result = classifier_app.classify_text(text, return_probability=True) return jsonify(result) if __name__ == '__main__': print("启动文本分类Web应用...") print("请在浏览器中访问：http://localhost:5000") app.run(debug=True, host='0.0.0.0', port=5000)

要运行这个Web应用，只需要执行：

python app.py

然后在浏览器中打开http://localhost:5000，你就可以看到一个简单的界面，输入文本，点击按钮，就能看到分类结果了。

7. 总结与进阶建议

7.1 回顾学习成果

恭喜你！通过这篇教程，你已经完成了一个完整的端到端文本分类项目：

1. 理解了EmbeddingGemma的核心价值：一个轻量但强大的文本嵌入模型，能将文本转换为有意义的数字向量。
2. 掌握了快速部署方法：通过CSDN星图镜像广场或Ollama，几分钟内就能让模型服务跑起来。
3. 学会了数据处理：创建、探索和准备文本数据集。
4. 实践了核心流程：调用EmbeddingGemma API生成文本向量。
5. 训练了分类模型：使用SVM和随机森林算法，并评估了它们的性能。
6. 构建了完整应用：将各个环节串联，创建了可用的分类器，甚至还有一个Web界面。

7.2 优化与进阶方向

你现在拥有的是一个可工作的原型。要让它在实际项目中表现更好，可以考虑以下优化方向：

1. 数据质量提升

• 收集更多真实数据：模拟数据有局限性，尽可能收集真实的业务数据。
• 数据清洗：去除无关字符、处理缩写、统一术语。
• 数据增强：对现有数据稍作修改（如同义词替换），生成更多训练样本。

2. 模型优化

• 尝试更多算法：逻辑回归、梯度提升树（如XGBoost、LightGBM）可能表现更好。
• 调整超参数：使用网格搜索（GridSearchCV）寻找最优参数组合。
• 集成学习：结合多个模型的预测结果，提升稳定性和准确率。

3. 工程化改进

• 向量缓存：将常见文本的向量结果缓存起来，避免重复计算。
• 批量处理优化：实现真正的异步批量请求，提高处理效率。
• 服务监控：添加日志、性能监控和异常报警。

4. 探索EmbeddingGemma高级特性

• 多语言支持：EmbeddingGemma支持100+种语言，尝试处理多语言文本。
• 维度调整：根据你的硬件条件，尝试使用更低维度（如256维）的向量，在性能和速度间取得平衡。
• 任务提示模板：EmbeddingGemma支持为不同任务（检索、聚类、分类）使用不同的提示模板，可以尝试优化提示词来提升特定任务的效果。

7.3 实际应用场景扩展

你构建的这个文本分类框架可以轻松适配到各种实际场景：

• 情感分析：将标签改为“正面”、“中性”、“负面”，分析用户评论情感。
• 意图识别：在客服系统中，识别用户是“咨询”、“投诉”还是“售后”。
• 内容审核：自动识别违规、广告或垃圾内容。
• 新闻分类：将新闻自动归类到不同的频道或板块。
• 简历筛选：根据职位描述，自动分类和筛选匹配的简历。

7.4 最后的建议

开始总是最难的，但你已经跨出了最重要的一步。我建议你：

1. 先用起来：在你自己的一个小项目中使用这个分类器，哪怕只是处理个人文档。
2. 从小处改进：不要试图一次性完善所有方面，每次改进一个小点。
3. 记录过程：记录下你遇到的问题和解决方案，这会成为你宝贵的经验。
4. 分享交流：将你的成果和经验分享给他人，教学相长。

EmbeddingGemma这样的轻量级模型正在让AI技术变得更加平民化。你现在拥有的，不仅是一个文本分类工具，更是一把打开更多AI应用大门的钥匙。下一步，你可以尝试用它构建一个简单的搜索引擎，或者一个智能文档管理系统。可能性只受限于你的想象力。

获取更多AI镜像

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