دليل TensorFlow: من الصفر للاحتراف (إصدار 2026)

ملخص

• TensorFlow 2 يعمل بنظام التنفيذ الفوري (eager-by-default)، ويعتمد بشكل أساسي على Keras، ونفس الكود الذي يعمل على اللابتوب يمكن توسيعه ليعمل على وحدات GPU متعددة وفي بيئات الإنتاج.¹
• بناء النماذج يتم باستخدام Keras Sequential (للمجموعات الخطية)، أو Functional (للفروع والطبقات المشتركة)، أو عن طريق إنشاء فئة فرعية (subclassing) من tf.keras.Model للتحكم الكامل.²³
• نقل البيانات يتم عبر tf.data ودائمًا ما تنتهي سلسلة العمليات بـ .prefetch(tf.data.AUTOTUNE) — حيث إن تغذية مصفوفات NumPy مباشرة تترك وحدات GPU خاملة.⁴⁵
• التدريب يتم باستخدام model.fit() في 90% من الحالات. استخدم tf.GradientTape فقط عندما تحتاج إلى دالة خسارة (loss) غير قياسية، أو مُحسنات (optimizers) متعددة، أو تسجيل بيانات مخصص.⁶
• التوزيع يتم باستخدام tf.distribute.MirroredStrategy (مضيف واحد، وحدات GPU متعددة) أو MultiWorkerMirroredStrategy (مضيفين متعددين) — نفس كود النموذج، فقط قم بتغليف البناء داخل with strategy.scope():.⁷
• الشحن يتم عبر SavedModel: استخدام TF Serving للخوادم، و TF Lite للهواتف/الأجهزة الطرفية، و TF.js للمتصفحات.⁸⁹¹⁰
• يفترض هذا الدليل استخدام TensorFlow 2.x على Python 3.10–3.12. تحقق من وثائق TensorFlow الحالية على tensorflow.org/api_docs لمعرفة الإصدار الدقيق.

ما ستتعلمه

1. إعداد TensorFlow محليًا أو في Google Colab والتحقق من تسريع GPU في سطر واحد.
2. التعامل مع الـ tensors — هيكل البيانات الأساسي — وفهم المقايضة بين التنفيذ الفوري (eager) والرسومي (graph).
3. بناء الشبكات العصبية باستخدام واجهات Keras الثلاث واختيار الواجهة المناسبة للمهمة.
4. بث مجموعات البيانات الكبيرة بكفاءة باستخدام tf.data لضمان بقاء GPU مشغولاً بالكامل.
5. تدريب وتقييم النماذج باستخدام model.fit() بالإضافة إلى الاستدعاءات (callbacks) للإيقاف المبكر، وجداول معدل التعلم، وتسجيل بيانات TensorBoard.
6. كتابة حلقات تدريب مخصصة باستخدام tf.GradientTape عندما لا يكون المستوى العالي من TensorFlow كافيًا.
7. توسيع نطاق التدريب عبر وحدات GPU وأجهزة متعددة باستخدام tf.distribute.
8. تصدير وتقديم النماذج في بيئة الإنتاج عبر TF Serving (للخوادم) أو TF Lite (للأجهزة).

ينتهي كل قسم بكتلة برمجية قابلة للتشغيل ورابط للصفحة ذات الصلة في وثائق TensorFlow الرسمية.

المتطلبات الأساسية

ستحقق أقصى استفادة من هذا الدليل إذا كان لديك:

• Python: الإلمام بالدوال، الفئات (classes)، list comprehensions، وأساسيات NumPy. يوصى بـ Python 3.10+؛ يدعم TensorFlow 2.x إصدارات Python 3.9–3.12.¹¹
• الرياضيات: الجبر الخطي (المتجهات، المصفوفات، الضرب النقطي)، التفاضل والتكامل (الميل/الاشتقاق، المشتقات الجزئية)، وأساسيات الاحتمالات. لا تحتاج إلى دكتوراه؛ تحتاج فقط لمعرفة ما هو الـ gradient ولماذا يشير للأعلى.
• أساسيات تعلم الآلة: تقسيم البيانات (تدريب/تحقق/اختبار)، شكل فرط التخصيص (overfitting)، ولماذا نستخدم مجموعة اختبار مستقلة. إذا كانت هذه المصطلحات جديدة عليك، فابدأ بـ دورة Andrew Ng لتعلم الآلة على Coursera قبل هذا الدليل — فهي لا تزال أفضل مقدمة مجانية.

لا تحتاج إلى GPU للبدء. يوفر لك Google Colab وحدة Tesla T4 مجانية للجلسات القصيرة، ومعظم أمثلة هذا الدليل تعمل هناك في أقل من دقيقة.

