king - man + woman ≈ queen

package com.zhouquan.ai;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
import java.util.*;
/**
* GTE 向量生成示例
* <p>
* 使用 gte-multilingual-base 模型批量生成文本向量
* </p>
*
* @author zhouquan
*/
public class SentenceEmbeddingExample {
// GTE 服務配置
private static final String EMBEDDING_SERVICE_URL = "http://192.168.0.168:5000";
private static final int VECTOR_DIMENSION = 768;
public static void main(String[] args) {
try {
System.out.println("GTE 向量生成示例");
System.out.println("模型: Alibaba-NLP/gte-multilingual-base");
System.out.println("服務地址: " + EMBEDDING_SERVICE_URL);
System.out.println("向量維度: " + VECTOR_DIMENSION);
System.out.println();
// 測試句子
List<String> sentences = Arrays.asList(
"如何學習 Java 編程",
"Java 入門教程",
"今天天氣真好"
);
// 批量文本向量化
System.out.println("【批量文本向量化】");
System.out.println();
List<float[]> embeddings = embedBatchTexts(sentences);
  for (int i = 0; i < sentences.size(); i++) {
  System.out.println("句子: " + sentences.get(i));
  // 向量只打印前五個
  System.out.print("向量: ");
  for (int j = 0; j < Math.min(5, embeddings.get(i).length); j++) {
  System.out.print(embeddings.get(i)[j] + " ");
  }
  System.out.println("向量維度: " + embeddings.get(i).length);
  System.out.println();
  }
  } catch (Exception e) {
  System.err.println("錯誤: " + e.getMessage());
  e.printStackTrace();
  }
  }
  /**
  * 批量文本向量化
  *
  * @param texts 待向量化的文本列表
  * @return 向量列表
  */
  public static List<float[]> embedBatchTexts(List<String> texts) {
    try {
    RestTemplate restTemplate = new RestTemplate();
    String url = EMBEDDING_SERVICE_URL + "/embed_batch";
    // 構建請求
    Map<String, Object> requestBody = new HashMap<>();
      requestBody.put("texts", texts);
      HttpHeaders headers = new HttpHeaders();
      headers.setContentType(MediaType.APPLICATION_JSON);
      HttpEntity<Map<String, Object>> request = new HttpEntity<>(requestBody, headers);
        // 發送請求
        ResponseEntity<Map> response = restTemplate.postForEntity(url, request, Map.class);
          // 解析響應
          Map<String, Object> body = response.getBody();
            if (body == null || !body.containsKey("embeddings")) {
            throw new RuntimeException("響應數據為空");
            }
            List<List<Double>> embeddings = (List<List<Double>>) body.get("embeddings");
              List<float[]> result = new ArrayList<>();
                for (List<Double> embedding : embeddings) {
                  result.add(convertToFloatArray(embedding));
                  }
                  return result;
                  } catch (Exception e) {
                  throw new RuntimeException("批量文本向量化失敗: " + e.getMessage(), e);
                  }
                  }
                  /**
                  * 將 List<Double> 轉換為 float[]
                    */
                    private static float[] convertToFloatArray(List<Double> list) {
                      float[] array = new float[list.size()];
                      for (int i = 0; i < list.size(); i++) {
                      array[i] = list.get(i).floatValue();
                      }
                      return array;
                      }
                      }

GTE 向量生成示例
模型: Alibaba-NLP/gte-multilingual-base
服務地址: http://192.168.0.168:5000
向量維度: 768
【批量文本向量化】
句子: 如何學習 Java 編程
向量: 0.026278736 -0.027642524 -0.11199176 -0.052430928 0.050870888 向量維度: 768
句子: Java 入門教程
向量: -0.014897345 0.011146749 -0.091105774 -0.050095912 0.012215903 向量維度: 768
句子: 今天天氣真好
向量: -0.030632775 0.057086878 -0.06665294 -0.026957892 -0.02842947 向量維度: 768

公式：
cosine_similarity(A, B) = (A · B) / (||A|| × ||B||)
其中：
• A · B = 點積 = A₀×B₀ + A₁×B₁ + A₂×B₂ + ... + A₇₆₇×B₇₆₇
• ||A|| = 向量A的模長 = √(A₀² + A₁² + A₂² + ... + A₇₆₇²)
• ||B|| = 向量B的模長 = √(B₀² + B₁² + B₂² + ... + B₇₆₇²)

