دوال المسافة

أُضيف في: v21.11.0

يحسب المسافة بين نقطتين (حيث تمثل عناصر المتجهات الإحداثيات) في فضاء L1 (المعيار 1 (مسافة هندسة مانهاتن)).

البنية

L1Distance(vector1, vector2)

الأسماء البديلة: distanceL1

الوسائط

• vector1 — المتجه الأول. Tuple(T) أو Array(T)
• vector2 — المتجه الثاني. Tuple(T) أو Array(T)

القيمة المعادة

يعيد مسافة معيار L1. بالنسبة إلى مدخلات Array، يعيد Float32 إذا كان النوع الفائق المشترك الأدنى لأنواع العناصر هو Float32 أو BFloat16، وإلا فيعيد Float64. أما بالنسبة إلى مدخلات Tuple، فإن نوع الإرجاع يتبع نوع الناتج الحسابي للعمليات على مستوى العناصر (مع الحفاظ على أنواع الأعداد الصحيحة). (U)Int* أو Float*

أمثلة

الاستخدام الأساسي

SELECT L1Distance((1, 2), (2, 3))

┌─L1Distance((1, 2), (2, 3))─┐
│                          2 │
└────────────────────────────┘

أُضيفت في: v21.11.0

تحسب مجموع القيم المطلقة لعناصر المتجه.

الصيغة

L1Norm(vector)

الأسماء البديلة: normL1

الوسيطات

• vector — متجه أو Tuple من القيم الرقمية. Array(T) أو Tuple(T)

القيمة المُعادة

تُرجع معيار L1 أو مسافة هندسة مانهاتن. UInt* أو Float* أو Decimal

أمثلة

الاستخدام الأساسي

SELECT L1Norm((1, 2))

┌─L1Norm((1, 2))─┐
│              3 │
└────────────────┘

أُضيفت في: v21.11.0

تحسب متجه الوحدة لمتجه معيّن (عناصر الـ Tuple أو الـ Array هي الإحداثيات) في فضاء L1 (هندسة مانهاتن).

الصيغة

L1Normalize(vector)

الأسماء البديلة: normalizeL1

الوسيطات

• vector — Tuple أو Array من القيم العددية. Tuple(T) أو Array(T)

القيمة المُعادة

تُرجع متجه الوحدة. بالنسبة إلى مُدخلات Array، تُرجع Array(Float32) إذا كان النوع الفائق المشترك الأدنى لأنواع العناصر هو Float32 أو BFloat16، وإلا فتُرجع Array(Float64). بالنسبة إلى مُدخلات Tuple، تُرجع دائمًا Tuple(Float64). Tuple(Float64) أو Array(Float32) أو Array(Float64)

أمثلة

الاستخدام الأساسي

SELECT L1Normalize((1, 2))

┌─L1Normalize((1, 2))─────────────────────┐
│ (0.3333333333333333,0.6666666666666666) │
└─────────────────────────────────────────┘

أُضيفت في: v21.11.0

تحسب المسافة بين نقطتين (تمثل عناصر المتجهات الإحداثيات) في الفضاء الإقليدي (المسافة الإقليدية).

الصيغة

L2Distance(vector1, vector2)

الأسماء المستعارة: distanceL2

الوسائط

• vector1 — المتجه الأول. Tuple(T) أو Array(T)
• vector2 — المتجه الثاني. Tuple(T) أو Array(T)

القيمة المُعادة

تُرجع مسافة معيار L2. بالنسبة إلى مدخلات Array، تُرجع Float32 إذا كان النوع الفائق المشترك الأدنى لأنواع العناصر هو Float32 أو BFloat16، وإلا فتُرجع Float64. أما بالنسبة إلى مدخلات Tuple، فتُرجع دائمًا Float64. Float*

أمثلة

الاستخدام الأساسي

SELECT L2Distance((1, 2), (2, 3))

┌─L2Distance((1, 2), (2, 3))─┐
│         1.4142135623730951 │
└────────────────────────────┘

أُضيف في: v25.10.0

يحسب المسافة التقريبية بين نقطتين (تمثل قيم المتجهات الإحداثيات) في الفضاء الإقليدي (المسافة الإقليدية).

الصيغة

L2DistanceTransposed(vector1, vector2, p[, used_dims])

