Quantization (II): Linear Quantization and Integer-Only Inferenceالتكميم (Quantization) الجزء الثاني: التكميم الخطي والاستدلال بالأعداد الصحيحة فقط

Take the 4×4 weight matrix from last lecture and quantize it two ways to 2 bits. With K-means, each weight becomes an index between 0 and 3, and a four-entry table says index 3 means 2.00, index 2 means 1.50, and so on. With linear quantization, each weight becomes a signed code between -2 and 1, and one formula, (q - (-1)) × 1.07, turns any code back into a real number. Both versions use 2 bits per weight. The difference shows up only when the layer runs.

خذ مصفوفة الأوزان 4×4 من المحاضرة السابقة وكمّمها بطريقتين إلى 2 بت. مع K-means، يصبح كل وزن فهرسًا بين 0 و3، وجدول من أربعة مدخلات يقول إن الفهرس 3 يعني 2.00، والفهرس 2 يعني 1.50، وهكذا. ومع التكميم الخطي، يصبح كل وزن رمزًا بإشارة (signed) بين -2 و1، وصيغة واحدة هي (q - (-1)) × 1.07 تعيد أي رمز إلى عدد حقيقي. كلا النسختين تستخدم 2 بت لكل وزن. الفرق لا يظهر إلا عندما تعمل الطبقة.

The table that frames the lectureالجدول الذي يؤطّر المحاضرة

Slide 2 compares the schemes on two rows: what sits in memory, and what kind of arithmetic the processor performs. Learn it as a grid, because it is an easy short-answer question.

تقارن الشريحة 2 بين الطرق على صفّين: ما الذي يقبع في الذاكرة، وأي نوع من الحساب ينفّذه المعالج. احفظه على شكل شبكة، لأنه سؤال سهل من نوع الإجابة القصيرة.

K-means-based quantization wins on storage but not on compute. Before a multiply can happen, every index must be looked up in the Codebook, and what comes out is a float. The multiply-accumulate (MAC) that follows is a floating-point MAC, exactly as in the original model. K-means saves memory and memory traffic, and that is all it saves.

K-means quantization يتفوق في التخزين لكن ليس في الحساب. قبل أن يحدث أي ضرب، يجب البحث عن كل فهرس في الـ codebook، وما يخرج من هذا البحث عدد عشري (float). وعملية الضرب والجمع التراكمي (MAC) التي تليه هي MAC عشرية، تمامًا كما في النموذج الأصلي. K-means يوفّر الذاكرة وحركة البيانات من الذاكرة وإليها، وهذا كل ما يوفّره.

Linear quantization changes the second row too. The reason is algebraic. Every real value in a tensor is written as r = S(q - Z) with the same Scale (S) S and the same Zero point (Z) Z. In a dot product of weights and inputs, the common scale factors out of the whole sum:

التكميم الخطي يغيّر الصف الثاني أيضًا. والسبب جبري. كل قيمة حقيقية في الـ tensor تُكتب على الصورة r = S(q - Z) بنفس الـ scale S ونفس الـ zero point Z. وفي حاصل الضرب النقطي (dot product) بين الأوزان والمدخلات، يخرج الـ scale المشترك عاملًا من المجموع كله:

Everything inside the sum is integer subtraction, multiplication and addition. The floats S_W S_X are applied once per output, not once per MAC, and part 3 shows that even that single rescale can be done as an integer multiply and a bit shift. That is what makes Integer-only inference possible. A codebook gives no such shortcut: its centroids are arbitrary floats like 2.00, 1.50, 0.00 and -1.00, with no common factor and offset to pull out.

كل ما داخل المجموع عمليات طرح وضرب وجمع على أعداد صحيحة. أما القيم العشرية S_W S_X فتُطبَّق مرة واحدة لكل مخرج، لا مرة لكل MAC، والجزء 3 يبيّن أن حتى إعادة التحجيم (rescale) الوحيدة هذه يمكن تنفيذها بضرب صحيح وإزاحة بتات (bit shift). وهذا ما يجعل integer-only inference ممكنًا. أما الـ codebook فلا يقدّم اختصارًا كهذا: مراكزه أعداد عشرية عشوائية مثل 2.00 و1.50 و0.00 و-1.00، ليس لها عامل مشترك ولا إزاحة (offset) مشتركة يمكن إخراجهما.

Storage also differs a little, even at the same bit width. For the 16 example weights:

ويختلف التخزين قليلًا أيضًا، حتى عند نفس عدد البتات (bit width). بالنسبة لأوزان المثال الـ 16:

For a real layer with millions of weights the side information is negligible in both schemes, so the storage row is roughly a tie. The computation row decides the matter. Integer adders and multipliers cost far less energy and silicon area than floating-point ones (recall the energy table from Lecture 05-1), and many microcontrollers and NPUs have no floating-point unit at all.

في طبقة حقيقية فيها ملايين الأوزان تكون المعلومات الجانبية (side information) مهملة في الطريقتين، لذا يكون صف التخزين متعادلًا تقريبًا. صف الحساب هو الذي يحسم الأمر. وحدات الجمع والضرب الصحيحة تستهلك طاقة ومساحة سيليكون أقل بكثير من نظيراتها العشرية (تذكّر جدول الطاقة من المحاضرة 05-1)، وكثير من المتحكمات الدقيقة (microcontrollers) ووحدات NPU لا تحتوي على وحدة أعداد عشرية (floating-point unit) أصلًا.

Start with one weight, 1.48, and a ruler whose marks are 1.07 apart. Divide by the mark spacing: 1.48 / 1.07 = 1.383. The nearest whole mark is 1. Now shift every mark number down by one so that the mark sitting on real zero is called -1. The weight lands on mark 1 + (-1) = 0. That is the whole of the forward step.

ابدأ بوزن واحد، 1.48، ومسطرة تفصل بين علاماتها مسافة 1.07. اقسم على المسافة بين العلامات: 1.48 / 1.07 = 1.383. أقرب علامة صحيحة هي 1. الآن أنقص رقم كل علامة بواحد بحيث تُسمّى العلامة الواقعة على الصفر الحقيقي -1. يقع الوزن على العلامة 1 + (-1) = 0. وهذه هي الخطوة الأمامية بكاملها.

The affine mappingالتحويل الـ affine

Linear quantization ties every integer code q to a real value r with an Affine mapping: a multiply by a scale plus a fixed offset.

يربط التكميم الخطي كل رمز صحيح q بقيمة حقيقية r عبر affine mapping: ضرب في scale مع إزاحة (offset) ثابتة.

• Scale (S) S is a floating-point number: the real distance between two neighbouring codes. In the example S = 1.07.الـ scale S عدد عشري (floating-point): هو المسافة الحقيقية بين رمزين متجاورين. في المثال S = 1.07.
• Zero point (Z) Z is an integer of the same type as the codes: the code that means real 0, since S(Z - Z) = 0 for any S. In the example Z = -1; part 2 derives it as round(q_min - r_min / S) = round(-2 + 1.08 / 1.07) = round(-0.99) = -1.الـ zero point Z عدد صحيح من نفس نوع الرموز: هو الرمز الذي يعني الصفر الحقيقي 0، لأن S(Z - Z) = 0 لأي قيمة S. في المثال Z = -1، والجزء 2 يشتقّه على أنه round(q_min - r_min / S) = round(-2 + 1.08 / 1.07) = round(-0.99) = -1.
• The codes are signed Bit width (N) integers. With N = 2, q_min and q_max are -2 and 1, so there are only 4 levels.الرموز أعداد صحيحة بإشارة (signed) بعدد بتات يحدده الـ bit width. عندما N = 2، تكون قيمتا q_min, q_max هما -2 و1، فلا يوجد إلا 4 مستويات.

