File size: 2,484 Bytes
8b12d82
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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

import os
import joblib
import numpy as np

from app.models import models


PCA_PATH = os.getenv(
    "PCA_PATH",
    "artifacts/embedding_pca.joblib"
)


def generate_embeddings(request):

    model = models.embedding()

    vectors = model.encode(
        request.input,
        convert_to_numpy=True,
        normalize_embeddings=False,
        show_progress_bar=False
    ).astype(np.float32)

    # PHASE 1: Embedding generation
    original_dimensions = vectors.shape[1]

    # PHASE 2: Dimensionality reduction
    if request.dimensions:
        if request.dimensions > original_dimensions:
            raise ValueError("Requested dimensions exceed model output")

        if request.dimensions < original_dimensions:
            if not os.path.exists(PCA_PATH):
                raise ValueError(
                    "PCA artifact not configured. "
                    "Train and deploy PCA before reducing dimensions."
                )

            pca = joblib.load(PCA_PATH)

            if pca.n_features_in_ != original_dimensions:
                raise ValueError("PCA input dimensions mismatch")

            if pca.n_components_ != request.dimensions:
                raise ValueError("PCA output dimensions mismatch")

            vectors = pca.transform(vectors)

    # Optional normalization after projection
    if request.normalize:
        norms = np.linalg.norm(
            vectors,
            axis=1,
            keepdims=True
        )

        vectors = vectors / np.maximum(norms, 1e-12)

    # PHASE 3: Precision quantization
    scales = None

    if request.precision == "float32":
        output = vectors.astype(np.float32).tolist()

    elif request.precision == "float16":
        output = vectors.astype(np.float16).tolist()

    elif request.precision == "int8":

        # Symmetric per-vector quantization
        max_values = np.max(
            np.abs(vectors),
            axis=1,
            keepdims=True
        )

        scale_array = np.maximum(
            max_values / 127.0,
            1e-12
        )

        quantized = np.clip(
            np.round(vectors / scale_array),
            -127,
            127
        ).astype(np.int8)

        output = quantized.tolist()

        scales = scale_array.flatten().tolist()

    return {
        "dimensions": vectors.shape[1],
        "precision": request.precision,
        "embeddings": output,
        "scales": scales,
        "original_dimensions": original_dimensions
    }