الأسماء البديلة: distanceL2Transposed

وسيط

• vectors — المتجهات. QBit(T, UInt64[, UInt64])
• reference — المتجه المرجعي. Array(T)
• p — عدد البِتّات من كل عنصر في المتجه التي ستُستخدم في حساب المسافة (من 1 إلى عرض البِتّ للعنصر). يتحكم مستوى التكميم في موازنة بين الدقة والسرعة. يؤدّي استخدام عدد أقل من البِتّات إلى تسريع عمليات IO والحسابات مع تقليل الدقة، بينما يؤدّي استخدام عدد أكبر من البِتّات إلى زيادة الدقة على حساب الأداء. UInt
• used_dims — اختياري. عدد الأبعاد الأولى المطلوب قراءتها لإجراء بحث منخفض الأبعاد (Matryoshka) على QBit ذي stride. يجب أن يكون مضاعفًا لـ stride الخاص بـ QBit وألا يتجاوز بُعده، ويجب أن يحتوي المتجه المرجعي على هذا العدد من العناصر على الأقل (ويُتجاهل أي عناصر إضافية لاحقة). لا تُقرأ إلا مجموعات stride التي تغطي هذه الأبعاد. UInt

القيمة المعادة

يعيد مسافة معيار L2 التقريبية. ويُرجع دائمًا Float64. Float64

أمثلة

الاستخدام الأساسي