/**
* 計算餘弦相似度
*
* @param vec1 向量1
* @param vec2 向量2
* @return 相似度值 (0-1之間，越大越相似)
*/
public static double cosineSimilarity(float[] vec1, float[] vec2) {
// 初始化三個累加器
double dotProduct = 0.0;  // 點積：A·B
double norm1 = 0.0;        // ||A||²
double norm2 = 0.0;        // ||B||²
// 遍歷所有維度（768維）
for (int i = 0; i < vec1.length; i++) {
dotProduct += vec1[i] * vec2[i];    // 累加點積
norm1 += vec1[i] * vec1[i];         // 累加A的平方和
norm2 += vec2[i] * vec2[i];         // 累加B的平方和
}
// 返回餘弦相似度
return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
}

euclidean_distance(A, B) = sqrt(Σ(Ai - Bi)²)

/**
* 計算歐氏距離
*
* @param vec1 向量1 (768維)
* @param vec2 向量2 (768維)
* @return 歐氏距離值 (範圍: [0, ∞), 0表示完全相同)
*/
public static double euclideanDistance(float[] vec1, float[] vec2) {
if (vec1.length != vec2.length) {
throw new IllegalArgumentException("向量維度不匹配");
}
double sumSquaredDiff = 0.0;  // 差值平方和
// 遍歷所有維度（768維）
for (int i = 0; i < vec1.length; i++) {
double diff = vec1[i] - vec2[i];        // 計算差值
sumSquaredDiff += diff * diff;           // 累加差值平方
}
// 返回平方根
return Math.sqrt(sumSquaredDiff);
}
/**
* 歸一化歐氏距離（範圍轉換為 [0, 1]）
*
* @param vec1 向量1
* @param vec2 向量2
* @return 歸一化後的距離 (0表示相同, 1表示最遠)
*/
public static double normalizedEuclideanDistance(float[] vec1, float[] vec2) {
double distance = euclideanDistance(vec1, vec2);
// 對於單位向量，最大距離是 √2
double maxDistance = Math.sqrt(2.0);
return distance / maxDistance;
}
/**
* 將歐氏距離轉換為相似度 (範圍: [0, 1])
*
* @param vec1 向量1
* @param vec2 向量2
* @return 相似度 (1表示相同, 0表示最遠)
*/
public static double euclideanSimilarity(float[] vec1, float[] vec2) {
double distance = euclideanDistance(vec1, vec2);
// 使用公式: similarity = 1 / (1 + distance)
return 1.0 / (1.0 + distance);
}

代數定義：
dot_product(A, B) = Σ(Aᵢ × Bᵢ)
展開形式：
A · B = A₀×B₀ + A₁×B₁ + A₂×B₂ + ... + A₇₆₇×B₇₆₇
幾何定義：
A · B = ||A|| × ||B|| × cos(θ)
其中：
• ||A|| = 向量 A 的長度（模長）
• ||B|| = 向量 B 的長度（模長）
• θ = 向量 A 和 B 之間的夾角