The mapping is called affine rather than linear in the strict sense because of the offset Z. Its job is to give real zero an exact code. Zero padding, ReLU outputs and pruned weights are all exactly zero, and Jacob et al. require that they quantize with no error at all. Part 2 shows how to derive S and Z from r_min and r_max. Here, take them as given.

يُسمّى هذا التحويل affine وليس خطيًا (linear) بالمعنى الدقيق بسبب الإزاحة Z. مهمتها أن تعطي الصفر الحقيقي رمزًا دقيقًا (exact code). الحشو بالأصفار (zero padding) ومخرجات ReLU والأوزان المقلّمة (pruned) كلها أصفار تامة، وJacob et al. يشترطون أن تُكمَّم دون أي خطأ على الإطلاق. الجزء 2 يبيّن كيف نشتق S وZ من r_min, r_max. هنا، اعتبرهما معطيين.

The forward formula the slides leave outالصيغة الأمامية التي تتجاهلها الشرائح

Slide 4 shows the weights turning into codes, but it never writes down how. Inverting r = S(q - Z) gives q = r / S + Z, which is usually not a whole number. So round it, and clamp anything that falls outside the integer range:

تعرض الشريحة 4 الأوزان وهي تتحول إلى رموز، لكنها لا تكتب أبدًا كيف يحدث ذلك. عكس الصيغة r = S(q - Z) يعطي q = r / S + Z، وهي في العادة ليست عددًا صحيحًا. لذا نقرّبها (round)، ونقصّ (clamp) أي قيمة تقع خارج مدى الأعداد الصحيحة:

Rounding r / S before adding Z works because Z is already an integer, and it keeps real 0 landing exactly on code Z. This is the form given in the Nagel et al. white paper on neural network quantization.

تقريب r / S قبل إضافة Z يصحّ لأن Z عدد صحيح أصلًا، وهو يضمن أن يقع الصفر الحقيقي 0 تمامًا على الرمز Z. هذه هي الصيغة الواردة في الورقة البيضاء (white paper) لـ Nagel et al. عن تكميم الشبكات العصبية.

Reading the 2-bit codesقراءة الرموز بطول 2 بت

The codes are stored in Two's complement. With two bits the leading bit carries weight -2 and the trailing bit carries +1, which gives the table on slide 4. The slides colour each level: blue for 1, pink for 0, orange for -1, green for -2. The simulator below also gives each of the four levels its own colour, using the site palette, with a legend under the matrices.

تُخزَّن الرموز بصيغة two's complement. مع بتين، يحمل البت الأول وزن -2 ويحمل البت الأخير وزن +1، وهذا يعطي الجدول في الشريحة 4. تلوّن الشرائح كل مستوى: الأزرق لـ 1، والوردي لـ 0، والبرتقالي لـ -1، والأخضر لـ -2. والمحاكي أدناه يعطي كذلك كل مستوى من المستويات الأربعة لونه الخاص، باستخدام ألوان الموقع، مع مفتاح ألوان تحت المصفوفات.

Slide 4 turns 16 weights into codes, then back into numbers. What comes back has only four distinct values: -1.07, 0, 1.07 and 2.14. The weights 1.48, 1.53 and 1.49 all come back as 1.07. That collapse is the price of using 2 bits.

تحوّل الشريحة 4 الأوزان الـ 16 إلى رموز، ثم تعيدها إلى أعداد. ما يعود ليس فيه إلا أربع قيم مختلفة: -1.07 و0 و1.07 و2.14. الأوزان 1.48 و1.53 و1.49 كلها تعود على أنها 1.07. هذا الانهيار هو ثمن استخدام 2 بت.

Reconstruct with the affine mapإعادة البناء بالتحويل الـ affine

The Reconstructed weights are just S(q - Z) applied to each Quantized value (q). With Z = -1, that is (q + 1) × 1.07:

الـ reconstructed weights ما هي إلا S(q - Z) مطبّقة على كل quantized value. ومع Z = -1، تصبح (q + 1) × 1.07:

• q = 1 gives 2.14, and q = 0 gives 1.07.q = 1 يعطي 2.14، وq = 0 يعطي 1.07.
• q = -1 gives 0 exactly, and q = -2 gives -1.07.q = -1 يعطي 0 بالضبط، وq = -2 يعطي -1.07.

The reconstructed matrix is [[2.14, -1.07, 1.07, 0], [0, 0, -1.07, 2.14], [-1.07, 2.14, 0, -1.07], [2.14, 0, 1.07, 1.07]]. In a real integer pipeline this matrix is never built in memory. It is the meaning of the codes, which is what we compare against the original to measure the damage.

المصفوفة المعاد بناؤها هي [[2.14, -1.07, 1.07, 0], [0, 0, -1.07, 2.14], [-1.07, 2.14, 0, -1.07], [2.14, 0, 1.07, 1.07]]. في خط معالجة صحيح حقيقي (integer pipeline) لا تُبنى هذه المصفوفة في الذاكرة أبدًا. إنها معنى الرموز، وهي ما نقارنه بالأصل لقياس حجم الضرر.

Quantization error and the S/2 boundخطأ التكميم والحد S/2

The Quantization error of each cell is the original minus the reconstruction, e = r - S(q - Z):

الـ quantization error لكل خانة هو القيمة الأصلية ناقص القيمة المعاد بناؤها، e = r - S(q - Z):

Round-to-nearest picks the closest level, and neighbouring levels are S apart, so a value that is not clipped is never more than half a step from its level. For every such value, |e| ≤ S/2 = 0.535. The worst cell is 1.53: it divides to 1.430, rounds down to code 0, and comes back as 1.07, an error of 0.46. That is close to the bound, because 1.53 sits near the midpoint 1.605 between 1.07 and 2.14. The two zeros have error 0, as promised by the exact zero point.

التقريب إلى الأقرب (round-to-nearest) يختار أقرب مستوى، والمستويات المتجاورة تفصل بينها مسافة S، لذا فالقيمة التي لم تُقصّ (not clipped) لا تبعد أبدًا عن مستواها أكثر من نصف خطوة. لكل قيمة كهذه، |e| ≤ S/2 = 0.535. أسوأ خانة هي 1.53: قسمتها تعطي 1.430، فتُقرَّب للأسفل إلى الرمز 0، وتعود على أنها 1.07، بخطأ قدره 0.46. وهذا قريب من الحد، لأن 1.53 تقع قرب نقطة المنتصف 1.605 بين 1.07 و2.14. والصفران خطؤهما 0، كما يضمن الـ zero point الدقيق.

More than half a step beyond either end level, clamping takes over and the error grows with the distance. Nagel et al. call this clipping error, as opposed to rounding error. A wider range means less clipping but a larger S and more rounding error. Choosing the range is the central trade-off in linear quantization.

عندما تبتعد القيمة أكثر من نصف خطوة خارج أيّ من المستويين الطرفيين، يتولى القصّ (clamping) الأمر ويكبر الخطأ مع المسافة. يسمّي Nagel et al. هذا خطأ القصّ (clipping error)، في مقابل خطأ التقريب (rounding error). المدى الأوسع يعني قصًّا أقل، لكنه يعني S أكبر وخطأ تقريب أكبر. اختيار المدى هو المفاضلة (trade-off) المحورية في التكميم الخطي.

Why the top level is 2.14 and not 2.12لماذا المستوى الأعلى 2.14 وليس 2.12

The largest weight is r_max = 2.12, yet the top level is 2.14, and the bottom level -1.07 sits just above r_min = -1.08. Two roundings cause this. The exact scale is 3.20 / 3 = 1.0667, which the slides round to 1.07. The exact offset would be -0.99, but the zero point must be an integer so that real zero stays exact, so it is rounded to -1. Together these shift and stretch the grid slightly, so it covers [-1.07, 2.14] instead of [-1.08, 2.12]. The cost is tiny: -1.08 still reconstructs with an error of only -0.01, well within S/2.