CREATE TABLE qbit (id UInt32, vec QBit(Float64, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, [0, 1]);
SELECT L2DistanceTransposed(vec, array(1, 2), 16) FROM qbit;

┌─L2DistanceTransposed(vec, [1, 2], 16)─┐
│                    1.3922918381215914 │
└───────────────────────────────────────┘

أُضيف في: v26.7.0

يحسب المسافة الإقليدية التقريبية بين QBit(Int8) من رموز quantizeBFloat16ToInt8 (تُفكّ تكميمها آنيًا) ومتجه مرجعي. يُقارَن متجه مرجعي (استعلام) من النوع Float مباشرةً بدقة Float32 – وهي دقة إعادة بناء الرموز بعد فك تكميمها، لذا يُحوَّل استعلام Float64 إلى Float32، بينما يُوسَّع استعلام BFloat16 إليها بدقة تامة (أي إن حساب المسافة غير متماثل)؛ أما المرجع Array(Int8) فيُعامَل هو نفسه على أنه رموز quantizeBFloat16ToInt8 وتُفكّ تكميمه إلى مستويات إعادة البناء الخاصة به. لاحظ أن p يقتطع فقط رموز QBit المخزنة؛ أما المرجع Array(Int8) فهو استعلام كامل ويُعاد بناؤه دائمًا بدقة 8-بت الكاملة، لذا لا تكون هذه مسافة متماثلة بين طرفين مكمّمين إلا عند p = 8 (أما عند p < 8 فلا يُقرأ إلا الطرف المخزن بدقة أخشن). ويجب أن يكون في الفضاء نفسه الذي كانت فيه القيم قبل التكميم (أي بعد تطبيق التدوير العشوائي والتحجيم نفسيهما)، وهذه مسؤولية المستدعي. إن cosine distance ثابتة تجاه التحجيم؛ أما dot product ومسافة L2 فليستا كذلك.

الصيغة

L2DistanceTransposedQuantized(vectors, reference, p[, used_dims])

وسيط

• vectors — متجهات رموز quantizeBFloat16ToInt8. QBit(Int8, UInt64[, UInt64])
• reference — المتجه المرجعي (الاستعلام): مصفوفة Float (أي الاستعلام، وتُجرى المقارنة بدقة Float32 – ويُضيَّق استعلام Float64 إلى Float32)، أو Array(Int8) من رموز quantizeBFloat16ToInt8 تُفك كميًا آنيًا. Array(Float32) أو Array(Int8)
• p — عدد البِتّات العليا من كل رمز QBit مخزَّن المطلوب استخدامه (من 1 إلى 8). يؤدّي استخدام عدد أقل من البِتّات إلى إعادة بناء مكمِّم مضمَّن أكثر خشونة باستخدام مراكز المتوسط الشرطي الغاوسي لفترات البادئة Lloyd-Max الموجودة، لتسريع عمليات IO مع تقليل الدقة؛ وتمثل 8 بِتّات إعادة بناء بالدقة الكاملة. يقتصر p على اقتطاع QBit المخزَّن فقط؛ أما المرجع Array(Int8) فيُعاد بناؤه دائمًا بدقة 8 بِتّات كاملة. UInt
• used_dims — اختياري. عدد الأبعاد الأولى المطلوب قراءتها لإجراء بحث منخفض الأبعاد (Matryoshka) على QBit ذي stride. يجب أن يكون مضاعفًا لـ stride الخاص بـ QBit وألا يتجاوز بُعده، ويجب أن يحتوي المتجه المرجعي على هذا العدد من العناصر على الأقل (وأي عناصر إضافية لاحقة يتم تجاهلها). لا تُقرأ إلا مجموعات stride التي تغطي هذه الأبعاد. UInt

القيمة المعادة

يعيد مسافة معيار L2 التقريبية. ويُرجع دائمًا Float64. Float64

أمثلة

الاستخدام الأساسي

CREATE TABLE qbit (id UInt32, vec QBit(Int8, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, arrayMap(x -> quantizeBFloat16ToInt8(x), [0.1, -0.5]::Array(BFloat16)));
SELECT L2DistanceTransposedQuantized(vec, [0.1, -0.5]::Array(Float32), 8) FROM qbit;

┌─L2DistanceTransposedQuantized(vec, CAST('[0.1, -0.5]', 'Array(Float32)'), 8)─┐
│                                                         0.004942022755037076 │
└──────────────────────────────────────────────────────────────────────────────┘

تم تقديمها في: v21.11.0

تحسب الجذر التربيعي لمجموع مربعات عناصر المتجه.

الصيغة

L2Norm(vector)

الأسماء البديلة: normL2

المعاملات

• vector — متجه أو Tuple من القيم العددية. Tuple(T) أو Array(T)

القيمة المُعادة

تُرجع معيار L2 أو المسافة الإقليدية. UInt* أو Float*

أمثلة

الاستخدام الأساسي

SELECT L2Norm((1, 2))

┌───L2Norm((1, 2))─┐
│ 2.23606797749979 │
└──────────────────┘

أُضيف في: v21.11.0

يحسب متجه الوحدة لمتجه معيّن (إذ تمثل عناصر الـ Tuple أو الـ Array الإحداثيات) في الفضاء الإقليدي (باستخدام المسافة الإقليدية).

الصيغة

L2Normalize(vector)

الأسماء البديلة: normalizeL2

الوسيطات

• vector — Tuple أو Array من القيم العددية. Tuple(T) أو Array(T)

القيمة المُعادة

يُرجع متجه الوحدة. بالنسبة إلى مدخلات Array، يُرجع Array(Float32) إذا كان النوع الفائق المشترك الأدنى لأنواع العناصر هو Float32 أو BFloat16، وإلا يُرجع Array(Float64). وبالنسبة إلى مدخلات Tuple، يُرجع دائمًا Tuple(Float64). Tuple(Float64) أو Array(Float32) أو Array(Float64)

أمثلة

الاستخدام الأساسي

SELECT L2Normalize((3, 4))

┌─L2Normalize((3, 4))─┐
│ (0.6,0.8)           │
└─────────────────────┘

أُضيف في: v22.7.0

يحسب مجموع مربعات الفروق بين العناصر المناظرة في متجهين.

صيغة

L2SquaredDistance(vector1, vector2)

الأسماء البديلة: distanceL2Squared

الوسيطات

• vector1 — المتجه الأول. Tuple(T) أو Array(T)
• vector2 — المتجه الثاني. Tuple(T) أو Array(T)

القيمة المعادة

تعيد مجموع مربعات الفروق بين العناصر المناظرة في متجهين. بالنسبة إلى مُدخلات Array، يكون نوع الإرجاع Float32 إذا كان النوع الفائق المشترك الأدنى لأنواع العناصر هو Float32 أو BFloat16، وإلا فيكون Float64. أما بالنسبة إلى مُدخلات Tuple، فيتبع نوع الإرجاع نوع النتيجة الحسابية للعمليات على مستوى العناصر (مع الاحتفاظ بالأنواع الصحيحة). (U)Int* أو Float*

أمثلة

الاستخدام الأساسي

SELECT L2SquaredDistance([1, 2, 3], [0, 0, 0])

┌─L2SquaredDistance([1, 2, 3], [0, 0, 0])─┐
│                                      14 │
└─────────────────────────────────────────┘

قُدِّمت في: v22.7.0

تحسب مربع الجذر التربيعي لمجموع مربعات عناصر المتجه (أي L2Norm).

البنية

L2SquaredNorm(vector)

الأسماء المستعارة: normL2Squared

الوسيطات

• vector — متجه أو Tuple من القيم العددية. Array(T) أو Tuple(T)

القيمة المعادة

يعيد مربع معيار L2. UInt* أو Float* أو Decimal

أمثلة

الاستخدام الأساسي

SELECT L2SquaredNorm((1, 2))

┌─L2SquaredNorm((1, 2))─┐
│                     5 │
└───────────────────────┘

أُضيفت في: v21.11.0

تحسب المسافة بين نقطتين (تمثل عناصر المتجهات الإحداثيات) في الفضاء L_{inf} (المعيار الأعظمي).

الصيغة

LinfDistance(vector1, vector2)

الأسماء البديلة: distanceLinf

الوسائط

• vector1 — المتجه الأول. Tuple(T) أو Array(T)
• vector2 — المتجه الثاني. Tuple(T) أو Array(T)

القيمة المعادة

تعيد مسافة معيار اللانهاية. بالنسبة إلى مُدخلات Array، تُعيد Float32 إذا كان النوع الأعلى المشترك الأدنى لأنواع العناصر هو Float32 أو BFloat16، وإلا فتُعيد Float64. أما بالنسبة إلى مُدخلات Tuple، فتُعيد دائمًا Float64. Float*

أمثلة

الاستخدام الأساسي

SELECT LinfDistance((1, 2), (2, 3))

┌─LinfDistance((1, 2), (2, 3))─┐
│                            1 │
└──────────────────────────────┘

أُضيفت في الإصدار: v21.11.0

يحسب أكبر قيمة مطلقة بين عناصر المتجه.

البنية

LinfNorm(vector)

الأسماء البديلة: normLinf

الوسيطات

• vector — متجه أو Tuple من القيم الرقمية. Array(T) أو Tuple(T)

القيمة المُعادة

تُرجِع معيار Linf أو أكبر قيمة مطلقة. Float64

أمثلة

الاستخدام الأساسي

SELECT LinfNorm((1, -2))

┌─LinfNorm((1, -2))─┐
│                 2 │
└───────────────────┘

أُضيفت في: v21.11.0

تحسب متجه الوحدة لمتجه معيّن (عناصر الـ Tuple أو المصفوفة هي الإحداثيات) في فضاء L_{inf} (باستخدام المعيار الأعظمي).

الصيغة

LinfNormalize(vector)

الأسماء البديلة: normalizeLinf

وسيطات الدالة

• vector — Tuple أو Array من القيم الرقمية. Tuple(T) أو Array(T)

القيمة المُعادة

تُرجع متجه الوحدة. بالنسبة إلى مُدخلات Array، تُرجع Array(Float32) إذا كان النوع الأعلى المشترك الأدنى لأنواع العناصر هو Float32 أو BFloat16، وإلا فتُرجع Array(Float64). بالنسبة إلى مُدخلات Tuple، تُرجع دائمًا Tuple(Float64). Tuple(Float64) أو Array(Float32) أو Array(Float64)

أمثلة

الاستخدام الأساسي

SELECT LinfNormalize((3, 4))

┌─LinfNormalize((3, 4))─┐
│ (0.75,1)              │
└───────────────────────┘

أُضيفت في: v21.11.0

تحسب المسافة بين نقطتين (عناصر المتجهات هي الإحداثيات) في فضاء Lp (مسافة معيار p).

صيغة

LpDistance(vector1, vector2, p)

الأسماء البديلة: distanceLp

وسيطات الدالة

• vector1 — المتجه الأول. Tuple(T) أو Array(T)
• vector2 — المتجه الثاني. Tuple(T) أو Array(T)
• p — الأس. القيم الممكنة: عدد حقيقي ضمن [1; inf). UInt* أو Int* أو Float*

القيمة المُعادة

تُرجِع مسافة معيار p. بالنسبة إلى مُدخلات Array، تُرجِع Float32 إذا كان النوع الأعلى المشترك الأدنى لأنواع العناصر هو Float32 أو BFloat16، وإلا فتُرجِع Float64. أما بالنسبة إلى مُدخلات Tuple، فتُرجِع دائمًا Float64. Float*

أمثلة

الاستخدام الأساسي

SELECT LpDistance((1, 2), (2, 3), 3)

┌─LpDistance((1, 2), (2, 3), 3)─┐
│            1.2599210498948732 │
└───────────────────────────────┘

أُضيفت في: v21.11.0

تحسب معيار p لمتجه، وهو الجذر من الرتبة p لمجموع القوى من الرتبة p للقيم المطلقة لعناصره.

حالات خاصة:

• عندما تكون p=1، فإنها تكافئ L1Norm (مسافة مانهاتن).
• عندما تكون p=2، فإنها تكافئ L2Norm (المسافة الإقليدية).
• يجب أن تكون قيمة p عددًا محدودًا لا يقل عن واحد؛ لاستخدام المعيار الأعظمي (حدّ p→∞)، استخدم LinfNorm بدلًا من ذلك.

صيغة

LpNorm(vector, p)

الأسماء البديلة: normLp

وسيطات الدالة

• vector — متجه أو Tuple من قيم رقمية. Tuple(T) أو Array(T)
• p — الأسّ. القيم الممكنة هي أعداد حقيقية ضمن النطاق [1; inf). UInt* أو Int* أو Float*

القيمة المعادة

يعيد معيار Lp. Float64

أمثلة

الاستخدام الأساسي

SELECT LpNorm((1, -2), 2)

┌─LpNorm((1, -2), 2)─┐
│   2.23606797749979 │
└────────────────────┘

تم تقديمه في: v21.11.0

يحسب متجه الوحدة لمتجه معيّن (حيث تمثل عناصر الـTuple أو الـArray الإحداثيات) في فضاء Lp (باستخدام معيار p).

صيغة

LpNormalize(vector, p)

الأسماء البديلة: normalizeLp

وسيطات الدالة

• vector — Tuple أو مصفوفة من قيم رقمية. Tuple(T) أو Array(T)
• p — الأس. القيم الممكنة هي أعداد حقيقية ضمن النطاق [1; inf). UInt* أو Int* أو Float*

القيمة المُعادة

تُرجع متجه الوحدة. بالنسبة إلى مدخلات Array، تُرجع Array(Float32) إذا كان النوع الأعلى المشترك الأدنى لأنواع العناصر هو Float32 أو BFloat16، وإلا فتُرجع Array(Float64). أما بالنسبة إلى مدخلات Tuple، فتُرجع دائمًا Tuple(Float64). Tuple(Float64) أو Array(Float32) أو Array(Float64)

أمثلة

مثال على الاستخدام

SELECT LpNormalize((3, 4), 5)

┌─LpNormalize((3, 4), 5)──────────────────┐
│ (0.7187302630182624,0.9583070173576831) │
└─────────────────────────────────────────┘

قُدِّمت في: v21.11.0

تحسب مسافة جيب التمام بين متجهين (عناصر Tuple هي الإحداثيات). وكلما صغرت القيمة المعادة، زاد التشابه بين المتجهين.

بناء الجملة

cosineDistance(vector1, vector2)

الأسماء البديلة: distanceCosine

الوسائط

• vector1 — الـ Tuple الأولى. Tuple(T) أو Array(T)
• vector2 — الـ Tuple الثانية. Tuple(T) أو Array(T)

القيمة المعادة

تعيد مسافة جيب التمام (أي واحدًا ناقص تشابه جيب التمام). بالنسبة إلى مُدخلات Array، تعيد Float32 إذا كان النوع الأعلى المشترك الأدنى لأنواع العناصر هو Float32 أو BFloat16، وإلا فتعيد Float64. أما بالنسبة إلى مُدخلات Tuple، فتعيد دائمًا Float64. Float*

أمثلة

الاستخدام الأساسي

SELECT cosineDistance((1, 2), (2, 3));

┌─cosineDistance((1, 2), (2, 3))─┐
│           0.007722123286332261 │
└────────────────────────────────┘

تمت إضافته في: v26.1.0

يحسب مسافة جيب التمام التقريبية بين نقطتين (إذ تمثل قيم المتجهات الإحداثيات). وكلما صغرت القيمة المُعادة، زاد التشابه بين المتجهات.

الصيغة

cosineDistanceTransposed(vector1, vector2, p[, used_dims])

الأسماء البديلة: distanceCosineTransposed

وسيطات الدالة

• vectors — متجهات. QBit(T, UInt64[, UInt64])
• reference — المتجه المرجعي. Array(T)
• p — عدد البِتّات من كل عنصر في المتجه التي ستُستخدم في حساب المسافة (من 1 حتى عرض البِتّ للعنصر). يتحكم مستوى التكميم في موازنة بين الدقة والسرعة. يؤدي استخدام عدد أقل من البِتّات إلى تسريع عمليات I/O والحسابات مع انخفاض الدقة، بينما يؤدي استخدام عدد أكبر من البِتّات إلى زيادة الدقة على حساب الأداء. UInt
• used_dims — اختياري. عدد الأبعاد الأولى التي ستُقرأ، لإجراء بحث منخفض الأبعاد (Matryoshka) على QBit ذي stride. يجب أن يكون مضاعفًا لـ stride الخاص بـ QBit، وألا يتجاوز بُعده، ويجب أن يحتوي المتجه المرجعي على هذا العدد من العناصر على الأقل (ويُتجاهل أي عناصر إضافية لاحقة). لا تُقرأ إلا مجموعات stride التي تغطي هذه الأبعاد. UInt

القيمة المُعادة

تُرجع مسافة جيب التمام التقريبية (واحد ناقص تشابه جيب التمام). وتكون القيمة المُعادة دائمًا من النوع Float64. Float64

أمثلة

الاستخدام الأساسي

CREATE TABLE qbit (id UInt32, vec QBit(Float64, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, [0, 1]);
SELECT cosineDistanceTransposed(vec, array(1, 2), 16) FROM qbit;

┌─cosineDistanceTransposed(vec, [1, 2], 16)─┐
│                       0.10557280905788935 │
└───────────────────────────────────────────┘

أُضيف في: v26.7.0

يحسب مسافة جيب التمام التقريبية بين رموز QBit(Int8) التابعة لـ quantizeBFloat16ToInt8 (التي يُفكّ تكميمها آنيًا) ومتجه مرجعي. وكلما صغرت القيمة المعادة، زاد تشابه المتجهات. يُقارَن متجه مرجعي (استعلام) من نوع Float مباشرةً بدقة Float32 — وهي دقة إعادة بناء الرموز بعد فك التكميم — لذا يُحوَّل استعلام Float64 إلى Float32، بينما يُوسَّع استعلام BFloat16 إليه بدقة تامة (أي إن حساب المسافة غير متماثل)؛ أما المرجع Array(Int8) فيُعامَل هو نفسه على أنه رموز quantizeBFloat16ToInt8 ويُفكّ تكميمه إلى مستويات إعادة البناء الخاصة به. لاحظ أن p يقتطع فقط رموز QBit المخزنة؛ أما المرجع Array(Int8) فهو استعلام كامل ويُعاد بناؤه دائمًا بدقة 8 بت كاملة، لذلك لا تكون هذه مسافة متماثلة بين قيم مكمّاة إلا عند p = 8 (أما عند p < 8 فلا يُقرأ إلا الجانب المخزن بدقة أقل). ويجب أن يكون في الفضاء نفسه الذي كانت فيه القيم قبل التكميم (أي بعد تطبيق دوران عشوائي والتحجيم نفسيهما)، وهذا يقع على عاتق المستدعي. مسافة جيب التمام لا تتأثر بالتحجيم؛ أما الضرب النقطي ومسافة L2 فليسا كذلك.

الصيغة

cosineDistanceTransposedQuantized(vectors, reference, p[, used_dims])

وسيطات الدالة

• vectors — متجهات من رموز quantizeBFloat16ToInt8. QBit(Int8, UInt64[, UInt64])
• reference — المتجه المرجعي (الاستعلام): مصفوفة Float (أي الاستعلام، وتتم مقارنته بدقة Float32 – ويُحوَّل استعلام Float64 إلى Float32)، أو Array(Int8) من رموز quantizeBFloat16ToInt8 تُفك كميتها آنيًا. Array(Float32) أو Array(Int8)
• p — عدد البتات العليا من كل رمز QBit مخزَّن المطلوب استخدامها (من 1 إلى 8). يؤدي استخدام عدد أقل من البتات إلى إعادة بناء مُكمِّم مضمَّن أكثر خشونة باستخدام مراكز المتوسط الشرطي الغاوسي لفواصل البادئة Lloyd-Max الحالية، لتسريع I/O على حساب الدقة؛ وتمثل 8 بتات إعادة البناء بالدقة الكاملة. يقتصر تأثير p على بتر QBit المخزَّن فقط؛ أما المرجع من النوع Array(Int8) فيُعاد بناؤه دائمًا بدقة 8 بت كاملة. UInt
• used_dims — اختياري. عدد الأبعاد الأولى المطلوب قراءتها لإجراء بحث منخفض الأبعاد (Matryoshka) على QBit ذي stride. يجب أن يكون مضاعفًا لـ stride الخاص بـ QBit وألا يتجاوز بُعده، ويجب أن يحتوي المتجه المرجعي على هذا العدد من العناصر على الأقل (وأي عناصر زائدة لاحقة يتم تجاهلها). لا تُقرأ إلا مجموعات stride التي تغطي هذه الأبعاد. UInt

القيمة المعادة

تعيد مسافة جيب التمام التقريبية (واحد ناقص تشابه جيب التمام). وتُعيد دائمًا Float64. Float64

أمثلة

الاستخدام الأساسي

CREATE TABLE qbit (id UInt32, vec QBit(Int8, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, arrayMap(x -> quantizeBFloat16ToInt8(x), [0.1, -0.5]::Array(BFloat16)));
SELECT cosineDistanceTransposedQuantized(vec, [0.1, -0.5]::Array(Float32), 8) FROM qbit;

┌─cosineDistanceTransposedQuantized(vec, CAST('[0.1, -0.5]', 'Array(Float32)'), 8)─┐
│                                                          0.000027192636379513857 │
└──────────────────────────────────────────────────────────────────────────────────┘

تمت إضافته في: v26.7.0

يحسب الضرب القياسي التقريبي (الجداء الداخلي) لمتجهين (إذ تمثل قيم المتجهات الإحداثيات). وعلى عكس دوال المسافة، فهذا مقياس للتشابه: فكلما كبرت القيمة المُعادة، زاد التشابه بين المتجهات.

الصيغة

dotProductTransposed(vector1, vector2, p[, used_dims])

الأسماء البديلة: scalarProductTransposed

وسيطات الدالة

• vectors — متجهات. QBit(T, UInt64[, UInt64])
• reference — المتجه المرجعي. Array(T)
• p — عدد البِتّات من كل عنصر في المتجه التي ستُستخدم في الحساب (من 1 حتى عرض البِتّ للعنصر). يتحكم مستوى التكميم في موازنة بين الدقة والسرعة. يؤدي استخدام عدد أقل من البِتّات إلى تسريع عمليات I/O والحسابات مع انخفاض الدقة، بينما يؤدي استخدام عدد أكبر من البِتّات إلى زيادة الدقة على حساب الأداء. UInt
• used_dims — اختياري. عدد الأبعاد الأولى التي ستُقرأ لإجراء بحث منخفض الأبعاد (Matryoshka) على QBit ذي stride. يجب أن يكون مضاعفًا لـ stride الخاص بـ QBit وألا يتجاوز بُعده، ويجب أن يحتوي المتجه المرجعي على هذا العدد من العناصر على الأقل (وأي عناصر إضافية في النهاية يتم تجاهلها). لا تُقرأ إلا مجموعات stride التي تغطي هذه الأبعاد. UInt

القيمة المُعادة

تُرجع الضرب القياسي التقريبي للمتجهين. وتكون القيمة المُعادة دائمًا من النوع Float64. Float64

أمثلة

الاستخدام الأساسي

CREATE TABLE qbit (id UInt32, vec QBit(Float64, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, [0, 1]);
SELECT dotProductTransposed(vec, array(1, 2), 16) FROM qbit;

┌─dotProductTransposed(vec, [1, 2], 16)─┐
│                                2.0625 │
└───────────────────────────────────────┘

أُضيف في: v26.7.0

يحسب الضرب القياسي التقريبي (الجداء الداخلي) بين QBit(Int8) من رموز quantizeBFloat16ToInt8 (تُفكّ تكميمها آنيًا) ومتجه مرجعي. وهذا مقياس للتشابه: فكلما كبرت القيمة المُعادة، زاد التشابه بين المتجهات. يُقارَن متجه مرجعي (استعلام) من نوع Float مباشرة بدقة Float32 – وهي دقة إعادة بناء الرموز بعد فكّ تكميمها، لذا يُحوَّل استعلام Float64 إلى Float32، بينما يُوسَّع استعلام BFloat16 إليه تمامًا (حساب مسافة غير متماثل)؛ أما المرجع Array(Int8) فيُتعامل معه هو نفسه على أنه رموز quantizeBFloat16ToInt8، وتُفكّ تكميمه إلى مستويات إعادة البناء الخاصة به. لاحظ أن p يقتطع فقط رموز QBit المخزَّنة؛ أما المرجع Array(Int8) فهو في حد ذاته استعلام كامل، ويُعاد بناؤه دائمًا بدقة 8-بت كاملة، لذا لا يكون هذا حساب مسافة متناظرًا بين بيانات مكمَّمة وأخرى مكمَّمة إلا عند p = 8 (أما عند p < 8 فلا يُقرأ من الجانب المخزَّن إلا بدقة أخشن). ويجب أن يكون في الفضاء نفسه الذي كانت القيم فيه قبل التكميم (أي بعد الدوران العشوائي والتحجيم نفسيهما)، وهذه مسؤولية المستدعي. مسافة جيب التمام غير متأثرة بالتحجيم؛ أما الضرب القياسي ومسافة L2 فليسا كذلك.

الصيغة

dotProductTransposedQuantized(vectors, reference, p[, used_dims])

وسيطات الدالة

• vectors — متجهات من رموز quantizeBFloat16ToInt8. QBit(Int8, UInt64[, UInt64])
• reference — المتجه المرجعي (الاستعلام): مصفوفة Float (أي الاستعلام، ويُقارَن بدقة Float32 – ويُحوَّل الاستعلام من النوع Float64 إلى Float32)، أو Array(Int8) من رموز quantizeBFloat16ToInt8 يُفك تكميمها آنيًا. Array(Float32) أو Array(Int8)
• p — عدد البِتّات العليا من كل رمز QBit مخزنة التي ستُستخدم (من 1 إلى 8). يؤدي استخدام عدد أقل من البِتّات إلى إعادة بناء مُكمِّم مضمن أكثر خشونة باستخدام مراكز المتوسط الشرطي الغاوسي لفاصل البادئة Lloyd-Max الحالي، لتسريع عمليات I/O مع انخفاض الدقة؛ وتمثل 8 بِتّات إعادة البناء كاملة الدقة. يقتطع p فقط قيمة QBit المخزنة؛ أما المرجع من النوع Array(Int8) فيُعاد بناؤه دائمًا بدقة كاملة تبلغ 8 بِتّات. UInt
• used_dims — اختياري. عدد الأبعاد الأولى التي ستُقرأ لإجراء بحث منخفض الأبعاد (Matryoshka) على QBit ذي stride. يجب أن يكون مضاعفًا لـ stride الخاص بـ QBit وألا يتجاوز بُعده، ويجب أن يحتوي المتجه المرجعي على هذا العدد من العناصر على الأقل (وأي عناصر إضافية لاحقة يتم تجاهلها). لا تُقرأ إلا مجموعات stride التي تغطي هذه الأبعاد. UInt

القيمة المُعادة

تُرجع الضرب القياسي التقريبي للمتجهين. وتكون القيمة المُعادة دائمًا من النوع Float64. Float64

أمثلة

الاستخدام الأساسي

CREATE TABLE qbit (id UInt32, vec QBit(Int8, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, arrayMap(x -> quantizeBFloat16ToInt8(x), [0.1, -0.5]::Array(BFloat16)));
SELECT dotProductTransposedQuantized(vec, [0.1, -0.5]::Array(Float32), 8) FROM qbit;

┌─dotProductTransposedQuantized(vec, CAST('[0.1, -0.5]', 'Array(Float32)'), 8)─┐
│                                                          0.25834959745407104 │
└──────────────────────────────────────────────────────────────────────────────┘