/**
* 計算點積（內積）
*
* @param vec1 向量1 (768維)
* @param vec2 向量2 (768維)
* @return 點積值 (範圍: (-∞, +∞))
*/
public static double dotProduct(float[] vec1, float[] vec2) {
if (vec1.length != vec2.length) {
throw new IllegalArgumentException("向量維度不匹配");
}
double result = 0.0;
// 遍歷所有維度（768維）- 最簡單高效的計算
for (int i = 0; i < vec1.length; i++) {
result += vec1[i] * vec2[i];  // 只需乘法和加法
}
return result;
}
/**
* 點積與餘弦相似度的關係
* cosine = dotProduct / (||A|| × ||B||)
*/
public static double cosineSimilarityFromDotProduct(float[] vec1, float[] vec2) {
double dot = dotProduct(vec1, vec2);
double norm1 = Math.sqrt(dotProduct(vec1, vec1));  // ||A|| = √(A·A)
double norm2 = Math.sqrt(dotProduct(vec2, vec2));  // ||B|| = √(B·B)
return dot / (norm1 * norm2);
}
/**
* 對於歸一化向量，點積就等於餘弦相似度
* 因為 ||A|| = ||B|| = 1
*/
public static double dotProductNormalized(float[] vec1, float[] vec2) {
// 假設向量已經歸一化
// 此時 dot(A, B) = ||A|| × ||B|| × cos(θ) = 1 × 1 × cos(θ) = cos(θ)
return dotProduct(vec1, vec2);
}
/**
* 使用 SIMD 優化的點積（性能優化版本）
* 實際生產中可以使用 Java Vector API (JDK 16+)
*/
public static double dotProductOptimized(float[] vec1, float[] vec2) {
double sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;  // 4路並行累加
int i = 0;
int limit = vec1.length - 3;
// 循環展開，利用 CPU 流水線
for (; i < limit; i += 4) {
sum0 += vec1[i] * vec2[i];
sum1 += vec1[i+1] * vec2[i+1];
sum2 += vec1[i+2] * vec2[i+2];
sum3 += vec1[i+3] * vec2[i+3];
}
// 處理剩餘元素
for (; i < vec1.length; i++) {
sum0 += vec1[i] * vec2[i];
}
return sum0 + sum1 + sum2 + sum3;
}

PUT /my_index
{
"mappings": {
"properties": {
"title": {
"type": "text"
},
"content": {
"type": "text"
},
"title_vector": {
"type": "dense_vector",
"dims": 768,
"index": true,
"similarity": "cosine"
},
"content_vector": {
"type": "dense_vector",
"dims": 768,
"index": true,
"similarity": "cosine"
}
}
}
}

POST /my_index/_doc
{
"title": "Python 數據分析實戰",
"content": "本課程將介紹如何使用 Python 進行數據分析，包括 NumPy、Pandas、Matplotlib 等庫的使用，從數據清洗到可視化，帶你掌握數據分析的核心技能。",
"title_vector": [    -0.0208999402821064,
0.01331911701709032,
-0.06355377286672592
...
],
"content_vector":  [-0.03954795375466347,
0.007010910660028458,
-0.07348231226205826,
...
]
}
POST /my_index/_doc
{
"title": "機器學習基礎",
"content": "機器學習是人工智能的一個分支，它使計算機能夠學習而不需要明確編程。本課程將從監督學習、無監督學習等基礎概念講起，帶你進入機器學習的世界。",
"title_vector": [ -0.013987698592245579,
-0.0579521618783474,
-0.08713562786579132
],
"content_vector": [ -0.030959052965044975,
-0.042195241898298264,
-0.0682775005698204,
...
]
}
POST /my_index/_doc
{
"title": "Elasticsearch 分佈式搜索",
"content": "Elasticsearch 是一個基於 Lucene 的分佈式搜索引擎，它提供了一個分佈式多用户能力的全文搜索引擎，具有高可用性、高擴展性和實時性。",
"title_vector": [ -0.08578959107398987,
0.02684123069047928,
-0.03178650140762329,
...
],
"content_vector": [
-0.09641386568546295,
0.017185380682349205,
-0.004696432966738939,
...
]
}

POST /my_index/_search
{
"_source": ["title", "content"],
"knn": {
"field": "title_vector",
"query_vector": [   // machine learning
0.008781400509178638,
-0.050233472138643265,
-0.050182443112134933
...
],
"k": 2,
"num_candidates": 4
}
}

POST /my_index/_search
{
"knn": {
"field": "content_vector",
"query_vector": [0.1, 0.2, 0.3, ...],
"k": 10,
"num_candidates": 100,
"filter": {
"term": {
"category": "技術文檔"
}
}
}
}

應用程序 → 向量化服務 → Elasticsearch
         ↓
    [批量處理隊列]

