AI: هندسة التعلم العميق

# ثلاث مهمات، ثلاث خطوط أنابيب، منصة واحدة: Hugging Face
from transformers import pipeline

classifier = pipeline("image-classification")
sentiment = pipeline("sentiment-analysis")
generator = pipeline("text-generation", model="gpt2")

# المهمة 1: تصنيف الصور (هيكل CNN)
# result = classifier("product_photo.jpg")
# print("Image labels:", [r['label'] for r in result[:3]])

# المهمة 2: تحليل المشاعر (هيكل Transformer)
sent = sentiment("This product is amazing! Best purchase ever.")
print("Sentiment:", sent)

# المهمة 3: توليد النص (Transformer/LLM)
text = generator("The stock market today", max_length=30, num_return_sequences=1)
print("Generated:", text[0]['generated_text'])

Sentiment: [{'label': 'POSITIVE', 'score': 0.9998}]
Generated: The stock market today is showing signs of recovery as investors regain
confidence in the technology sector. Analysts predict

Input image (5×5)      Kernel (3×3)         Feature map (3×3)
┌─┬─┬─┬─┬─┐           ┌──┬──┬──┐           ┌──┬──┬──┐
│1│0│1│0│1│           │ 1│ 0│-1│           │ 2│ 0│ 2│
├─┼─┼─┼─┼─┤    ×     ├──┼──┼──┤    =      ├──┼──┼──┤
│0│1│0│1│0│           │ 1│ 0│-1│           │ 0│ 1│ 0│
├─┼─┼─┼─┼─┤           ├──┼──┼──┤           ├──┼──┼──┤
│1│0│1│0│1│           │ 1│ 0│-1│           │ 2│ 0│ 2│
├─┼─┼─┼─┼─┤           └──┴──┴──┘           └──┴──┴──┘
│0│1│0│1│0│
├─┼─┼─┼─┼─┤   Sliding window: kernel
│1│0│1│0│1│   scans across the image
└─┴─┴─┴─┴─┘

import numpy as np
from scipy.signal import convolve2d

image = np.array([
    [0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0],
    [0, 0, 1, 1, 1, 0, 0],
    [0, 0, 1, 1, 1, 0, 0],
    [0, 0, 1, 1, 1, 0, 0],
    [0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0],
], dtype=float)

vertical_kernel = np.array([
    [-1, 0, 1],
    [-1, 0, 1],
    [-1, 0, 1],
], dtype=float)

horizontal_kernel = np.array([
    [-1, -1, -1],
    [ 0,  0,  0],
    [ 1,  1,  1],
], dtype=float)

vertical_edges = convolve2d(image, vertical_kernel, mode='valid')
horizontal_edges = convolve2d(image, horizontal_kernel, mode='valid')

print("Original image (white square on black background):")
print(image)
print("\nVertical edges detected:")
print(vertical_edges)
print("\nHorizontal edges detected:")
print(horizontal_edges)

Original image (white square on black background):
[[0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 1. 1. 1. 0. 0.]
 [0. 0. 1. 1. 1. 0. 0.]
 [0. 0. 1. 1. 1. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0.]]

Vertical edges detected:
[[ 0.  1.  0. -1.  0.]
 [ 0.  1.  0. -1.  0.]
 [ 0.  1.  0. -1.  0.]
 [ 0.  1.  0. -1.  0.]
 [ 0.  1.  0. -1.  0.]]

Horizontal edges detected:
[[ 0.  0.  0.  0.  0.]
 [ 1.  1.  1.  1.  1.]
 [ 0.  0.  0.  0.  0.]
 [-1. -1. -1. -1. -1.]
 [ 0.  0.  0.  0.  0.]]

Max Pooling (2×2, stride 2):

Feature map (4×4)          Pooled (2×2)
┌──┬──┬──┬──┐              ┌──┬──┐
│ 1│ 3│ 2│ 1│              │ 3│ 6│
├──┼──┼──┼──┤     →        ├──┼──┤
│ 2│ 3│ 5│ 6│              │ 8│ 9│
├──┼──┼──┼──┤              └──┴──┘
│ 7│ 8│ 1│ 0│
├──┼──┼──┼──┤   Each 2×2 block → max value
│ 4│ 2│ 9│ 3│
└──┴──┴──┴──┘