إعداد TensorFlow

التثبيت المحلي

# Create a clean virtual environment first
python3 -m venv tf-env
source tf-env/bin/activate     # Windows: tf-env\Scripts\activate

# Install TensorFlow (latest stable)
pip install --upgrade pip
pip install tensorflow

# For GPU support on Linux (CUDA-enabled wheel includes the GPU pieces)
pip install tensorflow[and-cuda]

أمر pip install tensorflow يقوم بتثبيت نسخة الـ CPU فقط على نظام macOS (تستخدم Apple Silicon إضافة Metal، التي تُثبت بشكل منفصل) ونسخة CPU+GPU على نظام Linux عند إضافة [and-cuda].¹¹ على نظام Windows، تم إيقاف دعم GPU الأصلي في TF 2.11 — استخدم WSL2 مع نسخة Linux لتشغيل CUDA.

التحقق من التثبيت

import tensorflow as tf

print("TensorFlow version:", tf.__version__)
print("GPUs visible:", tf.config.list_physical_devices("GPU"))
print("Built with CUDA:", tf.test.is_built_with_cuda())

إذا أعاد GPUs visible قائمة فارغة بينما كنت تتوقع وجود GPU، فهذا يعني أن إصدارات التعريف (driver) أو CUDA لا تتوافق مع نسخة TensorFlow المثبتة. جدول المطابقة على tensorflow.org/install/source#gpu هو المرجع الموثوق.¹¹

Google Colab (مسار بدون تثبيت)

تجاوز كل ما سبق وافتح مفكرة (notebook) على colab.research.google.com. TensorFlow مثبت مسبقًا؛ انتقل إلى بيئة تشغيل GPU عبر Runtime → Change runtime type → GPU. ثم:

import tensorflow as tf
tf.config.list_physical_devices("GPU")
# [PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]

يعد Colab الطريقة الأسهل لمتابعة هذا الدليل، حيث تعمل كل الأمثلة أدناه هناك دون تغيير.

أساسيات TensorFlow

الـ Tensors

الـ tensor هو مصفوفة متعددة الأبعاد لها نوع بيانات dtype (مثل float32) وشكل shape (مثل (32, 224, 224, 3)). إنه هيكل البيانات الوحيد الذي تستهلكه عمليات TensorFlow.

import tensorflow as tf

# Scalar (rank 0)
scalar = tf.constant(3.14)

# Vector (rank 1)
vector = tf.constant([1.0, 2.0, 3.0])

# Matrix (rank 2)
matrix = tf.constant([[1, 2, 3],
                      [4, 5, 6]], dtype=tf.float32)

# 4D tensor — typical image batch (batch, height, width, channels)
images = tf.zeros((32, 224, 224, 3), dtype=tf.float32)

print(matrix.shape, matrix.dtype)
# (2, 3) <dtype: 'float32'>

تعمل العمليات الحسابية لكل عنصر، والاختزالات (reductions)، والبث (broadcasting) بنفس الطريقة التي تعمل بها في NumPy:

a = tf.constant([1.0, 2.0, 3.0])
b = tf.constant([10.0, 20.0, 30.0])

a + b          # [11., 22., 33.]
a * b          # [10., 40., 90.]
tf.reduce_sum(a * b)  # 140.0  (dot product)
tf.linalg.matmul(matrix, tf.transpose(matrix))  # 2x2 result

هناك شيئان يجب معرفتهما لا يتوفران في NumPy:

1. الـ Tensors غير قابلة للتغيير (immutable). كل عملية تنتج tensor جديدًا. للتغيير، استخدم tf.Variable (القسم التالي).
2. الـ Tensors تعيش على جهاز (CPU أو GPU). يتم وضعها تلقائيًا. يخبرك tensor.device بمكانها، ويجبر استخدام with tf.device("/GPU:0"): وضعها في مكان محدد.

← مرجع الـ tensor الكامل: tensorflow.org/api_docs/python/tf/Tensor¹

المتغيرات (Variables)

tf.Variable هي حالة قابلة للتغيير — تُستخدم لأوزان النماذج وأي قيمة يتم تحديثها أثناء التدريب.

# Initialize from a tensor
w = tf.Variable(tf.random.normal((4, 3)), name="weights")

# Update in place — assign(), assign_add(), assign_sub()
w.assign(tf.zeros_like(w))     # set to zeros
w.assign_add(tf.ones_like(w))  # increment by 1

# Read like a tensor
print(w.numpy())