أكبر وزن هو r_max = 2.12، ومع ذلك فالمستوى الأعلى هو 2.14، والمستوى الأدنى -1.07 يقع فوق r_min = -1.08 بقليل. السبب عمليتا تقريب. الـ scale الدقيق هو 3.20 / 3 = 1.0667، وتقرّبه الشرائح إلى 1.07. والإزاحة الدقيقة كانت ستكون -0.99، لكن الـ zero point يجب أن يكون عددًا صحيحًا ليبقى الصفر الحقيقي دقيقًا، لذا يُقرَّب إلى -1. معًا، تُزيح هاتان العمليتان الشبكة وتمطّانها قليلًا، فتغطي [-1.07, 2.14] بدلًا من [-1.08, 2.12]. والكلفة ضئيلة: -1.08 ما زالت تُعاد بناؤها بخطأ قدره -0.01 فقط، وهو أقل بكثير من S/2.

Try it at other bit widthsجرّبه بأعداد بتات أخرى

The simulator below runs the same matrix through the same formulas. At 2 bits it reproduces slide 4 cell for cell. Slide up to 8 bits, the INT8 format used in deployment, and watch S shrink by roughly half per extra bit, the levels multiply, and the error heatmap fade.

المحاكي أدناه يمرّر المصفوفة نفسها عبر الصيغ نفسها. عند 2 بت يعيد إنتاج الشريحة 4 خانةً بخانة. حرّك المؤشر حتى 8 بت، وهي صيغة INT8 المستخدمة في النشر (deployment)، وراقب S وهي تتقلص إلى النصف تقريبًا مع كل بت إضافي، والمستويات وهي تتضاعف، وخريطة الخطأ الحرارية (heatmap) وهي تبهت.

Take the top-left weight of the slide's 4 x 4 matrix, 2.09. After quantization, the chip stores the 2-bit code 1. It also keeps two numbers for the whole matrix: Z = -1 and S = 1.07. To get a real number back it computes (1 - (-1)) x 1.07 = 2.14. That is close to 2.09 but not equal to it.

خذ الوزن في الزاوية العليا اليسرى من مصفوفة الشريحة ذات الحجم 4 x 4، وقيمته 2.09. بعد التكميم تخزّن الشريحة الإلكترونية الرمز ذا البتين 1. وتحتفظ أيضًا بعددين للمصفوفة كلها: Z = -1 وS = 1.07. ولكي تستعيد عددًا حقيقيًا تحسب (1 - (-1)) x 1.07 = 2.14. هذه القيمة قريبة من 2.09 لكنها لا تساويها.

The map and the types of its symbolsالدالة وأنواع رموزها

That recovery rule is Linear quantization written as an Affine mapping: a scale times a shifted integer.

قاعدة الاستعادة هذه هي linear quantization (التكميم الخطي) مكتوبًا على شكل affine mapping (دالة تآلفية): مقياس مضروب في عدد صحيح مُزاح.

Read the map from right to left. Start from the stored integer Quantized value (q), subtract the Zero point (Z), then multiply by the Scale (S). The types matter as much as the formula, and they are a favourite exam detail:

اقرأ الدالة من اليمين إلى اليسار. ابدأ من العدد الصحيح المخزّن quantized value (q)، واطرح منه zero point (Z)، ثم اضرب الناتج في scale (S). الأنواع مهمة بقدر أهمية الصيغة نفسها، وهي تفصيل يحب الامتحان أن يسأل عنه:

The two quantities that live with each value (r and q) are a float and an integer. The two quantization parameters (S and Z) are also a float and an integer. Z has the same type as q, so in the slide example it is a 2-bit signed integer. That is no accident: the paper the slides come from, Jacob et al. (CVPR 2018), defines Z as the quantized value that corresponds to real 0. A value can only be a code if it is an integer in the code's type.

الكميتان المرتبطتان بكل قيمة (r وq) هما عدد عشري وعدد صحيح. ومعاملا التكميم (S وZ) هما أيضًا عدد عشري وعدد صحيح. نوع Z هو نفس نوع q، لذلك في مثال الشرائح هو عدد صحيح بإشارة من بتين. وهذا ليس صدفة: الورقة التي أُخذت منها الشرائح، Jacob et al. (CVPR 2018)، تعرّف Z بأنه القيمة المكمّمة التي تقابل الصفر الحقيقي 0. ولا يمكن لقيمة أن تكون رمزًا إلا إذا كانت عددًا صحيحًا من نوع الرموز.

The picture shows the two operations in order. Subtracting Z slides the integer grid so the code Z sits on zero. Multiplying by S stretches the spacing from 1 to S. The Reconstructed weights therefore always lie on a uniform grid of spacing S. The gap between an original value and its grid point is the Quantization error, at most S/2 for in-range values.

يعرض الشكل العمليتين بالترتيب. طرح Z يزيح شبكة الأعداد الصحيحة بحيث يقع الرمز Z على الصفر. والضرب في S يمدّ المسافة بين النقاط من 1 إلى S. لذلك تقع reconstructed weights (الأوزان المعاد بناؤها) دائمًا على شبكة منتظمة المسافة بين نقاطها S. والفرق بين القيمة الأصلية ونقطة الشبكة الخاصة بها هو quantization error (خطأ التكميم)، ولا يتجاوز S/2 للقيم الواقعة داخل المدى.

With 2 bits you can write exactly four patterns: 00, 01, 10, 11. Read as signed numbers they are 0, 1, -2 and -1. So a 2-bit code lives in [-2, 1], and quantization must squeeze the whole real range of the matrix onto those four points.

باستخدام بتين يمكنك كتابة أربعة أنماط فقط: 00 و01 و10 و11. وإذا قرأتها كأعداد بإشارة فهي 0 و1 و-2 و-1. إذن الرمز ذو البتين يقع في [-2, 1]، وعلى التكميم أن يضغط المدى الحقيقي الكامل للمصفوفة على هذه النقاط الأربع.

Two number linesخطّا أعداد

Picture two parallel lines. The top line is the real axis r. On it, the tensor occupies an interval from r_min and r_max (here -1.08 to 2.12). The bottom line holds the integer codes from q_min and q_max. Quantization ties the two lines at their ends: q_min maps to r_min and q_max maps to r_max. Somewhere between them, the code Z points straight up at real 0. Every derivation in this part is just algebra on that picture.

تخيّل خطين متوازيين. الخط العلوي هو المحور الحقيقي r. وعليه يشغل الموتر فترة تمتد بين r_min and r_max (هنا من -1.08 إلى 2.12). والخط السفلي يحمل الرموز الصحيحة بين q_min and q_max. التكميم يربط الخطين عند طرفيهما: q_min يقابل r_min وq_max يقابل r_max. وفي مكان ما بينهما يشير الرمز Z مباشرة إلى الصفر الحقيقي 0. كل اشتقاق في هذا الجزء هو مجرد جبر على هذه الصورة.

The signed N-bit rangeمدى الأعداد ذات الإشارة بعدد N من البتات

The codes use Two's complement, the standard signed encoding. With a Bit width (N) of N there are 2^N codes. Half of them are negative and the other half are zero plus the positives. That is why the range is lopsided by one:

تستخدم الرموز two's complement (المتمم الثنائي)، وهو الترميز القياسي للأعداد ذات الإشارة. ومع bit width (N) (عرض بتات) يساوي N يوجد 2^N رمزًا. نصفها سالب، والنصف الآخر هو الصفر مع الأعداد الموجبة. لهذا يكون المدى غير متوازن بفارق واحد:

The slide matrix spans -1.08 to 2.12, a real width of 3.20. The 2-bit codes -2, -1, 0, 1 have 3 gaps between them. Stretch three equal gaps over a width of 3.20 and each gap is 3.20 / 3 = 1.0667 real units. That number is the scale.

مصفوفة الشريحة تمتد من -1.08 إلى 2.12، أي بعرض حقيقي قدره 3.20. والرموز ذات البتين -2, -1, 0, 1 بينها 3 فجوات. إذا مددت ثلاث فجوات متساوية على عرض 3.20 فإن كل فجوة تساوي 3.20 / 3 = 1.0667 وحدة حقيقية. هذا العدد هو المقياس.

The derivation (slide 7)الاشتقاق (الشريحة 7)

Now turn the intuition into algebra. Demand that the affine map send each end of the integer range to the matching end of the real range. That gives two equations, both containing the unknowns S and Z:

الآن حوّل هذا الحدس إلى جبر. اشترط أن ترسل الدالة التآلفية كل طرف من مدى الأعداد الصحيحة إلى الطرف المقابل من المدى الحقيقي. هذا يعطي معادلتين، كل منهما تحتوي المجهولين S وZ:

Subtract the second from the first. Expanding gives S q_max - S Z - S q_min + S Z. The two S Z terms cancel, so the zero point disappears:

اطرح الثانية من الأولى. بعد فك الأقواس نحصل على S q_max - S Z - S q_min + S Z. الحدّان S Z يلغي أحدهما الآخر، فتختفي نقطة الصفر:

You now know one integer step is worth 1.0667. The smallest real value -1.08 sits at code -2. Walk up from there: -1.08 is about one step below zero, so real zero must sit about one code above -2, at code -1. That code is the zero point.

أنت تعرف الآن أن الخطوة الصحيحة الواحدة تساوي 1.0667. وأصغر قيمة حقيقية -1.08 تقع عند الرمز -2. اصعد من هناك: -1.08 تقع تحت الصفر بخطوة واحدة تقريبًا، إذن الصفر الحقيقي يجب أن يقع فوق -2 برمز واحد تقريبًا، أي عند الرمز -1. هذا الرمز هو نقطة الصفر.

The derivation (slide 9)الاشتقاق (الشريحة 9)

Take the bottom endpoint equation and solve it for Z, now that S is known:

خذ معادلة الطرف السفلي وحلّها لإيجاد Z، بعد أن أصبح S معروفًا:

Nothing forces that expression to be a whole number, but Z must be a code. So it is rounded:

لا شيء يجبر هذا التعبير على أن يكون عددًا صحيحًا، لكن Z يجب أن يكون رمزًا. لذلك نقرّبه:

Using the top equation instead gives Z = q_max - r_max / S. Before rounding it is the same number, because S was built to make both ends agree.

لو استخدمت المعادلة العليا بدلًا منها لحصلت على Z = q_max - r_max / S. وقبل التقريب هي العدد نفسه، لأن S بُني أصلًا ليجعل الطرفين متوافقين.

Why Z must be an integer: exact zeroلماذا يجب أن يكون Z عددًا صحيحًا: الصفر الدقيق

Rounding Z costs something. The ends of the range no longer land exactly. With the unrounded Z = -0.9875, code 1 would decode to 1.0667 x 1.9875 = 2.12. With Z = -1 it decodes to 1.0667 x 2 = 2.13, and code -2 to -1.07 rather than -1.08. The whole grid slides by 0.0125S, never more than S/2. The design accepts that small shift to buy something more valuable, the Exact representation of zero. If Z is an integer, then the code q = Z exists, and r = S(Z - Z) = 0 exactly.

تقريب Z له ثمن. طرفا المدى لم يعودا يقعان في مكانهما بالضبط. مع القيمة غير المقرّبة Z = -0.9875 كان الرمز 1 سيُفك إلى 1.0667 x 1.9875 = 2.12. ومع Z = -1 يُفك إلى 1.0667 x 2 = 2.13، والرمز -2 يُفك إلى -1.07 بدلًا من -1.08. الشبكة كلها تنزاح بمقدار 0.0125S، ولا يتجاوز ذلك أبدًا S/2. يقبل التصميم هذه الإزاحة الصغيرة ليكسب شيئًا أثمن، وهو exact representation of zero (التمثيل الدقيق للصفر). إذا كان Z عددًا صحيحًا فإن الرمز q = Z موجود، وr = S(Z - Z) = 0 تمامًا.

Real zero is not a rare value in a neural network. It appears all the time:

الصفر الحقيقي ليس قيمة نادرة في الشبكة العصبية. إنه يظهر طوال الوقت:

• Zero padding. Convolutions pad feature maps with zeros at the borders. Jacob et al. give this as the motivation for exact zero.الحشو بالأصفار (zero padding). الالتفافات (convolutions) تحشو خرائط الخصائص بأصفار عند الحواف. ويذكر Jacob et al. هذا بوصفه الدافع لتمثيل الصفر بدقة.
• ReLU outputs. Every negative pre-activation becomes exactly zero, so a large share of the activations after a ReLU are zero.مخرجات ReLU. كل قيمة سالبة قبل التفعيل تصبح صفرًا تمامًا، لذلك تكون نسبة كبيرة من التفعيلات بعد ReLU أصفارًا.
• Pruned weights. The pruning lectures (04-1 and 04-2) set many weights to exactly zero, and quantizing them must keep them zero.الأوزان المقلّمة (pruned weights). محاضرتا التقليم (04-1 و04-2) تجعلان كثيرًا من الأوزان صفرًا تمامًا، ويجب أن يحافظ تكميمها على كونها صفرًا.

Now suppose Z were fractional, say -0.6. No stored integer decodes to zero. The best the hardware can do is the nearest code -1, which decodes to S(-1 - (-0.6)) = -0.4S. Every padded cell then carries the same -0.4S error. It is systematic rather than random, so it does not average out. It adds up in every convolution window that touches the border, which biases the layer output. A fractional zero point would also need a float subtraction inside the integer pipeline, which part 3 works hard to avoid.

افترض الآن أن Z كسري، مثلًا -0.6. لا يوجد عدد صحيح مخزّن يُفك إلى الصفر. أفضل ما يستطيعه العتاد هو أقرب رمز -1، الذي يُفك إلى S(-1 - (-0.6)) = -0.4S. عندها تحمل كل خلية محشوة الخطأ نفسه -0.4S. هذا الخطأ منهجي (systematic) وليس عشوائيًا، لذلك لا يُلغى بالمتوسط. بل يتراكم في كل نافذة التفاف تلامس الحافة، فينحاز خرج الطبقة. كما أن نقطة الصفر الكسرية تتطلب عملية طرح عشرية داخل خط المعالجة الصحيح (integer pipeline)، وهذا ما يجتهد الجزء 3 في تجنّبه.

Try the explorer below. Drag the ends of the shaded range and watch S and Z update, with the teal arrow always running from code Z to real 0. The small ticks above the real axis are the representable values S(q - Z). One of them always sits exactly on zero, while the range ends drift slightly once Z is rounded. The presets load the slide example and both drills below.

جرّب المستكشف أدناه. اسحب طرفي المدى المظلل وراقب S وZ وهما يتحدّثان، مع السهم الأخضر المزرق الذي يمتد دائمًا من الرمز Z إلى الصفر الحقيقي 0. العلامات الصغيرة فوق المحور الحقيقي هي القيم القابلة للتمثيل S(q - Z). إحداها تقع دائمًا على الصفر تمامًا، بينما ينزاح طرفا المدى قليلًا بعد تقريب Z. الإعدادات الجاهزة تحمّل مثال الشرائح والتمرينين أدناه.