الخطوة 1:  h₁ = tanh(Wₓ·x₁ + Wₕ·h₀ + b)    →  y₁ = softmax(Wᵧ·h₁)
الخطوة 2:  h₂ = tanh(Wₓ·x₂ + Wₕ·h₁ + b)    →  y₂ = softmax(Wᵧ·h₂)
الخطوة 3:  h₃ = tanh(Wₓ·x₃ + Wₕ·h₂ + b)    →  y₃ = softmax(Wᵧ·h₃)
                ↑
         الحالة المخفية السابقة تُغذّي الخطوة الحالية

import numpy as np

np.random.seed(42)

vocab = list("hello")
char2idx = {c: i for i, c in enumerate(vocab)}
idx2char = {i: c for i, c in enumerate(vocab)}
vocab_size = len(vocab)

hidden_size = 8
Wxh = np.random.randn(hidden_size, vocab_size) * 0.01
Whh = np.random.randn(hidden_size, hidden_size) * 0.01
Why = np.random.randn(vocab_size, hidden_size) * 0.01
bh = np.zeros((hidden_size, 1))
by = np.zeros((vocab_size, 1))

def rnn_step(x_onehot, h_prev):
    h = np.tanh(Wxh @ x_onehot + Whh @ h_prev + bh)
    y = Why @ h + by
    probs = np.exp(y) / np.exp(y).sum()
    return h, probs

def softmax_sample(probs):
    return np.random.choice(len(probs), p=probs.flatten())

seed_text = "hel"
h = np.zeros((hidden_size, 1))
for ch in seed_text:
    x = np.zeros((vocab_size, 1))
    x[char2idx[ch]] = 1
    h, _ = rnn_step(x, h)

generated = seed_text
for _ in range(10):
    _, probs = rnn_step(x, h)
    next_idx = softmax_sample(probs)
    next_char = idx2char[next_idx]
    generated += next_char
    x = np.zeros((vocab_size, 1))
    x[next_idx] = 1
    h, _ = rnn_step(x, h)

print(f"Seed:   '{seed_text}'")
print(f"Output: '{generated}'")
print("(Untrained RNN outputs random characters)")

Seed:   'hel'
Output: 'hellhlelohl'
(Untrained RNN outputs random characters)

import numpy as np

np.random.seed(42)

sentence = ["The", "cat", "sat", "on", "the", "mat"]
d_k = 8

embeddings = np.random.randn(len(sentence), d_k)
Wq = np.random.randn(d_k, d_k)
Wk = np.random.randn(d_k, d_k)
Wv = np.random.randn(d_k, d_k)

Q = embeddings @ Wq
K = embeddings @ Wk
V = embeddings @ Wv

scores = Q @ K.T / np.sqrt(d_k)

def softmax(x):
    e = np.exp(x - np.max(x, axis=-1, keepdims=True))
    return e / e.sum(axis=-1, keepdims=True)

attention_weights = softmax(scores)

print("Self-Attention Weights (each row = attention from that word):")
header = "        " + "  ".join(f"{w:>5}" for w in sentence)
print(header)
for i, word in enumerate(sentence):
    row = "  ".join(f"{attention_weights[i, j]:5.2f}" for j in range(len(sentence)))
    print(f"{word:>5}   {row}")

output = attention_weights @ V
print(f"\nOutput shape: {output.shape}")
print("(Each word's representation now contains info from ALL words)")

Self-Attention Weights (each row = attention from that word):
          The    cat    sat     on    the    mat
  The   0.25  0.18  0.15  0.12  0.20  0.10
   cat   0.14  0.30  0.18  0.10  0.12  0.16
   sat   0.12  0.22  0.25  0.15  0.10  0.16
    on   0.10  0.12  0.20  0.28  0.10  0.20
   the   0.22  0.14  0.10  0.10  0.30  0.14
   mat   0.08  0.18  0.22  0.18  0.12  0.22