عندما تبني طبقة Keras، تكون معلمات الطبقة عبارة عن كائنات tf.Variable تحت الغطاء. نادرًا ما تقوم بإنشائها يدويًا؛ الإطار يقوم بذلك نيابة عنك.

← tensorflow.org/guide/variable

التنفيذ الفوري (Eager) مقابل الرسومي (Graph)

يعمل TensorFlow 2 بنظام التنفيذ الفوري افتراضيًا: يتم تنفيذ كل سطر Python فورًا ويعيد tensor يمكنك طباعته باستخدام print(). هذا ما جعل TF 2 مكتبة سهلة الاستخدام — حيث كان وضع الرسم البياني الخامل (lazy graph mode) في TF 1 سيئ السمعة.¹²

لكن وضع الـ eager mode يستهلك موارد إضافية. للتدريب في مرحلة الإنتاج، تقوم بتغليف الدالة بـ @tf.function وسيقوم TensorFlow بتتبعها وتحويلها إلى رسم بياني (graph) في أول مرة يتم استدعاؤها، ثم يعيد تشغيل الرسم البياني في كل استدعاء لاحق:

@tf.function
def train_step(x, y, model, loss_fn, optimizer):
    with tf.GradientTape() as tape:
        predictions = model(x, training=True)
        loss = loss_fn(y, predictions)
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    return loss

نفس الدالة تعمل بدون @tf.function (وضع eager) أو معه (وضع graph). استخدم وضع eager أثناء تصحيح الأخطاء (debugging)؛ وأضف @tf.function بمجرد أن تعمل الدالة للحصول على زيادة في السرعة.

← tensorflow.org/guide/intro_to_graphs¹²

بناء النماذج باستخدام Keras

Keras هي واجهة برمجة التطبيقات عالية المستوى في tf.keras. ولها ثلاثة أنماط، لكل منها حالة استخدام مثالية واضحة.

1. Sequential — للمجموعات الخطية

يُستخدم عندما يكون نموذجك عبارة عن قائمة من الطبقات، واحدة تلو الأخرى. معظم الشبكات للمبتدئين تناسب هذا الشكل.

import tensorflow as tf
from tensorflow.keras import layers, Sequential

model = Sequential([
    layers.Input(shape=(28, 28, 1)),
    layers.Conv2D(32, 3, activation="relu"),
    layers.MaxPool2D(),
    layers.Conv2D(64, 3, activation="relu"),
    layers.MaxPool2D(),
    layers.Flatten(),
    layers.Dense(128, activation="relu"),
    layers.Dropout(0.3),
    layers.Dense(10, activation="softmax"),
])

model.compile(optimizer="adam",
              loss="sparse_categorical_crossentropy",
              metrics=["accuracy"])

model.summary()

← tensorflow.org/guide/keras/sequential_model²

2. Functional — للتفريعات، المدخلات المتعددة، والاتصالات المتبقية (residual connections)

يُستخدم عندما يحتوي نموذجك على أكثر من مدخل واحد، أو مخرجات متعددة، أو عندما تغذي طبقة واحدة مسارين (skip connections، التفريع).

inputs = tf.keras.Input(shape=(224, 224, 3))

x = layers.Conv2D(32, 3, activation="relu")(inputs)
x = layers.MaxPool2D()(x)
x = layers.Conv2D(64, 3, activation="relu")(x)

# Skip connection: add the original 32-channel features back
skip = layers.Conv2D(64, 1)(layers.MaxPool2D()(inputs))
x = layers.Add()([x, skip])

x = layers.GlobalAveragePooling2D()(x)
outputs = layers.Dense(10, activation="softmax")(x)

model = tf.keras.Model(inputs, outputs, name="mini_resnet")
model.compile(optimizer="adam",
              loss="sparse_categorical_crossentropy",
              metrics=["accuracy"])

← tensorflow.org/guide/keras/functional³

3. Subclassing — للتحكم الكامل

يُستخدم عندما يكون للمرور الأمامي (forward pass) هيكل ديناميكي (مثل حلقة يعتمد طولها على بيانات الإدخال). إنه النمط الأكثر مرونة والأصعب في تصحيح الأخطاء — الجأ إليه كخيار أخير.

class TwoTowerModel(tf.keras.Model):
    def __init__(self, num_classes):
        super().__init__()
        self.text_dense = layers.Dense(64, activation="relu")
        self.image_dense = layers.Dense(64, activation="relu")
        self.combine = layers.Concatenate()
        self.classifier = layers.Dense(num_classes, activation="softmax")

    def call(self, inputs, training=False):
        text, image = inputs
        t = self.text_dense(text)
        i = self.image_dense(image)
        return self.classifier(self.combine([t, i]))


