أهداف التعلم والمتطلبات
ستفهم تمثيل الصور، preprocessing، convolution، CNN، transfer learning، والفرق بين classification و detection و segmentation. تحتاج Python و NumPy ومبادئ supervised learning وفكرة tensors.
CNN feature hierarchy
الصورة كبيانات
الصورة الرقمية tensor غالبًا بأبعاد H×W×C أو C×H×W. القيم قد تكون integers من 0 إلى 255 أو floats مطبعة. تغيير color space أو resize أو crop أو normalization يؤثر على المدخلات؛ يجب تطبيق نفس preprocessing في training و inference.
تأكد من channel order، dtype، range، orientation، EXIF rotation، corrupt files، والـ aspect ratio. لا تحول الصور إلى square stretch دون فهم أثر ذلك على الأجسام.
import torch
from torchvision import transforms
from PIL import Image
preprocess = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
image = Image.open("sample.jpg").convert("RGB")
x = preprocess(image).unsqueeze(0)
print(x.shape, x.dtype) # (1, 3, 224, 224), float32قيم mean/std أعلاه مرتبطة بإعدادات pretrained شائعة؛ يجب مطابقتها مع model card أو preprocessing الموصى به للنموذج الذي تستخدمه.
Convolutions و CNN
Convolution kernel ينزلق عبر الصورة ويحسب weighted sums محلية. مشاركة الأوزان تقلل عدد parameters مقارنة بطبقة dense تربط كل pixel بكل neuron. CNN تتعلم features هرمية: edges/textures ثم أجزاء وأنماط أكثر تعقيدًا. stride و padding و kernel size تحدد أبعاد feature maps.
Pooling أو strided convolutions تقلل spatial resolution. هذا مفيد للكلفة لكنه قد يفقد تفاصيل صغيرة؛ لذلك detection و segmentation يحتاجان تصميمًا يحافظ على localization information.
الـ Convolution بإيدك: إزاي الشبكة «بتشوف» حافة
الصورة للكمبيوتر مصفوفة أرقام. الـ convolution عملية واحدة بسيطة: نافذة صغيرة (kernel) بتتحرك على الصورة، وفي كل موضع بنضرب قيمها في قيم الصورة ونجمع. اللي بيتغير هو أرقام الـ kernel — وفي الـ CNN الأرقام دي هي اللي بتتعلّم.
import numpy as np
def conv2d(image, kernel, stride=1, padding=0):
if padding:
image = np.pad(image, padding)
kh, kw = kernel.shape
oh, ow = (image.shape[0] - kh) // stride + 1, (image.shape[1] - kw) // stride + 1
out = np.zeros((oh, ow))
for i in range(oh):
for j in range(ow):
patch = image[i * stride:i * stride + kh, j * stride:j * stride + kw]
out[i, j] = (patch * kernel).sum() # one number per position
return out
def max_pool(x, size=2):
h, w = x.shape[0] // size * size, x.shape[1] // size * size
return x[:h, :w].reshape(h // size, size, w // size, size).max(axis=(1, 3))
img = np.zeros((8, 8)); img[2:6, 3:6] = 1.0 # a bright rectangle on a dark background
sobel_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], float) # responds to left-right changes
sobel_y = sobel_x.T # responds to top-bottom changes
def show(title, a):
print(title)
for r in a:
print(" " + " ".join(f"{v:3.0f}" for v in r))
show("image (8x8):", img)
gx = conv2d(img, sobel_x)
show("\nvertical-edge response (6x6): positive = dark->bright, negative = bright->dark", gx)
magnitude = np.hypot(gx, conv2d(img, sobel_y))
show("\nedge magnitude after 2x2 max-pooling (3x3):", max_pool(magnitude))
print("\noutput size formula: (n + 2p - k) // s + 1")
for n, k, p, s in [(8, 3, 0, 1), (8, 3, 1, 1), (224, 7, 3, 2), (224, 16, 0, 16)]:
print(f" input {n:>3}, kernel {k:>2}, padding {p}, stride {s:>2} -> {(n + 2 * p - k) // s + 1}")
print(f"\nparameters: one 3x3 conv with 64 filters over 3 channels = {3 * 3 * 3 * 64 + 64:,} vs a dense layer on a 224x224x3 image to 64 units = {224 * 224 * 3 * 64 + 64:,}")image (8x8):
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 1 1 1 0 0
0 0 0 1 1 1 0 0
0 0 0 1 1 1 0 0
0 0 0 1 1 1 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
vertical-edge response (6x6): positive = dark->bright, negative = bright->dark
0 1 1 0 -1 -1
0 3 3 0 -3 -3
0 4 4 0 -4 -4
0 4 4 0 -4 -4
0 3 3 0 -3 -3
0 1 1 0 -1 -1
edge magnitude after 2x2 max-pooling (3x3):
3 4 4
4 4 4
3 4 4
output size formula: (n + 2p - k) // s + 1
input 8, kernel 3, padding 0, stride 1 -> 6
input 8, kernel 3, padding 1, stride 1 -> 8
input 224, kernel 7, padding 3, stride 2 -> 112
input 224, kernel 16, padding 0, stride 16 -> 14
parameters: one 3x3 conv with 64 filters over 3 channels = 1,792 vs a dense layer on a 224x224x3 image to 64 units = 9,633,856الـ response: أصفار في كل مكان الصورة فيه ثابتة (جوه المستطيل وبراه)، وقيم كبيرة عند الحواف بس. الإشارة بتقولك اتجاه التغيّر. ده «feature detector»: الـ kernel بيرد بقوة لما يلاقي النمط اللي هو مصمم له.
في الـ CNN محدش بيكتب Sobel بإيده. الـ kernels بتبدأ عشوائية والـ backprop بيعدّلها. اللي بيطلع عمليًا: الطبقات الأولى بتتعلم حواف وألوان (شبه Sobel فعلًا)، اللي بعدها textures، واللي بعدها أجزاء أشياء.
الـ pooling بيصغّر الخريطة وبيدّي تسامح مع الإزاحات الصغيرة: الحافة لو اتحركت pixel هتفضل في نفس خانة الـ pool.
السطر الأخير هو سبب وجود الـ CNN: الـ conv بيشارك نفس الـ weights على كل المواضع (weight sharing)، فعدد الـ parameters مالوش علاقة بحجم الصورة. والسطر 224, 16, 0, 16 → 14 هو بالظبط الـ patch embedding بتاع الـ Vision Transformer: الصورة بتتقطع لـ 14×14 = 196 patch، كل واحدة بتبقى token.
Transfer Learning عمليًا
ابدأ بنموذج pretrained على بيانات كبيرة، واستبدل classification head بعدد الفئات لديك. جرّب أولًا تجميد backbone وتدريب head، ثم فك بعض الطبقات تدريجيًا إن كانت البيانات كافية. حافظ على split على مستوى subject/customer/source لتجنب صور شبه مكررة بين train و test.
import torch
from torch import nn
from torchvision.models import resnet18, ResNet18_Weights
weights = ResNet18_Weights.DEFAULT
model = resnet18(weights=weights)
for parameter in model.parameters():
parameter.requires_grad = False
model.fc = nn.Linear(model.fc.in_features, num_classes)
optimizer = torch.optim.AdamW(model.fc.parameters(), lr=1e-3)
# Train with a DataLoader; validate on a held-out split.
# Use weights.transforms() for the matching inference preprocessing.هذا skeleton وليس training script كاملًا. يجب تعريف dataset و DataLoader و loss و loop و metrics و checkpointing قبل اعتباره مشروعًا قابلًا للتشغيل.
Transfer learning عمليًا: مثال كامل بـ PyTorch
الآلية: backbone متدرّب على ملايين الصور اتعلّم features عامة (حواف، أنسجة، أشكال). بنشيل الـ classification head الأخير ونحط head لعدد الـ classes بتاعتنا. مع داتا قليلة: نجمّد الـ backbone وندرّب الـ head بس. مع داتا أكتر: نفك تجميد الطبقات الأخيرة بـ learning rate أصغر.
import torch, torch.nn as nn
from torchvision import models, datasets, transforms
from torch.utils.data import DataLoader
weights = models.ResNet50_Weights.DEFAULT
preprocess = weights.transforms() # the EXACT resize/crop/normalize used in pretraining
train_tf = transforms.Compose([
transforms.RandomResizedCrop(224, scale=(0.7, 1.0)),
transforms.ColorJitter(0.3, 0.3, 0.2),
transforms.ToTensor(),
transforms.Normalize(mean=weights.transforms().mean, std=weights.transforms().std),
])
train = datasets.ImageFolder("data/train", transform=train_tf)
val = datasets.ImageFolder("data/val", transform=preprocess)
train_dl = DataLoader(train, batch_size=32, shuffle=True, num_workers=4)
val_dl = DataLoader(val, batch_size=64, num_workers=4)
model = models.resnet50(weights=weights)
for p in model.parameters(): # stage 1: freeze the backbone
p.requires_grad = False
model.fc = nn.Linear(model.fc.in_features, len(train.classes))
device = "cuda" if torch.cuda.is_available() else "cpu"
model.to(device)
opt = torch.optim.AdamW(model.fc.parameters(), lr=1e-3, weight_decay=1e-4)
loss_fn = nn.CrossEntropyLoss()
for epoch in range(5):
model.train()
for x, y in train_dl:
x, y = x.to(device), y.to(device)
opt.zero_grad(); loss = loss_fn(model(x), y); loss.backward(); opt.step()
model.eval(); correct = total = 0
with torch.no_grad():
for x, y in val_dl:
pred = model(x.to(device)).argmax(1).cpu()
correct += (pred == y).sum().item(); total += len(y)
print(epoch, "val acc", round(correct / total, 3))
# stage 2 (if enough data): unfreeze layer4 with a 10x smaller learning rate
for p in model.layer4.parameters():
p.requires_grad = True
opt = torch.optim.AdamW([{"params": model.fc.parameters(), "lr": 1e-3},
{"params": model.layer4.parameters(), "lr": 1e-4}], weight_decay=1e-4)نقط بتفرق: (1) الـ normalization والـ resize لازم يطابقوا اللي الـ backbone اتدرّب عليه (weights.transforms()) — وده نفسه لازم يتكرر بالظبط في الـ serving (المعمل تحت). (2) لو الـ val accuracy عالي جدًا من أول epoch، شك في leakage. (3) راقب confusion matrix لكل class مش الـ accuracy الكلي.
Classification و Detection و Segmentation
Image Classification
صورة واحدة ← فئة أو توزيع فئات. لا يحدد مكان الجسم داخل الصورة.
Object Detection
صورة ← bounding boxes + class + score لكل جسم. مفيد عند تعدد الأجسام ومواقعها.
Segmentation
تنبؤ على مستوى pixel: semantic segmentation للفئات، و instance segmentation للفصل بين الأجسام الفردية.
اختيار المهمة يبدأ من السؤال التجاري والـ annotation budget. Bounding boxes أرخص غالبًا من masks الدقيقة، لكن لا تجيب عن نفس الأسئلة.
تقييم الرؤية الحاسوبية
Classification يستخدم precision/recall/F1 و confusion matrix. Detection يستخدم IoU لمقارنة overlap بين predicted و ground-truth boxes، و mAP عبر thresholds/classes. Segmentation يستخدم IoU/Dice على masks. افحص الأداء حسب حجم الجسم والإضاءة والزاوية والكاميرا، لا المتوسط فقط.
تأكد أن test set يمثل ظروف التشغيل. الصور المتتابعة من الفيديو نفسه قد تسبب leakage إذا وزعت عشوائيًا بين train/test. ضع split حسب الفيديو أو الموقع أو الزمن عند الحاجة.
Vision Transformers و Image Embeddings
Vision Transformer يقسم الصورة إلى patches، يحولها إلى embeddings ويستخدم Transformer blocks لالتقاط العلاقات. الأداء يعتمد على pretraining وحجم البيانات والـ resolution والـ compute. Image embeddings تسمح similarity search أو deduplication، لكنها تحتاج تقييمًا على domain-specific pairs.
لا تفترض أن ViT أفضل دائمًا من CNN؛ latency، حجم البيانات، edge hardware، والـ pretrained checkpoints عوامل حاسمة.
Inference Pipeline والنشر
خدمة الصور يجب أن تحدد file size و pixel count والـ formats المقبولة، وتتحقق من decode قبل inference. تعامل مع الصور كمدخلات غير موثوقة: لا تثق في extension أو MIME وحدهما، وحدد timeout و memory limits، واعزل parsing عند الحاجة. احذف metadata الحساسة مثل GPS إذا لم تكن مطلوبة.
راقب preprocessing failures، queue wait، inference latency، throughput، GPU memory، prediction distribution، و quality drift عبر labels متأخرة. افصل model artifact عن API contract، واحتفظ بإصدار preprocessing مع النموذج.
تمارين ومشروع مصغر
- نفذ image classifier لثلاث فئات باستخدام transfer learning.
- قارن frozen backbone مع fine-tuning جزئي.
- اختبر تأثير resize/crop و class imbalance.
- ابنِ endpoint يقبل صورة ويعيد prediction و model version، واختبر corrupt files والملفات الضخمة.
لماذا لا نستخدم accuracy وحدها في detection؟
ما سبب ضرورة حفظ preprocessing version مع model؟
تقييم الـ Object Detection: IoU و NMS و Precision/Recall
import numpy as np
def iou(a, b):
"""Boxes are (x1, y1, x2, y2). Intersection area / union area."""
x1, y1, x2, y2 = max(a[0], b[0]), max(a[1], b[1]), min(a[2], b[2]), min(a[3], b[3])
inter = max(0, x2 - x1) * max(0, y2 - y1)
union = (a[2] - a[0]) * (a[3] - a[1]) + (b[2] - b[0]) * (b[3] - b[1]) - inter
return inter / union if union else 0.0
def nms(boxes, scores, threshold=0.5):
"""Keep the highest-scoring box, drop every remaining box that overlaps it too much, repeat."""
order, keep = list(np.argsort(scores)[::-1]), []
while order:
best = int(order.pop(0)); keep.append(best)
order = [i for i in order if iou(boxes[best], boxes[i]) < threshold]
return keep
truth = [(10, 10, 60, 60), (100, 40, 160, 110)] # two real objects
preds = [(12, 11, 61, 62), (9, 14, 58, 57), (15, 8, 66, 59), # three boxes on object 1
(104, 45, 150, 100), # one loose box on object 2
(200, 200, 240, 240)] # a false alarm
scores = [0.92, 0.85, 0.60, 0.75, 0.55]
print("IoU of each prediction with its best ground-truth box:")
for p, s in zip(preds, scores):
print(f" score={s:.2f} best IoU={max(iou(p, t) for t in truth):.2f}")
kept = nms(preds, scores)
print(f"\nNMS keeps predictions {kept} (dropped {len(preds) - len(kept)} duplicates)")
def evaluate(indices, iou_threshold):
matched, tp = set(), 0
for i in sorted(indices, key=lambda i: -scores[i]): # highest confidence first
best_iou, best_t = max((iou(preds[i], t), k) for k, t in enumerate(truth))
if best_iou >= iou_threshold and best_t not in matched: # each object can be claimed once
matched.add(best_t); tp += 1
fp, fn = len(indices) - tp, len(truth) - tp
return tp / (tp + fp), tp / (tp + fn)
print(f"\n{'setting':<26}{'precision':>10}{'recall':>8}")
for label, idx, thr in [("no NMS, IoU>=0.50", range(len(preds)), 0.5), ("with NMS, IoU>=0.50", kept, 0.5), ("with NMS, IoU>=0.75", kept, 0.75)]:
p, r = evaluate(list(idx), thr)
print(f"{label:<26}{p:>10.2f}{r:>8.2f}")IoU of each prediction with its best ground-truth box:
score=0.92 best IoU=0.89
score=0.85 best IoU=0.81
score=0.60 best IoU=0.76
score=0.75 best IoU=0.60
score=0.55 best IoU=0.00
NMS keeps predictions [0, 3, 4] (dropped 2 duplicates)
setting precision recall
no NMS, IoU>=0.50 0.40 1.00
with NMS, IoU>=0.50 0.67 1.00
with NMS, IoU>=0.75 0.33 0.50IoU هو مقياس «قد إيه الصندوقين متطابقين»: 1.0 تطابق كامل، 0 مفيش تقاطع. الـ detection بيتحسب صح لو الـ IoU مع الحقيقة عدّى threshold.
من غير NMS: الـ detector طلّع 3 صناديق لنفس الجسم. واحد بس بيتحسب true positive والاتنين التانيين false positives — فالـ precision وقعت مع إن «مفيش غلط حقيقي». الـ NMS بيشيل التكرارات.
تشديد الـ IoU لـ 0.75: الصندوق «الواسع شوية» على الجسم التاني ما بقاش يعدّي، فبقى false positive وكمان الجسم بقى false negative. عشان كده mAP بيتذكر دايمًا مع الـ threshold: mAP@0.5 متساهل، وmAP@[0.5:0.95] (متوسط على عتبات كتير) بيعاقب عدم دقة الموضع.
mAP هو الخطوة اللي بعد كده: بتحسب precision/recall عند كل confidence threshold، بتاخد المساحة تحت المنحنى (AP) لكل class، وبعدين المتوسط على الـ classes.
Transfer Learning: الطريق العملي لأغلب المشاريع
الكود ده لم يُنفَّذ (PyTorch و torchvision مش متثبتين في بيئة تجهيز الموسوعة). مكتوب على الـ API الموثق في torchvision.
import torch
from torch import nn
from torchvision import models
weights = models.ResNet18_Weights.DEFAULT
model = models.resnet18(weights=weights)
preprocess = weights.transforms() # the EXACT resize/normalisation the backbone was trained with
for p in model.parameters(): # stage 1: freeze everything
p.requires_grad = False
model.fc = nn.Linear(model.fc.in_features, 5) # new head for our 5 classes (trainable by default)
optimizer = torch.optim.AdamW(model.fc.parameters(), lr=1e-3)
# ... train a few epochs on the head only ...
for p in model.layer4.parameters(): # stage 2 (optional): unfreeze the last block
p.requires_grad = True
optimizer = torch.optim.AdamW([
{"params": model.layer4.parameters(), "lr": 1e-5}, # tiny LR: do not destroy pretrained features
{"params": model.fc.parameters(), "lr": 1e-4},
])أهم سطر هو weights.transforms(): الـ backbone اتدرّب على صور متطبّعة بمتوسط وانحراف معيّنين وحجم معيّن. لو الـ preprocessing في الـ inference مختلف عن التدريب (ترتيب قنوات BGR بدل RGB، resize مختلف)، الدقة بتقع من غير أي error — ده أشهر bug في نشر موديلات الـ vision.
detector بيطلّع 4 صناديق متداخلة لكل عربية. الـ recall ممتاز والـ precision وحشة. الحل الأول؟
موديل تصنيف صور دقته 94% في الـ notebook و61% بعد النشر في خدمة تانية. أرجح سبب؟
خريطة تغطية الدرس
تم ربط الأهداف بالمفاهيم والتمارين داخل هذا الدرس. اعتبر التغطية بداية تعلم وليست إثبات إتقان؛ أكمل التمارين واختبر الحل على بيانات ممثلة قبل استخدامه في الإنتاج.
الداتا قبل الموديل: labeling و augmentation وتقسيم صح
في الـ CV العملي، أغلب التحسن بييجي من الداتا: labels متسقة، تقسيم بيمنع التسريب، و augmentation بيعكس ظروف الإنتاج الحقيقية — مش من تغيير الـ backbone.
- Labeling guidelines مكتوبة: «العلبة اللي ظاهر منها 30% بس تتعلّم؟» «الـ bounding box يشمل الظل؟». من غير قواعد، اتنين labelers هيختلفوا وده سقف لأداء الموديل. قِس الاتفاق بينهم (IoU بين labelers أو kappa للتصنيف).
- Split leakage: صور متتالية من نفس الفيديو، أو نفس المنتج بزوايا مختلفة، في train و test = أرقام وهمية. اقسم بالـ group (video_id، product_id، store_id).
- Augmentation بيعكس الإنتاج: لو الكاميرات في المخزن إضاءتها ضعيفة ← brightness/noise. لو الصور من موبايلات ← rotation بسيطة، blur، JPEG compression. متى ما تعملش augmentation: horizontal flip على نصوص أو أسهم اتجاه، أو rotation كبيرة لو الاتجاه معلومة مهمة.
- Class imbalance: عيوب التصنيع 1% من الصور — استخدم metrics لكل class و sampling/loss weighting، وقيّم على recall العيوب مش accuracy.
عائلات الـ object detection: إيه الفرق اللي يهمك كمهندس
| العائلة | الفكرة | القوة | الضعف |
|---|---|---|---|
| Two-stage (Faster R-CNN) | اقتراح مناطق ← تصنيف وتحسين كل منطقة | دقة عالية تاريخيًا، كويس للأجسام الصغيرة | أبطأ |
| One-stage (YOLO-family، SSD، RetinaNet) | تنبؤ مباشر بالـ boxes والـ classes على grid | سريع، مناسب للـ real-time والـ edge | محتاج NMS وضبط thresholds |
| Anchor-free (FCOS، CenterNet) | تنبؤ بالمراكز/المسافات بدل anchors جاهزة | tuning أقل للـ anchors | — |
| Transformer (DETR وعائلته) | set prediction من غير NMS | pipeline أبسط | تدريب أطول/أتقل عمومًا |
القرار العملي: اختار حسب الـ latency budget والهاردوير (GPU سيرفر؟ edge device؟)، وحجم الأجسام، والترخيص (بعض الـ implementations الشهيرة ليها licenses بتأثر على الاستخدام التجاري — اقرأ الـ license قبل ما تختار)، والقياس على الداتا بتاعتك بـ mAP لكل class (اتشرح IoU و NMS في v2-cv-metrics).
Document AI: الـ CV اللي هيقابلك فعلًا في مشاريع RAG
كـ AI engineer في شركة، احتمال إنك تدرّب detector لعربيات قليل؛ احتمال إنك تتعامل مع PDFs ممسوحة ضوئيًا وفواتير وجداول عالي جدًا. وده CV بالكامل:
- OCR: تحويل الصورة لنص. العربي له تحديات خاصة (الاتصال بين الحروف، التشكيل، الخطوط اليدوية، الاتجاه RTL مع أرقام LTR).
- Layout analysis: تحديد العناوين والفقرات والأعمدة والجداول وترتيب القراءة. OCR من غير layout = نص الأعمدة متداخل وده بيبوّظ الـ chunking.
- Table extraction: الجداول لو اتحولت لنص سطر بسطر بتفقد معناها. استخرجها كـ structure (HTML/Markdown table أو JSON) واعمل لها chunk منفصل.
- الأدوات: خدمات managed (مثلًا Azure AI Document Intelligence) أو مكتبات مفتوحة. القرار: جودة العربي على عينة من مستنداتك، الـ data residency، والتكلفة لكل صفحة.
// Package: Azure.AI.DocumentIntelligence — check the current SDK version and model names in the docs.
public sealed class LayoutExtractor(DocumentIntelligenceClient client)
{
public async Task<ExtractedDocument> ExtractAsync(Stream pdf, CancellationToken ct)
{
var op = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-layout",
BinaryData.FromStream(pdf), cancellationToken: ct);
var result = op.Value;
var sections = result.Paragraphs.Select(p => new Block(p.Role?.ToString() ?? "text", p.Content,
p.BoundingRegions.FirstOrDefault()?.PageNumber ?? 0));
var tables = result.Tables.Select(ToMarkdownTable); // keep tables as tables
return new ExtractedDocument(sections.ToList(), tables.ToList());
}
private static string ToMarkdownTable(DocumentTable t)
{
var grid = new string[t.RowCount, t.ColumnCount];
foreach (var c in t.Cells) grid[c.RowIndex, c.ColumnIndex] = c.Content.Replace("|", "\\|");
var sb = new StringBuilder();
for (var r = 0; r < t.RowCount; r++)
{
sb.Append('|');
for (var c = 0; c < t.ColumnCount; c++) sb.Append(' ').Append(grid[r, c] ?? "").Append(" |");
sb.AppendLine();
if (r == 0) sb.AppendLine("|" + string.Concat(Enumerable.Repeat(" --- |", t.ColumnCount)));
}
return sb.ToString();
}
}
public sealed record Block(string Role, string Text, int Page);
public sealed record ExtractedDocument(List<Block> Blocks, List<string> Tables);Vision-Language Models مقابل موديل متخصص
| المعيار | VLM (LLM بيشوف صور) | موديل متخصص (classifier/detector) |
|---|---|---|
| وقت البداية | دقايق: prompt + صورة | أسابيع: داتا و labels وتدريب |
| المهام المفتوحة («وصّف المشكلة في الصورة») | ممتاز | مش مصمم لده |
| Localization دقيق (boxes، pixels) | ضعيف/غير ثابت غالبًا | ممتاز |
| Throughput وتكلفة لملايين الصور | مكلف وبطيء نسبيًا | رخيص جدًا بعد التدريب |
| Latency على edge/offline | صعب | ممكن |
| الاتساق والقياس | محتاج eval لأن المخرجات نصية ومتغيرة | metrics واضحة |
نمط شائع ناجح: ابدأ بـ VLM كـ prototype وكـ labeler مساعد (يقترح labels والبشر يراجعوا)، ولما الحجم يكبر أو الـ latency يهم، درّب موديل متخصص على الداتا اللي اتجمعت. وفي الحالتين: نفس الـ eval set.
معمل: bug الـ letterbox — preprocessing parity بين التدريب والإنتاج
الـ detectors الحديثة غالبًا بتاخد صورة مربعة (مثلًا 640×640). عشان ما نشوّهش الصورة، بنعمل letterbox: resize يحافظ على النسبة + padding. لما الموديل يرجّع boxes في إحداثيات الـ 640، لازم نرجّعها للصورة الأصلية: نشيل الـ padding الأول وبعدين نقسم على الـ scale. الـ bug الشائع: حد يعامل الموضوع كأنه stretch resize عادي. المعمل بيفترض detector مثالي في إحداثيات الموديل، وبيقيس الضرر من الـ mapping الغلط بس:
import random
random.seed(8)
TARGET = 640 # detector input size (square)
def letterbox_params(w, h, size=TARGET):
"""Resize keeping aspect ratio, then pad to a square. Returns scale and padding."""
s = min(size / w, size / h)
new_w, new_h = round(w * s), round(h * s)
pad_x, pad_y = (size - new_w) / 2, (size - new_h) / 2
return s, pad_x, pad_y
def to_model(box, w, h): # original image coords -> model input coords
s, px, py = letterbox_params(w, h)
x1, y1, x2, y2 = box
return (x1 * s + px, y1 * s + py, x2 * s + px, y2 * s + py)
def back_correct(box, w, h): # model coords -> original coords (undo pad, then scale)
s, px, py = letterbox_params(w, h)
x1, y1, x2, y2 = box
return ((x1 - px) / s, (y1 - py) / s, (x2 - px) / s, (y2 - py) / s)
def back_naive(box, w, h): # the common bug: treat it as a plain stretch-resize
x1, y1, x2, y2 = box
return (x1 * w / TARGET, y1 * h / TARGET, x2 * w / TARGET, y2 * h / TARGET)
def iou(a, b):
ix = max(0, min(a[2], b[2]) - max(a[0], b[0])); iy = max(0, min(a[3], b[3]) - max(a[1], b[1]))
inter = ix * iy
union = (a[2] - a[0]) * (a[3] - a[1]) + (b[2] - b[0]) * (b[3] - b[1]) - inter
return inter / union if union else 0
SHAPES = {"square 1000x1000": (1000, 1000), "landscape 1920x1080": (1920, 1080), "portrait 1080x1920": (1080, 1920), "receipt 600x2400": (600, 2400)}
print(f"{'image':22s}{'scale':>7s}{'pad_x':>7s}{'pad_y':>7s}{'IoU naive':>11s}{'IoU correct':>13s}{'hits@0.5 naive':>16s}")
for name, (w, h) in SHAPES.items():
s, px, py = letterbox_params(w, h)
naive, correct, hits = [], [], 0
for _ in range(200):
bw, bh = random.uniform(0.05, 0.3) * w, random.uniform(0.05, 0.3) * h
x1, y1 = random.uniform(0, w - bw), random.uniform(0, h - bh)
gt = (x1, y1, x1 + bw, y1 + bh)
pred_model = to_model(gt, w, h) # assume a perfect detector in model space
n = iou(gt, back_naive(pred_model, w, h)); c = iou(gt, back_correct(pred_model, w, h))
naive.append(n); correct.append(c); hits += n >= 0.5
print(f"{name:22s}{s:7.3f}{px:7.1f}{py:7.1f}{sum(naive)/200:11.3f}{sum(correct)/200:13.3f}{hits:>11d}/200")image scale pad_x pad_y IoU naive IoU correct hits@0.5 naive
square 1000x1000 0.640 0.0 0.0 1.000 1.000 200/200
landscape 1920x1080 0.333 0.0 140.0 0.254 1.000 53/200
portrait 1080x1920 0.333 140.0 0.0 0.249 1.000 51/200
receipt 600x2400 0.267 240.0 0.0 0.078 1.000 0/200- على الصور المربعة الـ bug مش ظاهر خالص (مفيش padding). لو الـ test set بتاعك صور مربعة أو كلها نفس الأبعاد، الـ bug هيعدّي الـ QA.
- على الصور الـ landscape/portrait أغلب الـ boxes بقت misses، وعلى الإيصالات الطويلة (نسبة 1:4) ولا box صح. الموديل «ممتاز» والمنتج بايظ.
- الدرس العام: preprocessing parity. نفس الـ resize والـ normalization والـ color order (RGB vs BGR) والـ coordinate mapping في التدريب والـ serving، باختبار آلي على صور بأبعاد متنوعة. نفس فكرة الـ feature contract في Applied ML.
Serving من ASP.NET Core: ONNX Runtime للصور
public sealed class ImageClassifier(InferenceSession session, string[] labels) // singleton; session is thread-safe for Run
{
private static readonly float[] Mean = [0.485f, 0.456f, 0.406f]; // must equal the training normalization
private static readonly float[] Std = [0.229f, 0.224f, 0.225f];
public async Task<(string Label, float Prob)> ClassifyAsync(Stream imageStream, CancellationToken ct)
{
using var img = await Image.LoadAsync<Rgb24>(imageStream, ct); // RGB order, like torchvision
img.Mutate(x => x.AutoOrient() // respect EXIF rotation from phones!
.Resize(new ResizeOptions { Size = new(256, 256), Mode = ResizeMode.Max })
.Resize(new ResizeOptions { Size = new(224, 224), Mode = ResizeMode.Crop }));
var input = new DenseTensor<float>([1, 3, 224, 224]); // NCHW
img.ProcessPixelRows(rows =>
{
for (var y = 0; y < 224; y++)
{
var row = rows.GetRowSpan(y);
for (var x = 0; x < 224; x++)
{
input[0, 0, y, x] = (row[x].R / 255f - Mean[0]) / Std[0];
input[0, 1, y, x] = (row[x].G / 255f - Mean[1]) / Std[1];
input[0, 2, y, x] = (row[x].B / 255f - Mean[2]) / Std[2];
}
}
});
using var output = session.Run([NamedOnnxValue.CreateFromTensor(session.InputMetadata.Keys.First(), input)]);
var logits = output.First().AsEnumerable<float>().ToArray();
var probs = Softmax(logits);
var best = Array.IndexOf(probs, probs.Max());
return (labels[best], probs[best]);
}
private static float[] Softmax(float[] z) { var m = z.Max(); var e = z.Select(v => MathF.Exp(v - m)).ToArray(); var s = e.Sum(); return e.Select(v => v / s).ToArray(); }
}ملاحظات إنتاج: (1) AutoOrient: صور الموبايل بتتخزن مقلوبة مع EXIF flag — من غيره الموديل بيشوف صورة متلفّة 90°. (2) الـ resize هنا لازم يطابق الـ weights.transforms() بتاعة التدريب (resize ثم center crop) — اكتب parity test بصور حقيقية يقارن logits الـ Python بالـ .NET. (3) GPU: ONNX Runtime عنده execution providers (CUDA، DirectML…) — قِس الـ latency و throughput مع batching. (4) حدود حجم الملف والأبعاد قبل التحميل (DoS).
Failure modes في الإنتاج: domain shift و preprocessing
- Domain shift: كاميرا جديدة، إضاءة مختلفة، تغليف منتج اتغير ← الأداء بينزل. راقب توزيع الـ confidence ونسبة «low confidence» ومراجعة بشرية لعينة.
- Preprocessing mismatch: (المعمل) letterbox، RGB/BGR، EXIF، normalization.
- Threshold ثابت لكل الـ classes: بعض الـ classes محتاجة threshold أعلى. اضبط لكل class على validation.
- Silent label drift: فريق الـ labeling غيّر التعليمات ← labels جديدة مش متسقة مع القديمة.
- Privacy: صور فيها وشوش/لوحات عربيات/مستندات شخصية — retention و blur وصلاحيات.
Active learning loop: الصور اللي الموديل مش متأكد فيها (confidence قريب من الـ threshold) أو اللي المستخدمين صححوها ← تروح للـ labeling ← تدخل الـ training الجاي. ده أرخص طريقة لتحسين الموديل.
Knowledge check
الـ detector ممتاز على الـ test set، وفي الإنتاج الـ boxes مزاحة على صور الموبايل الطولية. أول حاجة تشك فيها؟
عايز تصنّف 5 مليون صورة منتج يوميًا لـ 12 فئة ثابتة بـ latency قليل. الأنسب؟
تمارين محلولة
1: اكتب اختبار آلي يمنع رجوع bug الـ letterbox
الحل: property-based test: لأبعاد صور عشوائية (نسب من 1:4 لـ 4:1) و boxes عشوائية، back(to_model(box)) ≈ box بفرق أقل من pixel. ويتعمل على نفس الكود اللي في الـ serving (لو .NET، الاختبار في .NET). وكمان golden images بأبعاد غير مربعة في الـ e2e test.
2: عندك 800 صورة بس لـ 4 أنواع عيوب. خطة؟
الحل: transfer learning بـ backbone مجمّد + head، augmentation واقعي، تقسيم بالـ batch/خط الإنتاج، metrics لكل نوع. لو الأداء مش كفاية: VLM لاقتراح labels على صور غير مصنّفة + مراجعة بشرية، و active learning. وقيّم إن recall للعيوب الخطيرة أهم من الـ accuracy.
3: RAG على PDFs ممسوحة فيها جداول أسعار، والإجابات عن الأسعار غلط. تحقق إزاي؟
الحل: افتح الـ chunks المخزنة: هل الجدول اتحول لنص سطر بسطر وفقد ربط الصف بالعمود؟ لو أيوه ← layout extraction بجداول structured و chunk لكل جدول (أو لكل مجموعة صفوف مع الـ header). وبعدين eval بأسئلة أسعار محددة.
أسئلة إنترفيو: Junior → Senior → Staff
(Junior) إيه هو transfer learning وليه بنستخدمه؟
(Senior) إزاي تضمن إن الـ serving بيعمل نفس preprocessing التدريب؟
(Staff) الشركة عايزة «AI يقرأ كل مستندات العملاء». إيه الـ architecture والقرارات؟
المراجع والقراءة الإضافية
الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)
التوثيق الرسمي — Official documentation
مصادر تعليمية ومتقدمة — Third-party & advanced reading
خريطة التغطية: 10 عنصر من الـ Roadmap ومكان شرحه في الدرس
خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.