# كيف تُجَدِّد المطوِّر كيف تُجَدِّد المطوِّر
2025-11-09T14:30
## أولاً
إذا كنت تتبع هذه المدونة، فأنت تعلم أنني مهووس قليلاً بالترجمة الآلية.[لقد كتبت عن](/blog/autotranslatingmarkdownfiles), [Name Name Name Name](/blog/backgroundtranslationspt1)خدمات الترجمة التحريرية الأساسية[وحتى](/blog/mostlylucid-nmt-complete-guide)□ □ □ □ □ □ □ □ ٪**لكنني أدركت أنني لم أفسر في الواقع
> كيف
أعمال الترجمة الآلية تحت غطاء المحرك.
ملاحظة: هذا جزء من تجاربي مع منظمة العفو الدولية/طريقة لإنفاق 1000 دولار من ائتمانات "كلوود" على شبكة الإنترنت.
- لقد أطعمت هذه مجموعة من الأوراق، فهمي، أسئلة كان عليّ أن ألفت هذه المقالة.
- إنه ممتع ويملأ فجوة لم أرها ملأت في أي مكان آخر
- لذلك دعونا إصلاح ذلك!
- سيأخذك هذا المقال من "الترجمة هي سحر" إلى "الترجمة هي رياضيات ذكية" عن طريق شرح المفاهيم الرئيسية وراء ترجمة الآلة العصبية بالإنجليزية البسيطة (مع الكثير من الرسوم البيانية وبعض الرموز C# لجعلها ملموسة).
- بنهاية هذا المنصب، ستفهمون:
ما هي الشبكات العصبية الاصطناعية وكيف تتعلّم
[TOC]
## كيف تصبح الكلمات أرقاماً (اختلاسات)
ما معنى "احذر" في AB (النفط: لا يتعلق الأمر بإيلاء الاهتمام)
```mermaid
graph LR
A[Source Sentence] --> B[Convert to Numbers]
B --> C[Neural Network Processing]
C --> D[Convert to Words]
D --> E[Translated Sentence]
```
الطريقة التي يعمل بها بنية العمية
## لماذا استولت المحوِّلات على العالم
لا تقلق إن لم تكن رياضياً سأبقي هذا عملياً وبصرياً قدر الإمكان
### دعونا نغوص في!
الفكرة الأساسية: الترجمة كإصدار عدد
1. هذا هو المفهوم الأول لإخضاع العقل للعقل: ترجمة الآلة العصبية تعامل الترجمة كعملية رياضية بحتة.
2. تغذّي في جملة، النظام يحوّلها إلى أرقام، تؤدّي الملايين من العمليات الرياضية، وتخرج ترجمة.
3. ولكن الانتظار - كيف يمكنك تحويل الكلمات إلى أرقام؟
4. وكيف يمكن للرياضيات أن تكون لغة "فهم" ؟
دعونا نبدأ ببنات البناء.
```mermaid
graph LR
I1[Input 1] -->|weight: 0.8| N[Neuron]
I2[Input 2] -->|weight: -0.3| N
I3[Input 3] -->|weight: 0.5| N
N --> O[Output]
style N stroke-width:4px
```
الشبكات الخلقية الاصطناعية: المؤسسة
```csharp
public class Neuron
{
private double[] weights;
private double bias;
public double Activate(double[] inputs)
{
// Step 1: Multiply each input by its weight and sum them
double sum = bias;
for (int i = 0; i < inputs.Length; i++)
{
sum += inputs[i] * weights[i];
}
// Step 2: Apply activation function (tanh keeps values between -1 and 1)
return Math.Tanh(sum);
}
}
```
قبل أن نتمكن من فهم الترجمة الآلية العصبية، نحن بحاجة إلى فهم الشبكات العصبية الاصطناعية.`Math.Tanh`على الرغم من الاسم الفاخر، فهي في الواقع بسيطة جدا في جوهرها.
### ما هو العصب الإصطناعي؟
الاعصاب الاصطناعي عبارة عن اقتران رياضي
```mermaid
graph LR
subgraph Input Layer
I1[Input 1]
I2[Input 2]
I3[Input 3]
end
subgraph Hidden Layer 1
H1[Neuron 1]
H2[Neuron 2]
H3[Neuron 3]
H4[Neuron 4]
end
subgraph Hidden Layer 2
H5[Neuron 5]
H6[Neuron 6]
H7[Neuron 7]
end
subgraph Output Layer
O1[Output 1]
O2[Output 2]
end
I1 --> H1 & H2 & H3 & H4
I2 --> H1 & H2 & H3 & H4
I3 --> H1 & H2 & H3 & H4
H1 --> H5 & H6 & H7
H2 --> H5 & H6 & H7
H3 --> H5 & H6 & H7
H4 --> H5 & H6 & H7
H5 --> O1 & O2
H6 --> O1 & O2
H7 --> O1 & O2
```
يَدِِِِِِدِِِِِِِِِِِِِِِِِِِِِِِِِِِِِِِِِِِِِِِِِِ
- يقوم بتثبيت كل مدخل بالوزن (ما مدى أهمية هذا المدخل؟)
- يسندها كلها إلى أعلى
- ينطبق "معامل الفعالية النشطة" إلى توليد مخرج
### هذا هو التمثيل البصري:
لنجعل هذا مثبتاً ببعض الرموز C#:
```mermaid
graph TD
A[Start with Random Weights] --> B[Feed in Training Example]
B --> C[Network Makes Prediction]
C --> D{Is Prediction Correct?}
D -->|No| E[Calculate Error]
E --> F[Adjust Weights Slightly]
F --> B
D -->|Yes| G[Try Next Example]
G --> B
style E stroke-width:2px
style F stroke-width:2px
```
الدالة الدالة التحفيز (في هذه الحالة)**هو ما يجعل الشبكات العصبية مثيرة للاهتمام.**فهو يُدخل غير الخطي، مما يسمح للشبكة بتعلم أنماط معقدة.
بدونه، بغض النظر عن عدد الخلايا العصبية التي جمعتها معاً، سيكون لديك فقط اقتران خطي مبهرج.
```csharp
public class SimpleNeuralNetwork
{
private double learningRate = 0.01;
private Neuron[] neurons;
public void Train(TrainingExample[] examples, int epochs)
{
for (int epoch = 0; epoch < epochs; epoch++)
{
foreach (var example in examples)
{
// Forward pass: make a prediction
double prediction = Predict(example.Input);
// Calculate error
double error = example.ExpectedOutput - prediction;
// Backward pass: adjust weights
// (simplified - real networks use backpropagation)
AdjustWeights(error * learningRate);
}
}
}
}
```
من العنان إلى الشبكات**يحدث السحر عندما تربط الآلاف أو الملايين من هذه الخلايا العصبية معاً في طبقات:**كل طبقة "تكيف" تمثيل المدخلات، وتستخرج الأنماط التجريدية بشكل متزايد.
## الترجمة التحريرية:
الطبقات المبكّرة قد تكتشف "هذا هو فعل" أو "هذه الكلمة هي ماضٍ من التوتر"
### الطبقات الوسطى قد تكتشف "هذا سؤال" أو "هذا حول الطقس"
الطبقات المتأخرة تجمع هذه إلى "ترجمة هذا كسؤال مهذب حول طقس الغد"
```csharp
// Don't do this!
var wordToNumber = new Dictionary
{
{"cat", 1},
{"dog", 2},
{"king", 3},
{"queen", 4},
{"man", 5},
{"woman", 6}
};
```
كيفية تعلم الشبكات: عملية التدريب
### هذا هو الجزء الذكي: نحن لا نضع كل تلك الأوزان يدوياً.
وتتعلمهم الشبكة من الامثلة !**هذه العملية دُعيت**الميـج
```csharp
public class WordEmbedding
{
// Each word is represented by a vector of floats
private Dictionary embeddings;
public float[] GetEmbedding(string word)
{
return embeddings[word]; // e.g., [0.2, -0.5, 0.8, 0.1, ...]
}
// Calculate similarity between two words
public double Similarity(string word1, string word2)
{
var vec1 = GetEmbedding(word1);
var vec2 = GetEmbedding(word2);
// Cosine similarity: how "aligned" are the vectors?
return CosineSimilarity(vec1, vec2);
}
private double CosineSimilarity(float[] a, float[] b)
{
double dot = 0, magA = 0, magB = 0;
for (int i = 0; i < a.Length; i++)
{
dot += a[i] * b[i];
magA += a[i] * a[i];
magB += b[i] * b[i];
}
return dot / (Math.Sqrt(magA) * Math.Sqrt(magB));
}
}
```
```mermaid
graph TD
subgraph "2D Projection of 300D Space"
King[King
0.8, 0.6]
Queen[Queen
0.75, 0.55]
Man[Man
0.3, 0.2]
Woman[Woman
0.25, 0.15]
Dog[Dog
-0.6, 0.4]
Cat[Cat
-0.65, 0.38]
end
King -.similar.-> Queen
Man -.similar.-> Woman
Dog -.similar.-> Cat
King -.same vector.-> Man
Queen -.same vector.-> Woman
```
بالنسبة لكل إجابة خاطئة، تستنتج الشبكة "أي الأوزان هي الأكثر مسؤولية عن هذا الخطأ؟" وتحوّلها قليلاً.`king - man + woman ≈ queen`
```csharp
public float[] AnalogicalReasoning(string a, string b, string c)
{
// king - man + woman = ?
var vecA = GetEmbedding(a); // king
var vecB = GetEmbedding(b); // man
var vecC = GetEmbedding(c); // woman
var result = new float[vecA.Length];
for (int i = 0; i < vecA.Length; i++)
{
result[i] = vecA[i] - vecB[i] + vecC[i];
}
// Find the word closest to this vector
return FindClosestWord(result); // Should return "queen"
}
```
### وبعد رؤية ملايين الامثلة ، تستقر الاوزان في قيم تعمل بشكل جيد .
هذه نسخة مبسطة في C#:
```mermaid
graph LR
A["The cat sat on the mat"] --> B[Train Neural Network]
B --> C["cat → [0.1, 0.5, -0.3, ...]"]
B --> D["sat → [0.2, -0.1, 0.4, ...]"]
B --> E["mat → [0.15, 0.45, -0.25, ...]"]
```
الشبكات الحقيقية التي تستخدم خوارزمية أكثر تطوراً تدعى
##
الذي يقوم بكفاءة بحساب كيفية تعديل الأوزان في كامل الشبكة، لكن المبدأ هو نفسه: تعلم من الأخطاء.
```mermaid
graph TD
subgraph English
E1[The]
E2[cat]
E3[sat]
E4[on]
E5[the]
E6[mat]
end
subgraph French
F1[Le]
F2[chat]
F3[s'est assis]
F4[sur]
F5[le]
F6[tapis]
end
E2 -. focus 90% .-> F2
E3 -. focus 70% .-> F3
E4 -. focus 80% .-> F4
E6 -. focus 85% .-> F6
E1 -. focus 30% .-> F1
```
**ترجمة اللغة إلى رياضيات**الآن وصلنا إلى التحدي الرئيسي الأول: كيف نغذي الكلمات في شبكة عصبية؟
### نحن بحاجة إلى تحويل النص إلى أرقام.
المشكلة مع التر تش تشفر مع مُرْفِز مُرْفَز مُرْفَز مُرْفَز مُرْفَز مُرفَز مُرفَز مَ مَ مَ مَ مُرفَز مَ مَ مَ مَ مَ مَ مَ مَ مَ مَ تشفر مَ مَ مَ مَ مَ مَ مَ مَ مَ مَ تشفر مَ مَ مَ مَ مَ مَ مَ مَ مَ مَ مَ مَ مَ مَ مَ مَ مَ مَ مَ مَ م تش تش تش تش تش تش تش تش تش تشز مَ مَ مَ مَ مَ مَ مَ مَ مَ مَ مُ مُ مُ مُ مُ م تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش م م م م م م م م م م م م م م م م مُ م- م- م- م- م- م- م- م- م م- م- م- م- م- م- م م- م- م تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش م م م م تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش م م م م م م م م م م م م م م م م م م تش تش م م م م م م م م م م م م م م م م م م م م م م م تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش تش م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م م تش تش تش تش تش تش تش م م م م م م م م م م م م م م م م م م م
```csharp
public class AttentionMechanism
{
// Calculate attention weights for each source word
public double[] CalculateAttention(
float[] currentTargetState, // Where we are in translation
float[][] sourceWordStates) // All source words
{
int sourceLength = sourceWordStates.Length;
double[] scores = new double[sourceLength];
// Step 1: Calculate relevance scores
for (int i = 0; i < sourceLength; i++)
{
scores[i] = DotProduct(currentTargetState, sourceWordStates[i]);
}
// Step 2: Convert to probabilities (softmax)
return Softmax(scores);
}
public float[] ApplyAttention(
double[] attentionWeights,
float[][] sourceWordStates)
{
// Create weighted average of source words
int dim = sourceWordStates[0].Length;
float[] result = new float[dim];
for (int i = 0; i < sourceWordStates.Length; i++)
{
for (int j = 0; j < dim; j++)
{
result[j] += (float)(attentionWeights[i] * sourceWordStates[i][j]);
}
}
return result;
}
private double[] Softmax(double[] scores)
{
double[] result = new double[scores.Length];
double sum = 0;
for (int i = 0; i < scores.Length; i++)
{
result[i] = Math.Exp(scores[i]);
sum += result[i];
}
for (int i = 0; i < scores.Length; i++)
{
result[i] /= sum;
}
return result;
}
private double DotProduct(float[] a, float[] b)
{
double sum = 0;
for (int i = 0; i < a.Length; i++)
{
sum += a[i] * b[i];
}
return sum;
}
}
```
النهج الساذج هو "واحد-حارس-الترميز" --تخصيص كل كلمة رقماً فريداً:
1. ولكن هذا له مشكلة ضخمة: الأعداد تعسفية.
2. الشبكة لا تستطيع أن تقول أن "القط" و"الكلب" متشابهان أكثر من "القط" و"الكوين".
3. الأرقام 1 و 2 لا تعني أي شيء
4. الحل : الكلمات
### وبدلاً من ذلك، نمثل كل كلمة على أنها
(ن)
```mermaid
graph TD
subgraph "English (Source)"
E1[The]
E2[agreement]
E3[on]
E4[the]
E5[European]
E6[Economic]
E7[Area]
end
subgraph "German (Target)"
G1[Das]
G2[Abkommen]
G3[über]
G4[den]
G5[Europäischen]
end
E1 -->|0.8| G1
E2 -->|0.9| G2
E3 -->|0.6| G3
E4 -->|0.3| G3
E5 -->|0.85| G5
E6 -->|0.7| G5
```
من الأعداد، عادة 300 إلى 1000 أبعاد.
### تتشابه الكلمات للحصول على متجهات متشابهة:
هذا ما يجعل التزكية سحرية - أنها تلتقط العلاقات الدلالية:**المثال الشهير:**كيف تُعلَّم التعاليم ؟
```mermaid
graph LR
subgraph "Self-Attention for 'bank'"
B[bank]
R[river]
W[water]
F[fish]
end
B -.high attention.-> R
B -.high attention.-> W
B -.medium attention.-> F
```
تُتَعَلَّم الأسر من خلال تدريب شبكة عصبية على مهمة بسيطة: "توقع الكلمات المحيطة".
## والفكرة هي أن الكلمات التي تظهر في سياقات متشابهة ينبغي أن تكون لها معان متشابهة.
بعد التدريب على مليارات الجمل، الكلمات التي تظهر في سياقات متشابهة ينتهي بها المطاف بدمجات متشابهة. "Cat" و"Dog" كلاهما يظهران بالقرب من "pet" و"fed" و"come" و"compecte"، وبالتالي فإن دمجهما ينتهيان معاً.**المصدر: الـ الـ مُغيّر الـ مُستخدِر الـ مُغيّر**هذه هي البصيرة الحرجة: عند ترجمة "القط جلس على السجادة" إلى الفرنسية،
```mermaid
graph LR
subgraph Encoder
E1[Word Embeddings] --> E2[Self-Attention Layer 1]
E2 --> E3[Self-Attention Layer 2]
E3 --> E4[Self-Attention Layer N]
E4 --> E5[Contextual Representations]
end
subgraph Decoder
D1[Previous Translations] --> D2[Self-Attention]
D2 --> D3[Cross-Attention to Encoder]
D3 --> D4[Feed Forward]
D4 --> D5[Next Word Prediction]
end
E5 -.provides context.-> D3
```
### الموضوع
هو آلية تسمح للشبكة "بالتركيز" على أجزاء مختلفة من المدخلات عند توليد كل كلمة مخرج.
```csharp
public class TransformerEncoder
{
private WordEmbedding wordEmbedding;
private SelfAttentionLayer[] layers;
public float[][] Encode(string[] sourceWords)
{
// Step 1: Convert words to embeddings
float[][] embeddings = sourceWords
.Select(w => wordEmbedding.GetEmbedding(w))
.ToArray();
// Step 2: Add positional encoding (so network knows word order)
float[][] withPositions = AddPositionalEncoding(embeddings);
// Step 3: Apply multiple self-attention layers
float[][] representations = withPositions;
foreach (var layer in layers)
{
representations = layer.Forward(representations);
}
return representations; // Contextual representations for each word
}
private float[][] AddPositionalEncoding(float[][] embeddings)
{
// Add position-specific patterns so network knows word order
// (transformers don't naturally understand sequence order)
int sequenceLength = embeddings.Length;
int embeddingDim = embeddings[0].Length;
for (int pos = 0; pos < sequenceLength; pos++)
{
for (int i = 0; i < embeddingDim; i++)
{
double angle = pos / Math.Pow(10000, (2.0 * i) / embeddingDim);
// Use sine for even dimensions, cosine for odd
embeddings[pos][i] += (float)(i % 2 == 0 ? Math.Sin(angle) : Math.Cos(angle));
}
}
return embeddings;
}
}
```
كيف يعمل الاهتمام
- فكّر في الاهتمام على أنه يسأل: "لترجمة هذه الكلمة، أي كلمات ينبغي أن أهتم بها؟"
- (أ) الآلية:
- يقارن حالة الهدف الحالية بكل مصدر لـ كلمة
### تُحسب a a لـ مصدر كلمة
حوّل درجات إلى احتمالات (تُجمع إلى 1)
```csharp
public class TransformerDecoder
{
private WordEmbedding targetEmbedding;
private SelfAttentionLayer[] selfAttentionLayers;
private CrossAttentionLayer[] crossAttentionLayers;
private FeedForwardLayer[] feedForwardLayers;
public string[] Decode(float[][] encodedSource, int maxLength)
{
List translation = new List();
translation.Add(""); // Special token to begin
while (translation.Count < maxLength)
{
// Get next word
string nextWord = GenerateNextWord(encodedSource, translation.ToArray());
if (nextWord == "") break; // Stop token
translation.Add(nextWord);
}
return translation.Skip(1).ToArray(); // Remove token
}
private string GenerateNextWord(float[][] encodedSource, string[] partialTranslation)
{
// Step 1: Embed the partial translation
float[][] targetEmbeddings = partialTranslation
.Select(w => targetEmbedding.GetEmbedding(w))
.ToArray();
// Step 2: Self-attention on target words
float[][] selfAttended = ApplySelfAttention(targetEmbeddings);
// Step 3: Cross-attention to source (this is where translation happens!)
float[][] crossAttended = ApplyCrossAttention(selfAttended, encodedSource);
// Step 4: Feed forward
float[] finalState = ApplyFeedForward(crossAttended[^1]); // Last position
// Step 5: Predict next word
return PredictWord(finalState);
}
private string PredictWord(float[] state)
{
// Convert state to probability distribution over all possible words
Dictionary wordProbabilities = CalculateWordProbabilities(state);
// Return most likely word (or sample from distribution)
return wordProbabilities.OrderByDescending(kv => kv.Value).First().Key;
}
}
```
ينشئ متوسطاً مرجحاً لكلمات المصدر على أساس هذه الاحتمالات
```mermaid
sequenceDiagram
participant Input as Source Sentence
participant Encoder
participant Decoder
participant Output as Translation
Input->>Encoder: "The cat sat"
Encoder->>Encoder: Build representations
Encoder->>Decoder: Encoded states
Decoder->>Decoder: Generate [START]
Decoder->>Output: Emit START token
Decoder->>Decoder: Attend to "The" → Generate "Le"
Decoder->>Output: "Le"
Decoder->>Decoder: Attend to "cat" → Generate "chat"
Decoder->>Output: "chat"
Decoder->>Decoder: Attend to "sat" → Generate "s'est assis"
Decoder->>Output: "s'est assis"
Decoder->>Decoder: Generate [END]
Output->>Output: "Le chat s'est assis"
```
## مُنْجِج مُنْجِز
عند ترجمة "الاتفاق على المنطقة الاقتصادية الأوروبية تم التوقيع عليه في أغسطس 1992" إلى الألمانية، يبدو الاهتمام مثل هذا:
1. **عند توليد "Abbkommen" (الاتفاق)، تولي الشبكة اهتماماً بنسبة 90% إلى "الاتفاق"، 5% إلى "ال"، و5% موزعة بين كلمات أخرى.**مَصْرِفٌ لِنفسِكَ
2. **استخدام المحولات الحديثة**أن تكون ذاتية الاستخدام الذاتي
3. **: في نفس الجملة يلتئم بعضها مع بعض لبناء تمثيل أفضل.**في "تسبح الأسماك بالقرب من ضفة النهر" ، وتعني كلمة "بنك" بقوة إلى "الريف" ، و"الأسماك"، و"المياه"، مساعدة الشبكة على فهم أنها تعني "بنك" وليس "مؤسسة مالية".
```csharp
public class TranslationTrainer
{
private TransformerEncoder encoder;
private TransformerDecoder decoder;
private double learningRate = 0.0001;
public void Train(ParallelCorpus corpus, int epochs)
{
foreach (var epoch in Enumerable.Range(0, epochs))
{
double totalLoss = 0;
int batchCount = 0;
foreach (var batch in corpus.GetBatches(batchSize: 32))
{
// Forward pass
var predictions = new List();
var losses = new List();
foreach (var pair in batch)
{
// Encode source
var encoded = encoder.Encode(pair.Source);
// Try to decode target
var predicted = decoder.Decode(encoded, pair.Target.Length);
// Calculate loss (how different is prediction from target?)
double loss = CalculateLoss(predicted, pair.Target);
losses.Add(loss);
}
// Backward pass: adjust weights
double avgLoss = losses.Average();
UpdateWeights(avgLoss);
totalLoss += avgLoss;
batchCount++;
}
Console.WriteLine($"Epoch {epoch}: Average Loss = {totalLoss / batchCount}");
}
}
private double CalculateLoss(string[] predicted, string[] target)
{
// Cross-entropy loss: how far off were our word predictions?
double loss = 0;
for (int i = 0; i < Math.Min(predicted.Length, target.Length); i++)
{
if (predicted[i] != target[i])
{
loss += 1.0; // Simplified - real loss is more nuanced
}
}
return loss / target.Length;
}
private void UpdateWeights(double loss)
{
// Backpropagation: adjust all weights in encoder and decoder
// to reduce the loss (simplified here)
// Real implementation uses automatic differentiation
}
}
```
الـ مُفكّر مُفكّر مُعَدّ
```mermaid
graph TD
A[10M Sentence Pairs] --> B[Initial Random Weights]
B --> C[Epoch 1: Loss = 5.2]
C --> D[Epoch 2: Loss = 3.8]
D --> E[Epoch 3: Loss = 2.1]
E --> F[Epoch 10: Loss = 0.8]
F --> G[Epoch 20: Loss = 0.3]
G --> H[Trained Model!]
style A stroke-width:2px
style H stroke-width:4px
```
الآن يمكننا أن نضعها معاً!
- **تُستخدِم المترجمـات**مُفكّر مُفكّر
- **بنية العمارة:**المفكّر: فهم المصدر
- **وظيفة المُشفّر هي قراءة جملة المصدر وبناء تمثيلات غنية:**بعد الترميز، لكل كلمة مصدر تمثيل يلتقط:
## معانيه (من التألق)
موقعه في الجملة (من الترميز الموضعي)
```mermaid
graph TD
subgraph "1. Encoding"
A1[The] --> E1[emb: 0.2, -0.1, ...]
A2[cat] --> E2[emb: 0.5, 0.3, ...]
A3[sat] --> E3[emb: -0.1, 0.4, ...]
A4[on] --> E4[emb: 0.1, -0.2, ...]
A5[the] --> E5[emb: 0.2, -0.1, ...]
A6[mat] --> E6[emb: 0.4, 0.2, ...]
end
subgraph "2. Self-Attention in Encoder"
E1 & E2 & E3 & E4 & E5 & E6 --> SA[Self-Attention]
SA --> C1[ctx: 0.3, 0.1, ...]
SA --> C2[ctx: 0.6, 0.4, ...]
SA --> C3[ctx: -0.2, 0.5, ...]
end
subgraph "3. Decoding"
D1[START] --> G1[Le]
C2 -.attend.-> G1
G1 --> G2[chat]
C2 -.attend.-> G2
G2 --> G3[s'est assis]
C3 -.attend.-> G3
end
```
### علاقتها بعبارة أخرى (من الاكتفاء الذاتي)
**المفكفكفك مفك مفك مفك مفك مفك مفك مفك مفك مفك مفك مفك مفك مفك مفك مفك مفك مفك المفك: محرف الترجمة**
```csharp
var theEmbedding = encoder.GetEmbedding("The");
// [0.2, -0.1, 0.3, 0.05, ..., 0.1] (300 dimensions)
```
**الدالة المفككة تولد الترجمة كلمة واحدة في كل مرة:**
```csharp
var catEmbedding = encoder.GetEmbedding("cat");
// [0.5, 0.3, -0.2, 0.4, ..., 0.15] (300 dimensions)
```
**عملية الترجمة الكاملة:**
```csharp
// "cat" attends to other words
var catAttention = attention.CalculateAttention(catEmbedding, allWordEmbeddings);
// [0.1, 0.3, 0.2, 0.05, 0.1, 0.25]
// High attention to "sat" (0.3) and "mat" (0.25)
var catContextual = attention.ApplyAttention(catAttention, allWordEmbeddings);
// Weighted average incorporating context
```
**نموذج التدريب على الترجمة**
```csharp
var decoderState = decoder.InitialState();
```
**ويتطلب التدريب على نموذج الترجمة ثلاثة أمور:**
```csharp
// Attend to source
var sourceAttention = crossAttention.Calculate(decoderState, encodedSource);
// [0.8, 0.05, 0.05, 0.02, 0.05, 0.03]
// Strong focus on "The" (0.8)
var nextWordProbs = decoder.PredictNextWord(decoderState, sourceAttention);
// {"Le": 0.85, "La": 0.08, "Les": 0.04, ...}
var firstWord = "Le";
```
**مفرصة**
```csharp
decoderState = decoder.UpdateState(decoderState, "Le");
var sourceAttention = crossAttention.Calculate(decoderState, encodedSource);
// [0.05, 0.9, 0.02, 0.01, 0.01, 0.01]
// Strong focus on "cat" (0.9)
var nextWordProbs = decoder.PredictNextWord(decoderState, sourceAttention);
// {"chat": 0.92, "chien": 0.03, ...}
var secondWord = "chat";
```
**: بملايين الجمل في لغتي كل من اللغتين:**
```
Final translation: "Le chat s'est assis sur le tapis"
```
## دال
كيف "خطأ" كان تنبؤنا؟
1. **كيف تُحسب**تعديل الأوزان لتقليل الخسارة
2. **ويستغرق التدريب كميات هائلة من البيانات والحساب:**(أ) لنموذج حديث من أحدث التقنيات:
3. **بيانات التدريب**: 10.100 مليون من أزواج الأحكام
```mermaid
graph LR
subgraph "Old: Recurrent Neural Networks"
R1[Word 1] --> R2[Word 2]
R2 --> R3[Word 3]
R3 --> R4[Word 4]
end
subgraph "New: Transformers"
T1[Word 1] -.attend.-> T2[Word 2]
T1 -.attend.-> T3[Word 3]
T1 -.attend.-> T4[Word 4]
T2 -.attend.-> T3
T2 -.attend.-> T4
T3 -.attend.-> T4
end
```
## : 1-4 أسابيع على المستوى العالي
النموذج
```csharp
public class TranslationService
{
private readonly HttpClient _httpClient;
private readonly string _nmtServiceUrl;
public TranslationService(HttpClient httpClient, IConfiguration config)
{
_httpClient = httpClient;
_nmtServiceUrl = config["NMT:ServiceUrl"];
}
public async Task TranslateAsync(
string text,
string sourceLang,
string targetLang)
{
var request = new TranslationRequest
{
Text = new[] { text },
SourceLang = sourceLang,
TargetLang = targetLang
};
var response = await _httpClient.PostAsJsonAsync(
$"{_nmtServiceUrl}/translate",
request);
response.EnsureSuccessStatusCode();
var result = await response.Content
.ReadFromJsonAsync();
return new TranslationResult
{
Original = text,
Translated = result.Translated[0],
SourceLanguage = sourceLang,
TargetLanguage = targetLang,
TranslationTime = result.TranslationTime
};
}
}
public class TranslationRequest
{
[JsonPropertyName("text")]
public string[] Text { get; set; }
[JsonPropertyName("source_lang")]
public string SourceLang { get; set; }
[JsonPropertyName("target_lang")]
public string TargetLang { get; set; }
}
public class TranslationResponse
{
[JsonPropertyName("translated")]
public string[] Translated { get; set; }
[JsonPropertyName("translation_time")]
public double TranslationTime { get; set; }
}
```
100M إلى 1B+ البارامترات (الوزنات): 100M إلى 1B+
```csharp
// In your controller or service
public class BlogPostController : ControllerBase
{
private readonly TranslationService _translator;
public async Task TranslatePost(int postId, string targetLang)
{
var post = await _blogService.GetPostAsync(postId);
var translatedTitle = await _translator.TranslateAsync(
post.Title,
"en",
targetLang);
var translatedContent = await _translator.TranslateAsync(
post.Content,
"en",
targetLang);
return Ok(new
{
Title = translatedTitle.Translated,
Content = translatedContent.Translated,
OriginalLanguage = "en",
TargetLanguage = targetLang
});
}
}
```
## وضع كل شيء معا : مثال كامل
### دعونا نتتبع من خلال ترجمة "القط جلس على السجادة" إلى الفرنسية:
عملية الخطوة خطوة خطوة:
```csharp
public async Task TranslateLongText(string longText, string targetLang)
{
const int maxChunkSize = 500; // characters
// Split on paragraph boundaries
var paragraphs = longText.Split(new[] { "\n\n", "\r\n\r\n" },
StringSplitOptions.RemoveEmptyEntries);
var translatedParagraphs = new List();
foreach (var paragraph in paragraphs)
{
if (paragraph.Length <= maxChunkSize)
{
var result = await _translator.TranslateAsync(paragraph, "en", targetLang);
translatedParagraphs.Add(result.Translated);
}
else
{
// Split long paragraph into sentences
var sentences = SplitIntoSentences(paragraph);
var translatedSentences = new List();
foreach (var sentence in sentences)
{
var result = await _translator.TranslateAsync(sentence, "en", targetLang);
translatedSentences.Add(result.Translated);
}
translatedParagraphs.Add(string.Join(" ", translatedSentences));
}
}
return string.Join("\n\n", translatedParagraphs);
}
```
### الخطوة 1: الخطوة 1: الشفرة "T"
الخطوة: خطوة: مُسند "كات"
```csharp
public async Task TranslateMarkdown(string markdown, string targetLang)
{
// Extract text from markdown while preserving structure
var doc = Markdig.Markdown.Parse(markdown);
var textSegments = new List<(string text, int position)>();
// Walk the AST and extract translatable text
foreach (var node in doc.Descendants())
{
if (node is LiteralInline literal)
{
var text = literal.Content.ToString();
if (!string.IsNullOrWhiteSpace(text) && !IsImagePath(text))
{
textSegments.Add((text, literal.Span.Start));
}
}
}
// Translate all segments
var translations = await Task.WhenAll(
textSegments.Select(async seg => new
{
seg.position,
translated = (await _translator.TranslateAsync(seg.text, "en", targetLang)).Translated
}));
// Reconstruct markdown with translations
var result = markdown;
foreach (var translation in translations.OrderByDescending(t => t.position))
{
result = result.Remove(translation.position, textSegments
.First(s => s.position == translation.position).text.Length)
.Insert(translation.position, translation.translated);
}
return result;
}
```
### الخطوة 3: الاكتفاء الذاتي
خطوة 4: تنفيذ مفكفكفكفك مع
```csharp
public async Task> TranslateBatch(
IEnumerable texts,
string targetLang)
{
const int batchSize = 32;
var results = new Dictionary();
foreach (var batch in texts.Chunk(batchSize))
{
var request = new TranslationRequest
{
Text = batch.ToArray(),
SourceLang = "en",
TargetLang = targetLang
};
var response = await _httpClient.PostAsJsonAsync(
$"{_nmtServiceUrl}/translate",
request);
var result = await response.Content
.ReadFromJsonAsync();
for (int i = 0; i < batch.Length; i++)
{
results[batch[i]] = result.Translated[i];
}
}
return results;
}
```
## خطوة خطوة
الخطوة 6: خلق "محادثة"
```mermaid
graph TD
A[Translation Request] --> B{Model Size}
B -->|Small 100M params| C[Fast: 50-100ms]
B -->|Medium 500M params| D[Medium: 200-500ms]
B -->|Large 1B+ params| E[Slow: 1-3 seconds]
A --> F{Hardware}
F -->|CPU| G[Slow: 2-5x slower]
F -->|GPU| H[Fast: Baseline]
F -->|TPU/Special AI chips| I[Very Fast: 2-3x faster]
style C stroke-width:2px
style E stroke-width:2px
```
الخطوة 7: الاستمرار حتى
- **لِمَ المُحْلِلات**أصبحت بنية المحولات ("T" في Thagpt!) مهيمنة بسبب:
- **الموازي**:بخلاف النماذج المتكررة القديمة، يمكن معالجة جميع الكلمات في آن واحد
- **المعتمدات الطويلة المدى**:انتباه يمكن ربط أي كلمتين، بغض النظر عن مدى بعيد
****:: مزيد من البيانات + نموذج أكبر = نتائج أفضل (حتى نقطة)
**وتسير الشبكات المتكررة بشكل متتابع (منخفضة) في حين تقوم المحولات بتجهيز جميع الكلمات في آن واحد (متسارعة!).**استخدام NMMT في C#: مثال عملي
## الآن بما أنك تفهم كيف يعمل، هنا كيف يمكنك استخدامه في تطبيق شبكة:
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
1. **التحديات والحلول المشتركة**١ -
2. **سو**لنماذج MNT حدود طول المدخلات (عادة 512-1024 رمزاً).
3. **ماكينة!**)٢( A.
4. **تحفظ المُحْكِس**الترميز، HTML، وغيرها من الترميز يمكن أن يخلط نماذج NMT:
5. **أولاً -**تجهيز التجهيز للكفاءة
ترجمة جملة واحدة في وقت واحد أمر بطيء.
! اقبضوا عليهم
- **(أ)**فهم التكاليف الحسابية يساعدك على تصميم حلول أفضل:
- **(أ) الأداء النموذجي (في الجملة المتعلقة بالعنصر الجيني):**النماذج الصغيرة
- **(البارامترات 100 MM): 50-100ms**النماذج المتوسطة
- **(البارامترات 500 MM): 200-500ms**النماذج الكبيرة
(1B+ B+ parms): 1-3 ثوان
Now when you hit "translate" on your blog posts, you'll know exactly what's happening under the hood! 🚀
##
:GPU هو 2-10x أسرع من NMT
- [تجهيزات التتبع](https://arxiv.org/abs/1706.03762): يمكن تحقيق 100++ جمل/ثانية مع دفع
- [ثالثاً - استنتاج](https://jalammar.github.io/illustrated-transformer/)قد تبدو الترجمة الآلية الجينيّة كالسحر، لكنّها في الواقع مزيج أنيق من عدة أفكار ذكيّة:
- [مُحَث](https://arxiv.org/abs/1409.0473)تُمثل الكلمات كعواقل تُكبِّر معان
- [](/blog/category/EasyNMT): تعلّم الأنماط من ملايين الأمثلة