Exam drillsتمارين الامتحان

Start with something tiny: one weight and one input. Say the real weight is w = 0.5 and the real input is x = 1.5, so the real output is y = 0.75. In a quantized network none of these floats exist on the chip. What exists is three integer codes and, written next to each tensor, a scale and a zero point. The question is: given the codes q_w and q_x, which integer q_y should the chip write out, so that S_y(q_y - Z_y) is as close as possible to 0.75?

ابدأ بشيء صغير جداً: وزن واحد ومدخل واحد. لنقل إن الوزن الحقيقي w = 0.5 والمدخل الحقيقي x = 1.5، فيكون المخرج الحقيقي y = 0.75. في الشبكة المكمّمة لا يوجد أي من هذه الأعداد العشرية على الشريحة. الموجود هو ثلاثة رموز صحيحة (integer codes)، ومع كل مصفوفة scale وzero point مكتوبان بجانبها. والسؤال: بمعرفة الرمزين q_w وq_x، ما العدد الصحيح q_y الذي يجب أن تكتبه الشريحة كي تكون S_y(q_y - Z_y) أقرب ما يمكن إلى 0.75؟

The trick is to stop thinking about the codes and think about what they mean. Under Linear quantization, every tensor obeys the same Affine mapping: the real value equals its Scale (S) times the code minus its Zero point (Z). So wherever the real equation has a real number, you may substitute S(q - Z). The layer is Y = WX, and it is the source of the whole derivation.

الحيلة أن تتوقف عن التفكير في الرموز وتفكر في معناها. في Linear quantization تخضع كل مصفوفة للتحويل نفسه، Affine mapping: القيمة الحقيقية تساوي scale مضروباً في الرمز بعد طرح zero point منه. لذلك أينما ظهر عدد حقيقي في المعادلة الحقيقية يمكنك أن تعوّض مكانه S(q - Z). الطبقة هي Y = WX، وهي منطلق الاشتقاق كله.

Three lines of algebraثلاثة أسطر من الجبر

Substitute the affine map for all three tensors. The left side is the output, the right side the product of the two inputs:

عوّض التحويل affine للمصفوفات الثلاث. الطرف الأيسر هو المخرج، والطرف الأيمن حاصل ضرب المدخلين:

The scales are scalars, so they slide out of the product. Divide both sides by S_Y and move Z_Y to the right. This is the form to remember; it says the output code is a rescaled product of zero-shifted input codes, shifted by the output's zero point:

معاملات scale أعداد مفردة (scalars)، لذا تخرج من حاصل الضرب. اقسم الطرفين على S_Y وانقل Z_Y إلى الطرف الأيمن. هذه هي الصيغة التي يجب أن تحفظها؛ فهي تقول إن رمز المخرج هو حاصل ضرب رموز المدخلات بعد طرح نقاط الصفر منها، مُعاداً قياسه، ثم مُزاحاً بنقطة الصفر الخاصة بالمخرج:

Finally, multiply out the brackets. Nothing new happens mathematically, but this expanded form is the one that exposes the cost of each piece, which is what slides 12 to 14 are about:

أخيراً، افتح الأقواس. لا يحدث شيء جديد رياضياً، لكن هذه الصيغة المفكوكة هي التي تكشف تكلفة كل جزء، وهذا موضوع الشرائح 12 إلى 14:

That is the Quantized matrix multiplication. Notice what it buys. Every quantity inside the big bracket is an integer: codes and zero points. The only non-integer in the whole equation is the single factor S_W S_X / S_Y, a constant for the layer that you know before inference begins. So the expensive part, the inner products with millions of multiply-accumulates, can run on integer hardware, and the float only shows up once per output element at the very end. The construction comes from Jacob et al. (CVPR 2018), which is the source cited on every slide in this part.

هذا هو Quantized matrix multiplication. لاحظ ما يمنحك إياه. كل كمية داخل القوس الكبير عدد صحيح: رموز ونقاط صفر. والعدد غير الصحيح الوحيد في المعادلة كلها هو المعامل المفرد S_W S_X / S_Y، وهو ثابت للطبقة تعرفه قبل أن يبدأ الاستدلال. لذلك يمكن تنفيذ الجزء المكلف، أي الضرب الداخلي بملايين عمليات الضرب والجمع التراكمي (multiply-accumulate)، على عتاد الأعداد الصحيحة، ولا يظهر العدد العشري إلا مرة واحدة لكل عنصر من المخرج في النهاية تماماً. هذا البناء مأخوذ من Jacob et al. (CVPR 2018)، وهو المصدر المذكور في كل شريحة من هذا الجزء.

Look at the four terms inside the bracket and ask one question of each: does it change when the input image changes? q_W q_X obviously does: it is the matrix product itself. Z_W q_X does too, because it contains q_X. But Z_X q_W involves only the weights and the input zero point, both frozen after calibration, and Z_W Z_X is two constants. Those last two are the same for every image the model will ever see, so there is no reason to compute them more than once.

انظر إلى الحدود الأربعة داخل القوس واسأل كل حد سؤالاً واحداً: هل يتغير عندما تتغير صورة المدخل؟ q_W q_X يتغير بالطبع، فهو ضرب المصفوفات نفسه. وZ_W q_X يتغير أيضاً لأنه يحتوي على q_X. لكن Z_X q_W يتضمن الأوزان ونقطة الصفر للمدخل فقط، وكلاهما مُثبَّت بعد المعايرة، وZ_W Z_X عبارة عن ثابتين. هذان الحدان الأخيران متطابقان لكل صورة سيراها النموذج، لذلك لا داعي لحسابهما أكثر من مرة.

That is the logic of slide 12. The amber box marks -Z_X q_W + Z_W Z_X as precomputed: it is evaluated offline, when the model is converted, and stored as a constant per output. The big red box marks the whole bracket as N-bit integer multiplications with 32-bit integer additions and subtractions. The blue box on the left is the rescale, and the small box on the right is +Z_Y, an integer addition. Slide 14 adds the last label: the rescale converts back to an N-bit integer.

هذا منطق الشريحة 12. الصندوق الكهرماني (amber) يحدد -Z_X q_W + Z_W Z_X على أنه precomputed (محسوب مسبقاً): يُقيَّم offline عند تحويل النموذج، ويُخزَّن ثابتاً لكل مخرج. والصندوق الأحمر الكبير يحدد القوس كله على أنه عمليات ضرب صحيحة بـ N بت مع عمليات جمع وطرح صحيحة بـ 32 بت. الصندوق الأزرق على اليسار هو إعادة القياس، والصندوق الصغير على اليمين هو +Z_Y، وهو جمع صحيح. وتضيف الشريحة 14 التسمية الأخيرة: إعادة القياس تُرجع القيمة إلى عدد صحيح بـ N بت.

What the scalar notation hidesما تخفيه الكتابة بالأعداد المفردة

The slides write the terms as if q_W and q_X were single numbers. In a real layer they are matrices, and each output entry is a sum over the inner dimension K:

تكتب الشرائح الحدود كأن q_W وq_X عددان مفردان. في الطبقة الحقيقية هما مصفوفتان، وكل عنصر في المخرج مجموع على البعد الداخلي K:

Read it term by term. Z_W q_X is really Z_W times the column sum of q_X (one number per output column). Z_X q_W is really Z_X times the row sum of q_W (one number per output row). And Z_W Z_X is added once per k, so it appears multiplied by K. This is exactly how production kernels such as gemmlowp organize the computation: they compute the row and column sums during packing and add them as a correction afterwards.

