class AliKhalid:
    name       = "Ali Khalid"
    role       = "AI Engineer & Deep Learning Researcher"
    location   = "Egypt 🇪🇬"

    expertise  = {
        "core"       : ["Reinforcement Learning", "Deep Learning", "LLM Engineering", "FinTech AI"],
        "languages"  : ["Python ★★★★★", "C++ ★★★☆☆", "JavaScript ★★★☆☆", "MATLAB ★★★☆☆"],
        "frameworks" : ["PyTorch", "TensorFlow/Keras", "Stable-Baselines3", "LangChain", "HuggingFace"],
    }

    current    = [
        "🤖  PPO trading agent — custom Gymnasium env with Sharpe-ratio reward",
        "🔬  Transformer attention from mathematical first principles",
        "🦾  LangGraph multi-agent orchestration systems",
    ]

    philosophy = "Bridge mathematics → architecture → deployment"
    open_to    = ["Research collaborations", "Freelance AI projects", "Open-source contributions"]

    def say_hi(self):
        print("Thanks for visiting! Let's build something intelligent together. 🚀")

# Transformer Attention — built from scratch in AI-Researcher
import torch
import torch.nn as nn
import math

class MultiHeadSelfAttention(nn.Module):
    def __init__(self, d_model: int, n_heads: int):
        super().__init__()
        assert d_model % n_heads == 0
        self.d_k     = d_model // n_heads
        self.n_heads = n_heads
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)

    def scaled_dot_product(self, Q, K, V, mask=None):
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        if mask is not None:
            scores = scores.masked_fill(mask == 0, float('-inf'))
        return torch.matmul(torch.softmax(scores, dim=-1), V)

    def forward(self, x):
        B, T, D = x.shape
        Q = self.W_q(x).view(B, T, self.n_heads, self.d_k).transpose(1, 2)
        K = self.W_k(x).view(B, T, self.n_heads, self.d_k).transpose(1, 2)
        V = self.W_v(x).view(B, T, self.n_heads, self.d_k).transpose(1, 2)
        attn = self.scaled_dot_product(Q, K, V)
        out  = attn.transpose(1, 2).contiguous().view(B, T, D)
        return self.W_o(out)

# Transfer Learning workflow — from AI projects
from torchvision.models import efficientnet_b0, EfficientNet_B0_Weights
import torch.nn as nn

def build_classifier(num_classes: int, freeze_backbone: bool = True):
    backbone = efficientnet_b0(weights=EfficientNet_B0_Weights.IMAGENET1K_V1)

    if freeze_backbone:
        for param in backbone.features.parameters():
            param.requires_grad = False  # Freeze pretrained weights

    in_features = backbone.classifier[1].in_features
    backbone.classifier = nn.Sequential(
        nn.Dropout(p=0.3, inplace=True),
        nn.Linear(in_features, 512),
        nn.ReLU(),
        nn.Dropout(p=0.2),
        nn.Linear(512, num_classes)
    )
    return backbone