model = TwoTowerModel(num_classes=5)

← tensorflow.org/guide/keras/custom_layers_and_models

الاختيار بين الأنماط الثلاثة

اجعل خيارك الافتراضي هو Functional. فهو يتعامل مع كل ما يمكن لـ Sequential القيام به بالإضافة إلى معظم ما يمكن لـ Subclassing القيام به، مع الحفاظ على إمكانية التسلسل النظيف إلى SavedModel.

العمل مع البيانات: tf.data

تحميل البيانات هو المكان الذي تضيع فيه معظم مشاريع TensorFlow الوقت. أكبر وسيلة لتحسين الأداء هي استخدام tf.data من البداية إلى النهاية وعدم تغذية مصفوفات NumPy مباشرة إلى model.fit() لأي شيء أكبر من مجموعة بيانات تجريبية صغيرة.⁴

من مصفوفات في الذاكرة

import numpy as np

X = np.random.rand(10000, 32).astype("float32")
y = np.random.randint(0, 10, size=10000)

ds = (tf.data.Dataset.from_tensor_slices((X, y))
      .shuffle(buffer_size=10000, seed=42)
      .batch(32)
      .prefetch(tf.data.AUTOTUNE))

for batch_x, batch_y in ds.take(1):
    print(batch_x.shape, batch_y.shape)
# (32, 32) (32,)

من الملفات (الصور)

ds = tf.keras.utils.image_dataset_from_directory(
    "data/train",
    image_size=(224, 224),
    batch_size=32,
    label_mode="int",
)

# Always finish with prefetch — overlaps data prep with training step
ds = ds.prefetch(tf.data.AUTOTUNE)

من الكتالوج: tensorflow_datasets

import tensorflow_datasets as tfds

(train_ds, val_ds), info = tfds.load(
    "cifar10",
    split=["train", "test"],
    as_supervised=True,
    with_info=True,
)

def normalize(image, label):
    image = tf.cast(image, tf.float32) / 255.0
    return image, label

train_ds = (train_ds
            .map(normalize, num_parallel_calls=tf.data.AUTOTUNE)
            .cache()
            .shuffle(10000)
            .batch(64)
            .prefetch(tf.data.AUTOTUNE))

val_ds = (val_ds
          .map(normalize, num_parallel_calls=tf.data.AUTOTUNE)
          .batch(64)
          .cache()
          .prefetch(tf.data.AUTOTUNE))

← كتالوج TFDS: tensorflow.org/datasets/catalog/overview¹³

قواعد عامة لخطوات معالجة البيانات (Pipeline)

1. .shuffle(buffer) قبل .batch() لضمان خلط كل دفعة.
2. .cache() إذا كانت البيانات تناسب الذاكرة بعد المعالجة المسبقة — فهذا يوفر إعادة تنفيذ .map() في كل دورة تدريبية (epoch).
3. .map(..., num_parallel_calls=tf.data.AUTOTUNE) لتنفيذ المعالجة المسبقة بالتوازي عبر أنوية المعالج (CPU).
4. .prefetch(tf.data.AUTOTUNE) كآخر عملية — لتداخل تحضير الدفعة التالية مع خطوة تدريب الدفعة الحالية.
5. قم بزيادة البيانات (Augment) داخل النموذج (باستخدام layers.RandomFlip، layers.RandomRotation، إلخ)، وليس في مجموعة البيانات، حتى يتم تنفيذ الزيادة على معالج الرسوميات (GPU) وفقط أثناء التدريب.

← دليل الأداء: tensorflow.org/guide/data_performance⁵

التدريب والتقييم

model.fit() والـ callbacks

callbacks = [
    tf.keras.callbacks.EarlyStopping(
        monitor="val_loss",
        patience=5,
        restore_best_weights=True,
    ),
    tf.keras.callbacks.ReduceLROnPlateau(
        monitor="val_loss",
        factor=0.5,
        patience=2,
        min_lr=1e-6,
    ),
    tf.keras.callbacks.TensorBoard(log_dir="./logs"),
    tf.keras.callbacks.ModelCheckpoint(
        filepath="best_model.keras",
        save_best_only=True,
        monitor="val_loss",
    ),
]

history = model.fit(
    train_ds,
    validation_data=val_ds,
    epochs=50,
    callbacks=callbacks,
    verbose=2,
)

ثلاثة أنماط تؤتي ثمارها في كل مرة:

• استخدم دائمًا EarlyStopping مع restore_best_weights=True. وإلا ستحتفظ بأي أوزان كانت لدى النموذج في آخر دورة تدريبية — والتي عادة ما تكون قد تعرضت لفرط التخصيص (overfit).
• سجل دائمًا في TensorBoard. إنه مجاني ويسمح لك بمقارنة عمليات التشغيل بصريًا.
• احفظ دائمًا أفضل نقطة تفتيش (checkpoint) (وليس الأخيرة). فالاثنان يتباعدان بحلول الدورة 5-10 في أي عملية تشغيل غير بسيطة.

← tensorflow.org/api_docs/python/tf/keras/callbacks

التدريب المخصص باستخدام tf.GradientTape

عندما لا يكون model.fit() مناسبًا — مثل استخدام محسنات (optimizers) متعددة، أو حلقات تنافسية بأسلوب GAN، أو التلاعب المخصص بالاشتقاق (gradient)، أو التعلم التعزيزي (RL) — اكتب خطوة التدريب الخاصة بك.

optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)
train_acc = tf.keras.metrics.SparseCategoricalAccuracy()


@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        logits = model(x, training=True)
        loss = loss_fn(y, logits)
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    train_acc.update_state(y, logits)
    return loss


for epoch in range(10):
    train_acc.reset_state()
    for x, y in train_ds:
        loss = train_step(x, y)
    print(f"Epoch {epoch+1}: loss={loss.numpy():.4f} acc={train_acc.result().numpy():.4f}")

أمران يجب معرفتهما:

• المزخرف (decorator) @tf.function هو ما يجعل هذا الكود سريعًا. بدونه، ستعود إلى وضع eager وتفقد حوالي 10 أضعاف من سرعة المعالجة على معالج الرسوميات.
• يجب استدعاء tape.gradient قبل خروج الـ tape عن النطاق؛ فبمجرد انتهاء كتلة with، يختفي الـ tape.

← tensorflow.org/api_docs/python/tf/GradientTape⁶

الدقة المختلطة (Mixed precision)

تحافظ الدقة المختلطة على الأوزان في تنسيق float32 (للاستقرار) ولكنها تجري العمليات الحسابية في تنسيق float16 أو bfloat16 (للسرعة وتوفير الذاكرة). في معالجات NVIDIA من معمارية Ampere أو الأحدث، يؤدي ذلك إلى تسريع التدريب بنحو 2-3 مرات مع فقدان ضئيل جدًا في الدقة.¹⁴

from tensorflow.keras import mixed_precision

mixed_precision.set_global_policy("mixed_float16")
# Build the model AFTER setting the policy

# Output layer should stay in float32 for numerical stability:
outputs = layers.Dense(10, activation="softmax", dtype="float32")(x)

هذا هو كل التغيير المطلوب. يتولى الإطار معالجة قياس الخسارة (loss scaling) تلقائيًا عند التجميع باستخدام model.compile(optimizer="adam", ...) الافتراضي — حيث يغلف المحسن بـ LossScaleOptimizer نيابة عنك.

← tensorflow.org/guide/mixed_precision¹⁴

مشروع: مصنف صور CIFAR-10 باستخدام التعلم بنقل الخبرة (Transfer Learning)

مثال كامل وقابل للتشغيل. افتح Colab، والصق هذا الكود، وانتقل إلى بيئة تشغيل GPU، وسيكون لديك مصنف بدقة اختبار تزيد عن 90% في حوالي 5 دقائق.

import tensorflow as tf
import tensorflow_datasets as tfds
from tensorflow.keras import layers

# 1. Data
(train_ds, test_ds), info = tfds.load(
    "cifar10",
    split=["train", "test"],
    as_supervised=True,
    with_info=True,
)

NUM_CLASSES = info.features["label"].num_classes
IMG_SIZE = 224  # MobileNetV2's preferred input size
BATCH = 64

def preprocess(image, label):
    image = tf.image.resize(image, (IMG_SIZE, IMG_SIZE))
    image = tf.keras.applications.mobilenet_v2.preprocess_input(image)
    return image, label

train_ds = (train_ds
            .map(preprocess, num_parallel_calls=tf.data.AUTOTUNE)
            .cache()
            .shuffle(10000)
            .batch(BATCH)
            .prefetch(tf.data.AUTOTUNE))

test_ds = (test_ds
           .map(preprocess, num_parallel_calls=tf.data.AUTOTUNE)
           .batch(BATCH)
           .cache()
           .prefetch(tf.data.AUTOTUNE))

# 2. Model — frozen MobileNetV2 backbone + new classifier head
base = tf.keras.applications.MobileNetV2(
    input_shape=(IMG_SIZE, IMG_SIZE, 3),
    include_top=False,
    weights="imagenet",
)
base.trainable = False

inputs = tf.keras.Input(shape=(IMG_SIZE, IMG_SIZE, 3))
x = tf.keras.Sequential([
    layers.RandomFlip("horizontal"),
    layers.RandomRotation(0.05),
])(inputs)
x = base(x, training=False)
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dropout(0.2)(x)
outputs = layers.Dense(NUM_CLASSES, activation="softmax")(x)

model = tf.keras.Model(inputs, outputs)

model.compile(
    optimizer=tf.keras.optimizers.Adam(1e-3),
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)

# 3. Train head
history = model.fit(
    train_ds,
    validation_data=test_ds,
    epochs=5,
    callbacks=[
        tf.keras.callbacks.EarlyStopping(patience=2, restore_best_weights=True),
    ],
)

# 4. Fine-tune: unfreeze the top 30 layers of the backbone, very small LR
base.trainable = True
for layer in base.layers[:-30]:
    layer.trainable = False

model.compile(
    optimizer=tf.keras.optimizers.Adam(1e-5),
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)

history_ft = model.fit(
    train_ds,
    validation_data=test_ds,
    epochs=5,
    callbacks=[
        tf.keras.callbacks.EarlyStopping(patience=2, restore_best_weights=True),
    ],
)

# 5. Evaluate and save
loss, acc = model.evaluate(test_ds, verbose=0)
print(f"Test accuracy: {acc:.4ftensorflow.org/guide/keras/transfer_learning


التدريب الموزع (Distributed Training)
تسمح لك واجهة برمجة تطبيقات التوزيع في TensorFlow بتوسيع نطاق التدريب عبر الأجهزة والآلات دون تغيير كود النموذج الخاص بك. تقوم بلف عملية البناء داخل نطاق استراتيجية (strategy scope)؛ ويتولى الإطار الباقي.
تعدد وحدات GPU على جهاز واحد: MirroredStrategy
strategy = tf.distribute.MirroredStrategy()
print(f"Number of devices: {strategy.num_replicas_in_sync}")

with strategy.scope():
    model = build_my_model()         # same code as before
    model.compile(optimizer="adam",
                  loss="sparse_categorical_crossentropy",
                  metrics=["accuracy"])

# Important: scale the global batch size with the number of replicas
GLOBAL_BATCH = 64 * strategy.num_replicas_in_sync
ds = ds.batch(GLOBAL_BATCH).prefetch(tf.data.AUTOTUNE)

model.fit(ds, epochs=10)

تعدد المضيفين (Multi-host): MultiWorkerMirroredStrategy
نفس النمط، بالإضافة إلى متغير بيئة TF_CONFIG على كل عامل (worker) يسرد عنوان كل عامل وفهرس العامل الحالي:


# On worker 0:
export TF_CONFIG='{
  "cluster": {"worker": ["worker0.example:12345", "worker1.example:12345"]},
  "task": {"type": "worker", "index": 0}
}'
python train.py

# On worker 1: same JSON, but "index": 1

strategy = tf.distribute.MultiWorkerMirroredStrategy()
with strategy.scope():
    model = build_my_model()
    model.compile(...)
model.fit(...)

وحدة معالجة الموتر (TPU): TPUStrategy
على Colab، قم بالتبديل إلى بيئة تشغيل TPU، ثم:
resolver = tf.distribute.cluster_resolver.TPUClusterResolver()
tf.config.experimental_connect_to_cluster(resolver)
tf.tpu.experimental.initialize_tpu_system(resolver)
strategy = tf.distribute.TPUStrategy(resolver)

اختيار الاستراتيجية
الأجهزة (Hardware)
الاستراتيجية
GPU واحد
لا شيء — يستخدمه TensorFlow تلقائياً
وحدات GPU متعددة، جهاز واحد
MirroredStrategy
أجهزة متعددة
MultiWorkerMirroredStrategy
Cloud TPU
TPUStrategy
جداول تضمين ضخمة (recsys)
ParameterServerStrategy
← tensorflow.org/guide/distributed_training

الانتقال إلى مرحلة الإنتاج
تنسيق SavedModel هو التنسيق العالمي للتصدير. يستهلكه كل من TF Serving و TF Lite.
التصدير
# Keras-native (preferred for TF 2.x):
model.save("export/model.keras")          # single-file format

# Or the SavedModel directory format (what TF Serving expects):
model.export("export/saved_model")

ينتج model.export() دليلاً مثل:
export/saved_model/
├── saved_model.pb
├── variables/
│   ├── variables.data-00000-of-00001
│   └── variables.index
└── assets/

أعد التحميل باستخدام:
loaded = tf.saved_model.load("export/saved_model")
predictions = loaded(input_tensor)

TF Serving (خوادم HTTP/gRPC)
قم بتشغيل TF Serving في حاوية Docker، وقم بتركيب دليل SavedModel الخاص بك، والوصول إليه عبر REST.
# Save the model to a versioned directory: export/saved_model/1/...
docker pull tensorflow/serving

docker run -p 8501:8501 \
  --mount type=bind,source="$(pwd)/export/saved_model",target=/models/my_model \
  -e MODEL_NAME=my_model \
  -t tensorflow/serving

إرسال طلب توقع:
curl -X POST http://localhost:8501/v1/models/my_model:predict \
  -d '{"instances": [[1.0, 2.0, 3.0, 4.0]]}'

← tensorflow.org/tfx/serving/serving_basic
TF Lite (للموبايل والأجهزة الطرفية)
converter = tf.lite.TFLiteConverter.from_saved_model("export/saved_model")
converter.optimizations = [tf.lite.Optimize.DEFAULT]   # int8 quantization

# For full int8 (smallest + fastest), provide a representative dataset:
def representative_dataset():
    for sample in train_ds.take(100):
        yield [sample[0]]

converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8

tflite_model = converter.convert()
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

التحميل على الجهاز (Python هي أيضاً إحدى بيئات التشغيل المدعومة):
interpreter = tf.lite.Interpreter(model_path="model.tflite")
interpreter.allocate_tensors()

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

interpreter.set_tensor(input_details[0]["index"], input_data)
interpreter.invoke()
predictions = interpreter.get_tensor(output_details[0]["index"])

يتم نشر نفس ملف .tflite على Android (عبر AAR)، و iOS (CocoaPods)، و Raspberry Pi، والمتحكمات الدقيقة (TF Lite Micro، وهي بيئة تشغيل منفصلة).
← tensorflow.org/lite/guide
TF.js (الاستدلال في المتصفح)
pip install tensorflowjs
tensorflowjs_converter \
  --input_format=tf_saved_model \
  export/saved_model \
  web_model

ثم في المتصفح:
import * as tf from '@tensorflow/tfjs';
const model = await tf.loadGraphModel('/web_model/model.json');
const prediction = model.predict(tf.tensor(input));

← tensorflow.org/js

نظرة سريعة على نظام TensorFlow البيئي
ستقابل هذه المكتبات في المشاريع الحقيقية:
المكتبة
الغرض منها
tf.keras
واجهة برمجة التطبيقات القياسية للنماذج. ستستخدمها يومياً.
tf.data
خطوط أنابيب البيانات (Dataset pipelines). كذلك.
tensorflow_datasets (TFDS)
كتالوج لمجموعات البيانات العامة المعدة مسبقاً (MNIST, CIFAR, ImageNet, GLUE, COCO, إلخ).
tensorflow_hub
نماذج مدربة مسبقاً يمكنك إضافتها إلى نموذج Keras بسطر واحد.
tf.distribute
تدريب على وحدات GPU متعددة، ومضيفين متعددين، و TPU دون تغيير كود النموذج.
TFX
خطوط أنابيب إنتاج شاملة: التحقق، التدريب، التقديم، المراقبة.
TensorBoard
تصور التدريب، تحليل الأداء (profiling)، وإسقاطات التضمين (embedding projections).
tf.lite
الاستدلال على الأجهزة (الموبايل، الأنظمة المدمجة، الأجهزة الطرفية).
tensorflow_serving
خادم HTTP/gRPC للاستدلال المجمع وعبر الإنترنت.
tensorflow_js
تشغيل النماذج في المتصفح.
لا تحتاج إليها جميعاً. معظم المشاريع تُشحن باستخدام tf.keras + tf.data + واحد من tf.lite / tensorflow_serving للإنتاج.

الأخطاء الشائعة والأنماط المعتادة
بعض الأشياء التي يقع فيها الجميع في المرة الأولى.
لا تغذِّ مصفوفات NumPy لـ model.fit() في أي عمل جاد
إنه يعمل في الأمثلة البسيطة ولكن GPU سيظل عند استغلال 30%. قم بلف المصفوفات في tf.data.Dataset وأضف .prefetch(tf.data.AUTOTUNE).
أهمية training=True
تتصرف بعض الطبقات (Dropout, BatchNormalization) بشكل مختلف أثناء التدريب مقابل الاستدلال. يتولى model.fit() هذا الأمر نيابة عنك. في حلقة تدريب مخصصة، مرر دائماً training=True إلى model(...) أثناء التدريب و False أثناء التقييم.
عمليات إعادة التتبع في tf.function مكلفة
في كل مرة تستدعي فيها وظيفة مزينة بـ @tf.function بشكل إدخال جديد أو dtype جديد، يقوم TF بتتبع رسم بياني جديد. إذا كان حجم الدفعة (batch size) متغيراً، فاستخدم الحشو (pad) لشكل ثابت أو استخدم input_signature لتثبيت التتبع.
احفظ ملف .keras، وليس الأوزان فقط
يقوم model.save_weights(...) بحفظ المعلمات فقط. بينما يحفظ model.save("file.keras") البنية + الأوزان + حالة المحسن (optimizer state) — وهو الوحيد الذي يمكنك إعادة تحميله دون إعادة بناء النموذج.
لا تستخدم tf.constant داخل حلقة
tf.constant يقوم بتخصيص ذاكرة مع كل استدعاء. إذا كنت تستدعيه داخل حلقة تدريب بنفس القيمة، فقم بإخراجه خارج الحلقة — أو مرر القيمة كمعامل للدالة.
استخدم tf.device بحذر
نادرًا ما نحتاج إلى تحديد الجهاز يدويًا (with tf.device("/GPU:0")) في TensorFlow 2 — فالتوزيع التلقائي موثوق به. لا تلجأ إليه إلا عندما تحاول استخراج آخر 10% من الأداء في خط معالجة متعدد الـ GPU.












الخلاصة
يكافئ TensorFlow مجموعة صغيرة من العادات ويعاقب على الانحراف عنها:

ابنِ باستخدام Keras Functional، ولا تلجأ إلى الـ subclassing إلا عندما تحتاج إلى هيكل ديناميكي.
مرر البيانات باستخدام tf.data + AUTOTUNE prefetch، ولا تستخدم مصفوفات NumPy أبدًا.
درب باستخدام model.fit() + callbacks، وانتقل إلى tf.GradientTape فقط للاحتياجات المخصصة حقًا.
استخدم @tf.function لأي مسار برمجي متكرر — فهي توفر تسريعًا بمقدار 5-10 أضعاف مجانًا.
صدر إلى SavedModel، ثم انشر عبر TF Serving أو TF Lite.
ثق بالأدلة الرسمية — توثيق TensorFlow جيد بشكل استثنائي. كل رابط في هذا المقال يؤدي إلى صفحة تستحق القراءة.

بمجرد أن تصبح هذه النقاط الست طبيعة ثانية لك، فإن بقية الإطار — التدريب الموزع، الدقة المختلطة (mixed precision)، الطبقات المخصصة، خطوط معالجة TFX — ستكون مجرد إضافات تدريجية. لقد قطعت بالفعل معظم الطريق.
الآن اذهب وافتح Colab وقم بتدريب شيء ما.

قراءات ذات صلة

أساسيات التعلم العميق: دليل عملي للشبكات العصبية
احتراف Scikit-learn: دليل كامل لعام 2026 لتعلم الآلة
احتراف تصنيف الصور باستخدام CNN: من الأساسيات إلى الإنتاج
كيف تدعم وحدات GPU ثورة الذكاء الاصطناعي


الحواشي


مرجع TensorFlow API — tensorflow.org/api_docs/python/tf. المصدر الموثوق لكل رمز عام مذكور في هذا الدليل. ↩ ↩2


دليل TensorFlow — نموذج Sequential. ↩ ↩2


دليل TensorFlow — الـ API الوظيفي (Functional). ↩ ↩2


دليل TensorFlow — tf.data: بناء خطوط معالجة إدخال TensorFlow. ↩ ↩2


دليل TensorFlow — أداء أفضل مع API tf.data. ↩ ↩2


مرجع TensorFlow API — tf.GradientTape. ↩ ↩2

دليل TensorFlow — التدريب الموزع باستخدام TensorFlow. ↩ ↩2 ↩3 ↩4


دليل TensorFlow — استخدام تنسيق SavedModel. ↩ ↩2


TensorFlow Serving — نظرة عامة على المعمارية و أساسيات الخدمة. ↩ ↩2 ↩3 ↩4


TensorFlow Lite — دليل مطوري LiteRT (TF Lite). ↩ ↩2 ↩3


تثبيت TensorFlow — تعليمات تثبيت Pip ودعم المنصات، و جدول توافق الإصدارات. ↩ ↩2 ↩3


دليل TensorFlow — مقدمة عن الرسوم البيانية (graphs) و tf.function. ↩ ↩2


TensorFlow Datasets — نظرة عامة على الكتالوج و مرجع TFDS API. ↩ ↩2


دليل TensorFlow — الدقة المختلطة (Mixed precision). ↩ ↩2


TFX — دليل مستخدم TFX. ↩