/**
* 批量將文本轉換為向量
* <p>
* 支持自動重試機制，最多重試3次，採用指數退避策略。
* </p>
*
* @param texts 待向量化的文本列表
* @return 向量列表
*/
public List<float[]> embedTexts(List<String> texts) {
if (texts == null || texts.isEmpty()) {
return new ArrayList<>();
  }
  int maxRetries = 3;
  int retryDelay = 1000; // 初始延遲 1秒
  for (int attempt = 1; attempt <= maxRetries; attempt++) {
  try {
  String url = appConfig.getEmbeddingServiceUrl() + "/embed_batch";
  log.info("[向量化] 調用本地 embedding 服務: {}, 文本數量: {}, 嘗試次數: {}/{}",
  url, texts.size(), attempt, maxRetries);
  // 計算請求大小
  long totalChars = texts.stream().mapToLong(String::length).sum();
  log.debug("[向量化] 請求文本總字符數: {}", totalChars);
  // 構建請求體
  Map<String, Object> requestBody = new HashMap<>();
    requestBody.put("texts", texts);
    // 設置請求頭
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_JSON);
    headers.set("Connection", "keep-alive");
    HttpEntity<Map<String, Object>> request = new HttpEntity<>(requestBody, headers);
      // 發送 POST 請求
      ResponseEntity<EmbedBatchResponse> response = restTemplate.postForEntity(
        url,
        request,
        EmbedBatchResponse.class
        );
        EmbedBatchResponse body = response.getBody();
        if (body == null || body.getEmbeddings() == null || body.getEmbeddings().isEmpty()) {
        log.error("[向量化] 向量化服務返回結果為空");
        throw new RuntimeException("向量化服務返回結果為空");
        }
        log.info("[向量化] 成功，返回 {} 個向量，維度: {}", body.getCount(), body.getDimension());
        // 將 List<List<Double>> 轉換為 List<float[]>
          List<float[]> result = new ArrayList<>();
            for (List<Double> embedding : body.getEmbeddings()) {
              float[] floatArray = new float[embedding.size()];
              for (int i = 0; i < embedding.size(); i++) {
              floatArray[i] = embedding.get(i).floatValue();
              }
              result.add(floatArray);
              }
              return result;
              } catch (ResourceAccessException e) {
              if (attempt == maxRetries) {
              log.error("[向量化] 失敗，已達最大重試次數 {}", maxRetries, e);
              throw new RuntimeException("批量文本向量化失敗（連接錯誤）: " + e.getMessage() +
              "。請檢查向量化服務是否正常運行: " + appConfig.getEmbeddingServiceUrl(), e);
              }
              log.warn("[向量化] 第 {} 次嘗試失敗（連接錯誤），{}ms 後重試: {}",
              attempt, retryDelay, e.getMessage());
              try {
              Thread.sleep(retryDelay);
              retryDelay *= 2; // 指數退避
              } catch (InterruptedException ie) {
              Thread.currentThread().interrupt();
              throw new RuntimeException("重試被中斷", ie);
              }
              } catch (Exception e) {
              log.error("[向量化] 失敗，文本數量: {}", texts.size(), e);
              throw new RuntimeException("批量文本向量化失敗: " + e.getMessage(), e);
              }
              }
              throw new RuntimeException("批量文本向量化失敗：未知錯誤");
              }

PUT _ml/trained_models/sentence-transformers
{
"input": {
"field_names": ["text"]
},
"inference_config": {
"text_embedding": {}
}
}

PUT _ingest/pipeline/text-embeddings
{
"description": "Text embedding pipeline",
"processors": [
{
"inference": {
"model_id": "sentence-transformers",
"target_field": "text_embedding",
"field_map": {
"content": "text"
}
}
}
]
}

POST /my_index/_doc?pipeline=text-embeddings
{
"content": "這是一段需要向量化的文本"
}

POST /my_index/_search
{
"query": {
"bool": {
"should": [
{
"match": {
"content": {
"query": "Elasticsearch 教程",
"boost": 1.0
}
}
}
]
}
},
"knn": {
"field": "content_vector",
"query_vector": [0.1, 0.2, ...],
"k": 10,
"num_candidates": 100,
"boost": 2.0
}
}

{
"query": {
"match": {
"title": {
"query": "iPhone 15 Pro",
"boost": 3.0
}
}
},
"knn": {
"field": "description_vector",
"query_vector": [...],
"k": 10,
"num_candidates": 100,
"boost": 1.0
}
}

{
"query": {
"match": {
"content": {
"query": "如何提升代碼質量",
"boost": 0.5
}
}
},
"knn": {
"field": "content_vector",
"query_vector": [...],
"k": 10,
"num_candidates": 100,
"boost": 3.0
}
}