اقرأها حداً حداً. Z_W q_X هو في الحقيقة Z_W مضروباً في مجموع عمود q_X (عدد واحد لكل عمود في المخرج). وZ_X q_W هو في الحقيقة Z_X مضروباً في مجموع صف q_W (عدد واحد لكل صف في المخرج). أما Z_W Z_X فيُضاف مرة لكل k، لذلك يظهر مضروباً في K. وهذا بالضبط ما تفعله النوى (kernels) المستخدمة في الإنتاج مثل gemmlowp: تحسب مجاميع الصفوف والأعمدة أثناء التعبئة (packing) ثم تضيفها تصحيحاً بعد ذلك.

Why the accumulator is 32 bitsلماذا المراكم 32 بت

The red box's label pairs N-bit multiplies with 32-bit additions, and the reason is a bit count. Two INT8 codes multiply to at most (-128) x (-128) = 16,384, which needs 16 signed bits. A dot product adds K of these, and each doubling of K can add one more bit, so the sum needs about 16 + log2(K) bits. That is why products go into an 32-bit accumulator: the width has room for the worst case of more than a hundred thousand terms, far more than any real layer has.

تسمية الصندوق الأحمر تقرن عمليات ضرب بـ N بت مع عمليات جمع بـ 32 بت، والسبب عدٌّ للبتات. حاصل ضرب رمزين من نوع INT8 لا يتجاوز (-128) x (-128) = 16,384، ويحتاج 16 بت بإشارة. الضرب النقطي (dot product) يجمع K من هذه النواتج، وكل مضاعفة لـ K قد تضيف بتاً واحداً، لذلك يحتاج المجموع نحو 16 + log2(K) بت. ولهذا تذهب النواتج إلى 32-bit accumulator: فعرضه يتسع لأسوأ حالة تزيد على مئة ألف حد، وهذا أكثر بكثير مما تملكه أي طبقة حقيقية.

Suppose the accumulator for one output holds 5,000 and the layer's rescale factor is M = S_W S_X / S_Y = 0.0072. The output code before adding Z_Y is 5,000 x 0.0072 = 36. Easy on a laptop. On a microcontroller with no floating-point unit, that multiply by 0.0072 is the one operation left in the equation that is not an integer operation. If it stays a float multiply, the promise of Integer-only inference breaks at the last step.

افترض أن المراكم لمخرج واحد يحمل 5,000 وأن معامل إعادة القياس للطبقة هو M = S_W S_X / S_Y = 0.0072. رمز المخرج قبل إضافة Z_Y هو 5,000 x 0.0072 = 36. أمر سهل على حاسوب محمول. لكن على متحكم دقيق بلا وحدة فاصلة عائمة (floating-point unit)، يكون الضرب في 0.0072 هو العملية الوحيدة المتبقية في المعادلة التي ليست عملية أعداد صحيحة. وإذا بقي ضرباً عشرياً، ينكسر وعد Integer-only inference في الخطوة الأخيرة.

The fix is to rewrite M so that it uses only things integer hardware does cheaply. Keep doubling 0.0072 until it lands in [0.5, 1): 0.0144, 0.0288, 0.0576, 0.1152, 0.2304, 0.4608, 0.9216. Seven doublings. So 0.0072 = 2^(-7) x 0.9216. Multiplying by 0.9216 is a Fixed-point multiplication, and multiplying by 2^(-7) is a right shift by seven bits. That is the M0 and bit shift decomposition of slide 13:

الحل أن نعيد كتابة M بحيث لا تستخدم إلا ما ينفذه عتاد الأعداد الصحيحة بتكلفة رخيصة. استمر في مضاعفة 0.0072 حتى تقع في [0.5, 1): 0.0144، 0.0288، 0.0576، 0.1152، 0.2304، 0.4608، 0.9216. سبع مضاعفات. إذن 0.0072 = 2^(-7) x 0.9216. الضرب في 0.9216 هو Fixed-point multiplication (ضرب بفاصلة ثابتة)، والضرب في 2^(-7) هو إزاحة يمينية بسبع بتات. هذا هو تفكيك M0 and bit shift في الشريحة 13:

How M0 becomes an integerكيف يصبح M0 عدداً صحيحاً

M0 is still a real number, so it is stored as a fixed-point integer. With a 32-bit word, Jacob et al. store the int32 nearest to 2^31 M0, which is the Q31 format: the integer represents the fraction value / 2^31. For M0 = 0.9216 that integer is 1,979,120,930. The chip multiplies the accumulator by this integer into a 64-bit product and keeps the top bits (a right shift by 31 with rounding), then shifts right by n with rounding. Because M0 >= 0.5, the stored integer is at least 2^30, so it always uses about 30 significant bits. That is the point of normalizing: a tiny M stored directly in Q31 would waste most of its bits on leading zeros.

M0 ما زال عدداً حقيقياً، لذلك يُخزَّن عدداً صحيحاً بفاصلة ثابتة. مع كلمة من 32 بت، يخزّن Jacob et al. أقرب عدد int32 إلى 2^31 M0، وهذه صيغة Q31: العدد الصحيح يمثل الكسر value / 2^31. بالنسبة لـ M0 = 0.9216 يكون هذا العدد 1,979,120,930. تضرب الشريحة المراكم في هذا العدد لتحصل على حاصل ضرب من 64 بت وتحتفظ بالبتات العليا (إزاحة يمينية بمقدار 31 مع تقريب)، ثم تزيح يميناً بمقدار n مع تقريب. ولأن M0 >= 0.5، يكون العدد المخزّن 2^30 على الأقل، فيستخدم دائماً نحو 30 بتاً ذات دلالة. هذا هو الهدف من التطبيع (normalizing): لو خُزّن M صغير مباشرة بصيغة Q31 لأهدر معظم بتاته على أصفار بادئة.

Try M = 0.3 in the calculator: one doubling gives 0.6, so n = 1 and M0 = 0.6. Try M = 0.5: it is already in range, so n = 0 and M0 = 0.5. The rule is mechanical: n is the number of doublings needed to reach 0.5, and M0 = M x 2^n.

جرّب M = 0.3 في الحاسبة: مضاعفة واحدة تعطي 0.6، إذن n = 1 وM0 = 0.6. جرّب M = 0.5: هي أصلاً داخل المدى، إذن n = 0 وM0 = 0.5. القاعدة آلية: n هو عدد المضاعفات اللازمة للوصول إلى 0.5، وM0 = M x 2^n.

Why M is below 1, and why that is only an observationلماذا M أقل من 1، ولماذا هذه مجرد ملاحظة

S_W S_X is the value of one unit in the accumulator, and the accumulator sums many products, so it spans a far wider range than one output code. S_Y must cover that whole output range in only 2^N levels, so it is usually much larger than S_W S_X, which makes M small. Jacob et al. report that they empirically find it to always be in (0, 1). That is a finding about trained networks, not a theorem: nothing in the algebra forbids S_Y < S_W S_X. The gemmlowp documentation is more careful and says the multiplier is typically less than one.

S_W S_X هو قيمة الوحدة الواحدة في المراكم، والمراكم يجمع نواتج كثيرة، لذلك يمتد على مدى أوسع بكثير من رمز مخرج واحد. يجب أن يغطي S_Y مدى المخرج كله في 2^N مستوى فقط، لذلك يكون عادة أكبر بكثير من S_W S_X، وهذا يجعل M صغيراً. ويذكر Jacob et al. أنهم وجدوه تجريبياً دائماً في (0, 1). هذه نتيجة عن الشبكات المدرّبة، لا نظرية رياضية: لا شيء في الجبر يمنع S_Y < S_W S_X. ووثائق gemmlowp أكثر حذراً، إذ تقول إن المضاعِف يكون عادةً أقل من واحد.