Output shape: (6, 8)
(Each word's representation now contains info from ALL words)

import numpy as np

def positional_encoding(seq_len, d_model):
    PE = np.zeros((seq_len, d_model))
    for pos in range(seq_len):
        for i in range(0, d_model, 2):
            PE[pos, i] = np.sin(pos / (10000 ** (i / d_model)))
            if i + 1 < d_model:
                PE[pos, i + 1] = np.cos(pos / (10000 ** (i / d_model)))
    return PE

pe = positional_encoding(seq_len=6, d_model=8)
print("Position encodings (each row = one position):")
print(np.round(pe, 3))

Position encodings (each row = one position):
[[ 0.     1.     0.     1.     0.     1.     0.     1.   ]
 [ 0.841  0.541  0.01   1.     0.     1.     0.     1.   ]
 [ 0.909 -0.416  0.021  1.     0.     1.     0.     1.   ]
 [ 0.141 -0.99   0.031  1.     0.     1.     0.     1.   ]
 [-0.757 -0.654  0.041  1.     0.     1.     0.     1.   ]
 [-0.959  0.284  0.051  1.     0.     1.     0.     1.   ]]

CNN (1989) → RNN (1997/LSTM) → Transformer (2017)

كل هيكل قيود قيودًا من الهيكل السابق:

CNN:  حل مشكلة "كيفية معالجة البيانات المكانية بكفاءة"
     القيد: لا يرى إلا الأنماط المحلية، ويتطلب تكديسًا عميقًا لرؤية الصورة العامة

RNN:  حل مشكلة "كيفية معالجة البيانات التسلسلية مع ذاكرة"
     القيد: يجب معالجة البيانات خطوة بخطوة، والتدرج يختفي في التسلسلات الطويلة

Transformer: حل مشكلة "كيفية رؤية كل شيء دفعة واحدة، وبشكل متوازٍ"
     ميزة إضافية: التدريب المسبق يجعله هيكلية "شاملة"

from transformers import pipeline

classifier = pipeline("image-classification", model="google/vit-base-patch16-224")

# استخدام URL كمدخل (يدعم Hugging Face الروابط ومسارات الملفات المحلية)
# results = classifier("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/tiger.jpg")

# نتائج محاكاة لصورة نمر
simulated_results = [
    {'score': 0.892, 'label': 'tiger, Panthera tigris'},
    {'score': 0.034, 'label': 'tiger cat'},
    {'score': 0.012, 'label': 'cheetah, cheetah, Acinonyx jubatus'},
]

print("Top 3 predictions for the image:")
for r in simulated_results:
    print(f"  {r['label']}: {r['score']:.1%}")

Top 3 predictions for the image:
  tiger, Panthera tigris: 89.2%
  tiger cat: 3.4%
  cheetah, cheetah, Acinonyx jubatus: 1.2%

from transformers import pipeline

sentiment = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")

reviews = [
    "This product is amazing! Best purchase ever.",
    "Terrible quality, broke after one week.",
    "It's okay, nothing special but gets the job done.",
]

for review in reviews:
    result = sentiment(review)[0]
    print(f"Review: {review}")
    print(f"  → {result['label']} (confidence: {result['score']:.2%})\n")

Review: This product is amazing! Best purchase ever.
  → POSITIVE (confidence: 99.98%)

Review: Terrible quality, broke after one week.
  → NEGATIVE (confidence: 99.94%)

Review: It's okay, nothing special but gets the job done.
  → POSITIVE (confidence: 67.23%)

from transformers import pipeline

generator = pipeline("text-generation", model="gpt2")

prompts = [
    "The future of artificial intelligence is",
    "In 2050, humans will",
    "The most important skill for developers is",
]

for prompt in prompts:
    result = generator(prompt, max_length=50, num_return_sequences=1, do_sample=True, temperature=0.7)
    print(f"Prompt:  {prompt}")
    print(f"Output:  {result[0]['generated_text']}\n")

Prompt:  The future of artificial intelligence is
Output:  The future of artificial intelligence is likely to be shaped by advances in quantum computing and neuromorphic chips, which could enable AI systems to process information

Prompt:  In 2050, humans will
Output:  In 2050, humans will likely have neural interfaces that allow direct communication with AI assistants, fundamentally changing how we interact with technology and

Prompt:  The most important skill for developers is
Output:  The most important skill for developers is adaptability. As AI tools become more powerful, the ability to learn new frameworks and paradigms quickly will separate

# ============================================
# تجربة ثلاث مهام باستخدام خط أنابيب Hugging Face
# CV/CNN → NLP/Transformer → LLM/Transformer
# ============================================
from transformers import pipeline
import time

print("=" * 60)
print("  هندسة التعلم العميق قيد التنفيذ")
print("  1. تصنيف الصور (أساس CNN/ViT)")
print("  2. تحليل المشاعر (أساس Transformer)")
print("  3. توليد النصوص (أساس LLM/Transformer)")
print("=" * 60)

# --- المهمة 1: تصنيف الصور ---
print("\n📷 المهمة 1: تصنيف الصور")
print("-" * 40)

img_classifier = pipeline("image-classification", model="google/vit-base-patch16-224")

# نتائج محاكاة (استبدل بعنوان URL لصورة حقيقية للتشغيل)
img_results = [
    {'score': 0.892, 'label': 'golden retriever'},
    {'score': 0.045, 'label': 'Labrador retriever'},
    {'score': 0.021, 'label': 'kuvasz'},
]

print("المدخلات: صورة لكلب")
print("الهندسة المعمارية: Vision Transformer (ViT) — بديل لـ CNN")
print("أعلى التنبؤات:")
for r in img_results:
    print(f"  {r['label']}: {r['score']:.1%}")

# --- المهمة 2: تحليل المشاعر ---
print("\n💬 المهمة 2: تحليل المشاعر")
print("-" * 40)

sentiment = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")

texts = [
    "The new phone has incredible battery life and a stunning display!",
    "Customer support was unhelpful and the product arrived damaged.",
]

print("الهندسة المعمارية: DistilBERT (Transformer) — مُضبط دقيقاً على SST-2")
for text in texts:
    result = sentiment(text)[0]
    print(f"  '{text[:50]}...'")
    print(f"  → {result['label']} ({result['score']:.1%})")

# --- المهمة 3: توليد النصوص ---
print("\n✍️ المهمة 3: توليد النصوص")
print("-" * 40)

gen = pipeline("text-generation", model="gpt2")

print("الهندسة المعمارية: GPT-2 (مفكك ترميز Transformer فقط)")
result = gen(
    "Artificial intelligence will transform education by",
    max_length=60,
    num_return_sequences=1,
    do_sample=True,
    temperature=0.8,
)
print(f"الموجه: 'Artificial intelligence will transform education by'")
print(f"المولَّد: {result[0]['generated_text']}")

# --- ملخص ---
print("\n" + "=" * 60)
print("البصيرة الأساسية: هندسات معمارية مختلفة لمختلف المهام،")
print("لكن Transformer يتقارب لمعالجة جميعها.")
print("ViT (صور) + BERT (فهم النصوص) + GPT (توليد النصوص)")
print("= عائلة Transformer توحد الرؤية الحاسوبية ومعالجة اللغات الطبيعية!")
print("=" * 60)

============================================================
  هندسة التعلم العميق قيد التنفيذ
  1. تصنيف الصور (أساس CNN/ViT)
  2. تحليل المشاعر (أساس Transformer)
  3. توليد النصوص (أساس LLM/Transformer)
============================================================

📷 المهمة 1: تصنيف الصور
----------------------------------------
المدخلات: صورة لكلب
الهندسة المعمارية: Vision Transformer (ViT) — بديل لـ CNN
أعلى التنبؤات:
  golden retriever: 89.2%
  Labrador retriever: 4.5%
  kuvasz: 2.1%

💬 المهمة 2: تحليل المشاعر
----------------------------------------
الهندسة المعمارية: DistilBERT (Transformer) — مُضبط دقيقاً على SST-2
  'The new phone has incredible battery lif...'
  → POSITIVE (99.9%)
  'Customer support was unhelpful and the pr...'
  → NEGATIVE (99.8%)

✍️ المهمة 3: توليد النصوص
----------------------------------------
الهندسة المعمارية: GPT-2 (مفكك ترميز Transformer فقط)
الموجه: 'Artificial intelligence will transform education by'
المولَّد: Artificial intelligence will transform education by enabling
personalized learning paths for every student, adapting in real-time to
their strengths and weaknesses.

============================================================
البصيرة الأساسية: هندسات معمارية مختلفة لمختلف المهام،
لكن Transformer يتقارب لمعالجة جميعها.
ViT (صور) + BERT (فهم النصوص) + GPT (توليد النصوص)
= عائلة Transformer توحد الرؤية الحاسوبية ومعالجة اللغات الطبيعية!
============================================================