File size: 5,706 Bytes
5e028bf | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 | from __future__ import annotations
from http import HTTPStatus
from typing import Any, Dict, List, Optional, Union
import dashscope
import tiktoken
from lightmem.configs.text_embedder.base_config import BaseTextEmbedderConfig
class _FallbackTokenizer:
def encode(self, text: str):
return str(text).split()
class TextEmbedderDashScope:
def __init__(self, config: Optional[BaseTextEmbedderConfig] = None):
self.config = config or BaseTextEmbedderConfig()
self.model = getattr(self.config, "model", None) or "text-embedding-v4"
self.model_kwargs: Dict[str, Any] = dict(getattr(self.config, "model_kwargs", None) or {})
self.default_text_type = self.model_kwargs.get("text_type", "document")
self.batch_size = int(self.model_kwargs.get("batch_size", 10))
self.total_calls = 0
self.total_tokens = 0
try:
self.tokenizer = tiktoken.get_encoding("o200k_base")
except Exception:
self.tokenizer = _FallbackTokenizer()
api_key = getattr(self.config, "api_key", None)
if api_key:
dashscope.api_key = api_key
base_http_api_url = self.model_kwargs.get("base_http_api_url")
if base_http_api_url:
dashscope.base_http_api_url = base_http_api_url
@classmethod
def from_config(cls, config: BaseTextEmbedderConfig):
return cls(config)
@classmethod
def probe_dimensions(cls, config: Optional[BaseTextEmbedderConfig] = None, probe_text: str = "dimension probe") -> int:
embedder = cls(config=config)
embedding = embedder.embed(probe_text)
return len(embedding)
def _build_params(self, text_type: Optional[str]) -> Dict[str, Any]:
params: Dict[str, Any] = {"model": self.model}
dimension = getattr(self.config, "embedding_dims", None)
if dimension:
params["dimension"] = dimension
effective_text_type = text_type or self.default_text_type
if effective_text_type:
params["text_type"] = effective_text_type
for key in ("output_type", "instruct"):
value = self.model_kwargs.get(key)
if value is not None:
params[key] = value
return params
def _extract_usage_tokens(self, response: Any) -> int:
usage = getattr(response, "usage", None)
if usage is None and isinstance(response, dict):
usage = response.get("usage")
if usage is None:
return 0
if isinstance(usage, dict):
return int(usage.get("total_tokens", 0) or 0)
return int(getattr(usage, "total_tokens", 0) or 0)
def _estimate_input_tokens(self, batch: Union[str, List[str]]) -> int:
if isinstance(batch, list):
return sum(len(self.tokenizer.encode(item)) for item in batch)
return len(self.tokenizer.encode(batch))
def _extract_embeddings(self, response: Any) -> List[List[float]]:
output = getattr(response, "output", None)
if output is None and isinstance(response, dict):
output = response.get("output", {})
if hasattr(output, "get"):
embeddings = output.get("embeddings", [])
else:
embeddings = output["embeddings"]
result: List[List[float]] = []
for item in embeddings:
if isinstance(item, dict):
embedding = item.get("embedding")
else:
embedding = getattr(item, "embedding", None)
if embedding is None:
raise ValueError("DashScope embedding response did not contain an embedding vector.")
result.append(list(embedding))
if not result:
raise ValueError("DashScope embedding response returned no vectors.")
return result
def _call_api(self, batch: Union[str, List[str]], text_type: Optional[str]) -> List[List[float]]:
response = dashscope.TextEmbedding.call(
input=batch,
**self._build_params(text_type=text_type),
)
status_code = getattr(response, "status_code", None)
if status_code not in (HTTPStatus.OK, 200):
message = getattr(response, "message", None)
code = getattr(response, "code", None)
raise RuntimeError(f"DashScope embedding call failed: status_code={status_code}, code={code}, message={message}")
embeddings = self._extract_embeddings(response)
self.total_calls += 1
usage_tokens = self._extract_usage_tokens(response)
self.total_tokens += usage_tokens or self._estimate_input_tokens(batch)
if getattr(self.config, "embedding_dims", None) is None and embeddings:
self.config.embedding_dims = len(embeddings[0])
return embeddings
def embed(
self,
text: Union[str, List[str]],
text_type: Optional[str] = None,
) -> Union[List[float], List[List[float]]]:
if isinstance(text, list):
if not text:
return []
embeddings: List[List[float]] = []
for start in range(0, len(text), self.batch_size):
batch = [str(item) for item in text[start : start + self.batch_size]]
embeddings.extend(self._call_api(batch=batch, text_type=text_type))
return embeddings
single_embedding = self._call_api(batch=str(text), text_type=text_type)
return single_embedding[0]
def get_stats(self):
return {
"total_calls": self.total_calls,
"total_tokens": self.total_tokens,
"embedding_dims": getattr(self.config, "embedding_dims", None),
}
|