Go back to the cost map and look at the one term that is neither the core product nor precomputable: Z_W q_X. Slide 14 shades it light blue for that reason. Every inference, before or alongside the main multiply, the kernel has to sum each column of the input codes, multiply by Z_W and subtract. That is an extra pass over X, every inference, for every layer. The extra work is smaller than the matrix product itself (Jacob et al. count it as order N^2 additions against 2N^3 for the product), but it costs memory traffic, kernel complexity and energy, and on a tiny device none of that is free.

عد إلى خريطة التكلفة وانظر إلى الحد الوحيد الذي ليس هو حاصل الضرب الأساسي ولا يمكن حسابه مسبقاً: Z_W q_X. لهذا السبب تظلله الشريحة 14 باللون الأزرق الفاتح. في كل استدلال، قبل الضرب الرئيسي أو بالتوازي معه، يجب على النواة (kernel) أن تجمع كل عمود من رموز المدخل، وتضربه في Z_W، ثم تطرحه. هذا مرور إضافي على X، في كل استدلال، ولكل طبقة. العمل الإضافي أصغر من ضرب المصفوفات نفسه (يحسبه Jacob et al. بعدد عمليات جمع من رتبة N^2 مقابل 2N^3 لحاصل الضرب)، لكنه يكلّف حركة ذاكرة وتعقيداً في النواة وطاقة، وعلى جهاز صغير لا شيء من ذلك مجاني.

The slide's question, Z_W = 0?, is the obvious way out. If the weight zero point is zero, the term Z_W q_X vanishes, and so does Z_W Z_X. What remains is

سؤال الشريحة، Z_W = 0?، هو المخرج الواضح. إذا كانت نقطة الصفر للأوزان صفراً، يختفي الحد Z_W q_X، ويختفي معه Z_W Z_X. والمتبقي هو

Now the only runtime work inside the bracket is the integer matrix product, and the only correction is precomputed. This choice is Z_W = 0, and in practice it means quantizing weights with Symmetric quantization, the topic of the next part.

الآن العمل الوحيد وقت التشغيل داخل القوس هو ضرب المصفوفات الصحيح، والتصحيح الوحيد محسوب مسبقاً. هذا الاختيار هو Z_W = 0، ويعني عملياً تكميم الأوزان بـ Symmetric quantization (التكميم المتماثل)، وهو موضوع الجزء التالي.

Why weights can afford itلماذا تستطيع الأوزان تحمّل ذلك

Forcing Z = 0 means real 0 sits in the middle of the integer range, so the scheme is only efficient when the data is spread roughly evenly on both sides of zero. The histogram on slide 14 shows that weights are: the Weight distribution of a trained layer is a narrow bell, peaked at 0, falling off almost symmetrically by about -0.05 and +0.05. Centering the grid at zero wastes almost no levels. Activations after a ReLU are the opposite case, all non-negative, so a symmetric grid would waste half its codes on values that never occur. That is why activations keep a free zero point and weights do not.

فرض Z = 0 يعني أن الصفر الحقيقي 0 يقع في منتصف مدى الأعداد الصحيحة، لذلك لا يكون هذا الأسلوب فعالاً إلا عندما تنتشر البيانات بشكل متوازن تقريباً على جانبي الصفر. ويُظهر المدرج التكراري (histogram) في الشريحة 14 أن الأوزان كذلك: Weight distribution لطبقة مدرّبة جرس ضيق قمته عند 0، ويتلاشى بشكل شبه متماثل عند نحو -0.05 و+0.05. توسيط الشبكة عند الصفر لا يكاد يهدر أي مستوى. أما التنشيطات (activations) بعد ReLU فهي الحالة المعاكسة، كلها غير سالبة، فالشبكة المتماثلة ستهدر نصف رموزها على قيم لا تظهر أبداً. لهذا تحتفظ التنشيطات بنقطة صفر حرة ولا تحتفظ الأوزان بها.

Take two tensors. One is a layer of trained weights, with values scattered from about -2 to about +2 and most of them near 0. The other is the output of a ReLU, every value between 0 and 6. Both need to become 8-bit codes. Should both get the same kind of integer grid?

خذ موترين. الأول طبقة من الأوزان المدرّبة، قيمها منتشرة من حوالي -2 إلى حوالي +2 ومعظمها قريب من 0. والثاني مخرجات ReLU، كل قيمها بين 0 و6. كلاهما يجب أن يتحول إلى رموز بـ8 بت. فهل يجب أن يحصل الاثنان على نفس النوع من شبكة الأعداد الصحيحة؟

So far we have used asymmetric quantization: the float range [r_min, r_max] is stretched onto the code range [q_min, q_max], and the zero point Z lands wherever real 0 happens to fall. In the left half of slide 15 that is somewhere in the middle of the dots, and for the running matrix at 2 bits it was Z = -1. Symmetric quantization removes that freedom. It declares Z = 0 up front and, to make that consistent, quantizes a range centred on zero: [-|r|max, |r|max], where |r|max is the largest absolute value in the tensor.

حتى الآن استخدمنا asymmetric quantization (التكميم غير المتماثل): يُمدّ مدى القيم العشرية [r_min, r_max] على مدى الرموز [q_min, q_max]، وتقع zero point (نقطة الصفر) Z حيثما صادف أن وقع الصفر الحقيقي 0. في النصف الأيسر من الشريحة 15 يقع ذلك في مكان ما وسط النقاط، وفي المصفوفة المرافقة عند 2 بت كانت Z = -1. Symmetric quantization (التكميم المتماثل) يلغي هذه الحرية. فهو يعلن Z = 0 مسبقًا، ولكي يكون ذلك متسقًا يكمّم مدى متمركزًا حول الصفر: [-|r|max, |r|max]، حيث |r|max هي أكبر قيمة مطلقة في الموتر.

The integer side does not change. The codes are still signed N-bit integers with q_min and q_max taken from the table on the slide:

جانب الأعداد الصحيحة لا يتغير. الرموز ما زالت أعدادًا صحيحة بإشارة من N-bit، وقيمتا q_min and q_max مأخوذتان من الجدول الموجود في الشريحة:

Notice the range is already lopsided: there is one more negative code than positive. Keep that in mind; it is the root of the clipping problem in the next concept.

لاحظ أن المدى غير متوازن أصلًا: فيه رمز سالب واحد زيادة على عدد الرموز الموجبة. تذكّر هذا، فهو أصل مشكلة القصّ (clipping) في المفهوم التالي.

Who should be symmetric?من الذي يجب أن يكون متماثلًا؟

The answer depends on the shape of the data. Trained weights have a bell-shaped distribution centred near 0, so a range centred on 0 fits them well and almost no codes go to waste. ReLU outputs are the opposite: every value is 0 or positive. A symmetric grid would reserve the entire negative half of its codes for values that never occur.

الإجابة تعتمد على شكل البيانات. الأوزان المدرّبة لها bell-shaped distribution (توزيع على شكل جرس) متمركز قرب 0، لذلك يناسبها مدى متمركز حول 0، ولا يكاد يضيع أي رمز. مخرجات ReLU عكس ذلك: كل قيمة إما 0 أو موجبة. الشبكة المتماثلة ستحجز النصف السالب كله من رموزها لقيم لا تظهر أبدًا.

Run the running matrix through a symmetric quantizer. Its largest magnitude is 2.12, so the range is [-2.12, 2.12]. How big is one step?

مرّر المصفوفة المرافقة عبر مكمِّم متماثل. أكبر قيمة مطلقة فيها هي 2.12، لذلك المدى هو [-2.12, 2.12]. فكم حجم الخطوة الواحدة؟

Slide 16 puts the two scale formulas side by side. The asymmetric one is the familiar endpoint match from part two:

الشريحة 16 تضع صيغتي المقياس جنبًا إلى جنب. صيغة غير المتماثل هي مطابقة الطرفين المألوفة من الجزء الثاني:

The symmetric one comes from matching only the negative end. With Z = 0, the endpoint equation r_min = S(q_min - Z) becomes -|r|max = S q_min, and q_min = -2^(N-1):

أما صيغة المتماثل فتأتي من مطابقة الطرف السالب فقط. مع Z = 0 تصبح معادلة الطرف r_min = S(q_min - Z) هي -|r|max = S q_min، وq_min = -2^(N-1):

This is full range mode: it uses every code from -2^(N-1) up to 2^(N-1) - 1. For the running matrix in INT8, S = 2.12 / 128 = 0.01656.

هذا هو full range mode (نمط المدى الكامل): يستخدم كل الرموز من -2^(N-1) حتى 2^(N-1) - 1. للمصفوفة المرافقة بصيغة INT8 يكون S = 2.12 / 128 = 0.01656.

The value at the top does not fitالقيمة في الأعلى لا تتسع

The scale was fixed by the negative end. Now quantize the positive end: q = round(2.12 / 0.01656) = 128. But q_max = 127. Code 128 does not exist, so the value is clamped to 127 and comes back as 127 x 0.01656 = 2.103. In general, +|r|max maps to 2^(N-1), one step past q_max, because the signed range has one more negative code than positive.

المقياس حُدّد بواسطة الطرف السالب. الآن كمّم الطرف الموجب: q = round(2.12 / 0.01656) = 128. لكن q_max = 127. الرمز 128 غير موجود، لذلك تُحصر القيمة (clamp) إلى 127 وتعود بقيمة 127 x 0.01656 = 2.103. وبشكل عام، تُحوَّل +|r|max إلى 2^(N-1)، أي خطوة واحدة بعد q_max، لأن المدى ذا الإشارة فيه رمز سالب واحد زيادة على الرموز الموجبة.

Restricted range modeنمط المدى المقيّد

Many deployed toolchains give up the lonely -128 code instead. In restricted range mode the codes run from -(2^(N-1) - 1) to 2^(N-1) - 1, which is [-127, 127] for INT8, and the scale divides by q_max instead:

كثير من سلاسل الأدوات المستخدمة فعليًا تتخلى بدلًا من ذلك عن الرمز الوحيد -128. في restricted range mode (نمط المدى المقيّد) تمتد الرموز من -(2^(N-1) - 1) إلى 2^(N-1) - 1، أي [-127, 127] في INT8، ويُقسم المقياس على q_max بدلًا من ذلك:

Now both +|r|max and -|r|max land exactly on a code, and nothing clips. The cost is one code out of 2^N. TensorFlow Lite stores int8 weights in [-127, 127] with zero point 0, and NVIDIA's int8 workflow (Wu et al.) makes the same choice, noting that losing one value of 256 is insignificant at 8 bits but must be reconsidered at lower bit widths.

الآن تقع كل من +|r|max و-|r|max على رمز بالضبط، ولا يُقصّ شيء. الثمن رمز واحد من أصل 2^N. يخزّن TensorFlow Lite أوزان int8 في [-127, 127] مع نقطة صفر 0، وسير عمل int8 من NVIDIA (Wu et al.) يتخذ الاختيار نفسه، مع ملاحظة أن خسارة قيمة واحدة من 256 لا تُذكر عند 8 بت، لكن يجب إعادة النظر فيها عند عروض بتات أقل.

The trade-off, on the same tensorالمقايضة على نفس الموتر

The running matrix is skewed: its values reach +2.12 but only -1.08. Asymmetric INT8 fits that exactly with S = 3.20 / 255 = 0.01255. Symmetric must cover [-2.12, 2.12] and uses S = 0.01656, about 32% coarser, and the codes below round(-1.08 / 0.01656) = -65 are never used: 63 of 256 codes, roughly a quarter, are wasted. Drag the slider below from a balanced range to a fully one-sided one and watch the symmetric grid stay frozen while the asymmetric one follows the data.

المصفوفة المرافقة منحرفة: قيمها تصل إلى +2.12 لكنها لا تنزل إلا إلى -1.08. التكميم غير المتماثل بـINT8 يطابق ذلك تمامًا بـS = 3.20 / 255 = 0.01255. أما المتماثل فيجب أن يغطي [-2.12, 2.12] ويستخدم S = 0.01656، أي أخشن بحوالي 32%، والرموز الأقل من round(-1.08 / 0.01656) = -65 لا تُستخدم أبدًا: 63 رمزًا من 256، أي ربع الرموز تقريبًا، تضيع. حرّك المنزلق أدناه من مدى متوازن إلى مدى في جهة واحدة بالكامل، وراقب كيف تبقى الشبكة المتماثلة ثابتة بينما تتبع الشبكة غير المتماثلة البيانات.

Here is the payoff. Recall the full expansion of a quantized matrix multiplication from part three, with its four terms inside the bracket:

هنا تأتي الفائدة. تذكّر المفكوك الكامل لـquantized matrix multiplication (ضرب المصفوفات المكمّم) من الجزء الثالث، بحدوده الأربعة داخل القوس:

Sort the terms by what they depend on. q_W q_X is the real work: integer multiply-accumulates. Z_X q_W and Z_W Z_X involve only weights and fixed parameters, so they are precomputed offline. That leaves Z_W q_X: it contains the input, so it has to be recomputed for every new input, as an extra sum over the activations. Set Z_W = 0 and both Z_W q_X and Z_W Z_X disappear:

رتّب الحدود بحسب ما تعتمد عليه. q_W q_X هو العمل الحقيقي: عمليات ضرب وتجميع بالأعداد الصحيحة. Z_X q_W وZ_W Z_X لا تتضمنان إلا الأوزان ومعاملات ثابتة، لذلك تُحسبان مسبقًا (precomputed) خارج وقت التشغيل. يبقى Z_W q_X: فهو يحتوي على المُدخل، لذلك يجب إعادة حسابه لكل مُدخل جديد، كمجموع إضافي على قيم التنشيط. اجعل Z_W = 0 فيختفي كل من Z_W q_X وZ_W Z_X:

At inference time the only work inside the bracket is the N-bit integer product q_W q_X, summed in a 32-bit accumulator. The term Z_X q_W is a constant per output, added once. Outside the bracket, the rescale by S_W S_X / S_Y and the addition of Z_Y are unchanged from part three.

وقت الاستدلال، العمل الوحيد داخل القوس هو حاصل الضرب الصحيح بـN بت q_W q_X، الذي يُجمع في 32-bit accumulator (مجمّع بـ32 بت). الحد Z_X q_W ثابت لكل مخرج، ويُضاف مرة واحدة. وخارج القوس، تبقى rescale (إعادة القياس) بـS_W S_X / S_Y وإضافة Z_Y دون تغيير عن الجزء الثالث.

A real fully-connected layer computes Y = WX + b. Say one output has accumulator scale S_W S_X = 0.0005 and bias b = 0.37. The accumulator holds an integer that means 0.0005 per unit. How do we add 0.37 to it without leaving integer arithmetic?

الطبقة كاملة الاتصال الحقيقية تحسب Y = WX + b. لنفترض أن لأحد المخرجات مقياس مجمّع S_W S_X = 0.0005 وانحيازًا b = 0.37. المجمّع يحمل عددًا صحيحًا كل وحدة فيه تعني 0.0005. فكيف نضيف 0.37 إليه دون أن نغادر الحساب بالأعداد الصحيحة؟

Quantize every quantity, bias included, with its own scale and zero point, then substitute r = S(q - Z) into each one:

كمّم كل كمية، بما فيها الانحياز، بـscale (مقياس) ونقطة صفر خاصين بها، ثم عوّض r = S(q - Z) في كل واحدة منها: