Як нейронний машинний переклад насправді працює
Введение
Якщо ви читаєте цей блог, то знаєте, що я трохи одержимий машинним перекладом. за допомогою EasyNMT, будівельні послуги перекладу, і навіть покращення EasyNMTАле я зрозумів, що я ніколи не пояснював як нейронний машинний переклад працює підhood.
NOTE: Це частина моїх експериментів з штучним інтелектом M SK1 спосіб витрачати МSK2 Calude Code Web credits. ЯMSC4 fed this a BUNCH of papers , my understandingMST6 questions I had to generate this articleM ST7 ItM st8 fun and fills a gap I haven’ t seen filled anywhere elseMst10
Отже, давайте's виправимо цеM SK1 Цей пост переведе вас з "перетворення - це магія МSK3 до МSK4перекладання - це розумна математика МСК5, пояснюючи ключові концепції, що лежать за мозковим машинним перекладом в простому англійському MSC6с багатьма діаграмами та деякими кодами C# для того, щоб зробити це реальним MСК8
До кінця цього посту, виM SK1 зрозумієте :
- Що таке штучні нейронні мережі і як вони вчаться
- Як слова стають числами
- Що означає "" МСК0 "", "" ATTENTION, " "", у штучний інтелект
- Як працює архітектура кодера-decoder
- Чому трансформатори захопили світ
Не хвилюйтеся, якщо ви не математик
Основна ідея: Перетворення як число Crunching
Ось так: МСК0 - це перший розум . МСК1 - це змінна концепції. МСК2 - це нейронний машинний переклад, який сприймає переклад як чисто математичний процес. МSK3 - ви поглинаєте речення. , - система перетворює їх на числа. МКС5 - виконує мільйони математичних операцій.
graph LR
A[Source Sentence] --> B[Convert to Numbers]
B --> C[Neural Network Processing]
C --> D[Convert to Words]
D --> E[Translated Sentence]
Але чекайте. Як перетворити слова на цифри? Як математика розуміє? Як мова розуміє? Давайте розпочати з будівельних блоків?
штучні нейронні мережі: Фонд
До того, як ми зможемо зрозуміти нейронний машинний переклад, нам потрібно розуміти штучні нейронні мережі. Незважаючи на модне ім 'я, ,, вони
Що таке штучний нейрон?
Штучний нейрон - це математична функція, яка
- Бере багато входів
- Перемножує кожен вхід на об 'єм (скільки важливий цей вхідM SK1
- Додає їх докупи
- Застосовує функцію "активаціїM SK1, щоб отримати результат
Тут – МСК0 – візуальне представлення
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
Давайте зробимо це бетоном за допомогою коду C
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МСК0 - це те, що робить нейронні мережі цікавими. МSK1 - це неlineарність, що дозволяє мереже вивчати складні візерунки. МСК4 - без неї. ММК5 - неважливо, скільки нейронів ви складаєте разом. МСМ6 - ви. ММСК7 - просто маєте химерну лінійну функцію
Від нейронів до мереж
Магія відбувається, коли ви поєднуєте тисячі чи мільйони цих нейронів в шари.
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
Кожна шара " відображає МSK1 представлення входу МSK2 виділяє все більш абстрактні візерунки . У перекладі
- Перші шари можуть виявити: " це дієслово " або МSK2 це слово є минулим
- Середні шари можуть виявити: " це питання " або МSK2 це про погоду
- Далі ці шари об 'єднуються в " перетворити це на höfне запитання про завтра ' погоду МSK2
Як вчитися у мережі: Процес навчання
Тут - МСК0 - це розумна частина. МСК1 - ми не встановлюємо всі ці вага, МСК2 - не вказуємо їх наручно. МSK3 - мережа вивчає їх з прикладів.
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
Цей процес називається відхилення від gradients. Для кожного хибного відповіді , мережа з 'ясовує МSK2, які вага були найбільш відповідальними за цю помилку МSK3 і трохи вдосконалює їх мSK4 Після перегляду мільйонів прикладівM SK5 вага розраховується на цінності, які добре працюють.
Тут' є спрощеною версією в CM SK1
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);
}
}
}
}
Справжні нейронні мережі використовують більш складний алгоритм під назвою відхилення що ефективно обчислює, як підлаштувати вагу по всій мережі.
Word Embeddings: Перетворення мови в математику
Зараз ми зіткнулися з нашим першим великим завданням - як передавати слова в нейронну мережу? - МСК1. Ми повинні перетворити текст на цифри
Проблема з One-Hot кодуванням
Наївний підхід полягає в наступному: "oneM SK1hot encoding
// Don't do this!
var wordToNumber = new Dictionary<string, int>
{
{"cat", 1},
{"dog", 2},
{"king", 3},
{"queen", 4},
{"man", 5},
{"woman", 6}
};
Але у цьому є величезна проблема: : цифри довільні, МSK1 Мережа не може сказати, що МSK3 кіт, " і МSK5 собака, M SK6 більш подібні, ніж
Рішення: Word Embeddings
Замість ",", ми представляємо кожну слово як вектор чисел, tipично МSK1 виміриM SK2 Схожі слова отримують схожі вектори:
public class WordEmbedding
{
// Each word is represented by a vector of floats
private Dictionary<string, float[]> 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));
}
}
Ось що робить вбудовані додатки чарівними. Вони захоплюють семантичні відносини.
graph TD
subgraph "2D Projection of 300D Space"
King[King<br/>0.8, 0.6]
Queen[Queen<br/>0.75, 0.55]
Man[Man<br/>0.3, 0.2]
Woman[Woman<br/>0.25, 0.15]
Dog[Dog<br/>-0.6, 0.4]
Cat[Cat<br/>-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
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"
}
Як навчилися вміщання?
Embeddings вивчають, тренуючи нейронну мережу на простий задачі.
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, ...]"]
Після тренування на мільярдах речень слова, що з 'являються у схожих контекстах, мають подібні вбудовані літери. МSK1 " Ката МSK3 і " собака МSK5 обидва з' являються неподалік від МСК6 кішки МСК7
Увага: Перемінювач гри
Тут: "" МСК0 - це критичний урок "". ":", коли перекладаєш.
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
Увага це механізм, який дозволяє мережі зосередитися на різних частинах входу при генеруванні кожного вихідного слова
Як працює увага?
Подумайте про увагу, як про запитання: "" Як перевести це слово? "" "" На які слова я маю звернути увагу?"
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;
}
}
Механізм уваги:
- Порівнює теперішнє місце призначення з кожним джерелом слова
- Вираховує показник "релеванціїM SK1 для кожного слова з джерела
- Перетворює оцінки на ймовірність (сумма їх до МSK1
- Створює ваганий середній показник джерельних слів на основі цих ймовірностей
Візуалізація уваги
Коли перекладають "Соглашение про Європейську економічну зону було подписано в серпні МSK1 на німецьку МSK2, то увага виглядає ось так
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
Коли генерується "AbkommenM SK1 (agreement),, мережа звертає МSK4 увагу на МSK5aGREEMENTMSC6 \ 5% до \ МSK8the ", і \ 5%, розподілені між іншими словами \ мSK11
Своє я .
Сучасні трансформатори самосвідомістьwords in the same sentence attend to each other to build better representations
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
У мові "Ріба плавала біля берегу річки МSK1 слово МSK2 берег " тісно пов 'язане з МСК4 річкою МСК5 СМСК6 рибою \ МСк7 і СМСК8 водою \ ",, що допомагає мережі зрозуміти, що це означає.
Архітектура кодувальника
Тепер ми можемо все об 'єднати! Нейронний машинний переклад використовує кодувальник-кодувальник архітектура:
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
Кодувальник: Розуміння джерела
Задача кодувальника' - читати вихідне речення і створювати багаті представленняM SK1
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;
}
}
Після кодування, кожне слово-источник має представлення, яке захоплює
- Її значення ( з вбудованогоM SK1
- Її місцезнаходження в реченні (запозиційним кодуваннямM SK1
- Її зв 'язок з іншими словами (from self-attentionM SK2
Декодер: генерує переклад
Декодер генерує переклад одного слова за раз:
public class TransformerDecoder
{
private WordEmbedding targetEmbedding;
private SelfAttentionLayer[] selfAttentionLayers;
private CrossAttentionLayer[] crossAttentionLayers;
private FeedForwardLayer[] feedForwardLayers;
public string[] Decode(float[][] encodedSource, int maxLength)
{
List<string> translation = new List<string>();
translation.Add("<START>"); // Special token to begin
while (translation.Count < maxLength)
{
// Get next word
string nextWord = GenerateNextWord(encodedSource, translation.ToArray());
if (nextWord == "<END>") break; // Stop token
translation.Add(nextWord);
}
return translation.Skip(1).ToArray(); // Remove <START> 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<string, double> wordProbabilities = CalculateWordProbabilities(state);
// Return most likely word (or sample from distribution)
return wordProbabilities.OrderByDescending(kv => kv.Value).First().Key;
}
}
Повний процес перекладу:
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"
Викладання моделі перекладу
Тренування перекладної моделі потребує трьох речей:
- Паралельний корпус: Мільйони пар речень в обох мовах
- Функція втратиМSK0 Яким був наш прогноз
- Оптимізація: Регулювати вагу, щоб зменшити втрату
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<string[]>();
var losses = new List<double>();
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
}
}
Обучение потребує величезної кількості даних та обчислень:
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
Для штату МСК0 з МСК1, модель МСК2 та модель МSK3
- Дані про навчанняМSK0 10-100 мільйон пар речень
- Час навчанняМSK0 1-4 тижні на високому МSK2кінчному графіті
- Розмір моделіParameterи: : 100M до МSK2BM SK3
Поєднати все разом: Це повний приклад
Дозвольте "'" відслідковувати через переклад """ Кот сидів на килимі "" МSK2 "" до "" Французький ""
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 --> SA[Self-Attention]
E2 --> SA
E3 --> SA
E4 --> SA
E5 --> SA
E6 --> SA
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
Поступок-направдуМSK1Поступний процесM SK2
Шаг 1: Кодування "Для МSK2
var theEmbedding = encoder.GetEmbedding("The");
// [0.2, -0.1, 0.3, 0.05, ..., 0.1] (300 dimensions)
Шаг 2: Кодування "catM SK2
var catEmbedding = encoder.GetEmbedding("cat");
// [0.5, 0.3, -0.2, 0.4, ..., 0.15] (300 dimensions)
Шаг 3: Самосвідомість МSK1Attention
// "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
Шаг 4: Декодер починається з
var decoderState = decoder.InitialState();
Шаг 5: генерувати "LeM SK2
// 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";
Шаг 6: генерувати "chatM SK2
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";
Шаг 7: Продолжити до
Final translation: "Le chat s'est assis sur le tapis"
Чому Трансформери перемогли
Архітектура трансформатора (, "TM SK2 в ChatGPT МSK3 стала домінантною, тому що
- Паралелізація: На відміну від старих моделей повторюваностіM SK1 всі слова можуть оброблятися одночасно
- Long-залежності від діапазону: Увага може поєднати будь-які два словаM SK1 незалежно від відстані
- Скалабельність: Більше даних МSK1 більша модель МSK2 кращі результати ( до точки
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
Рекурентні мережі обробляють послідовно (повільноM SK1, в той час як трансформатори оброблять всі слова одночасно
Використовуючи NMT в C#: як практичний приклад
Тепер ви розумієте, як це працює.
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<TranslationResult> 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<TranslationResponse>();
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; }
}
Використовування:
// In your controller or service
public class BlogPostController : ControllerBase
{
private readonly TranslationService _translator;
public async Task<IActionResult> 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
});
}
}
Поширені проблеми та рішення
1. Obsługа довгих текстів
Моделі NMT мають обмеження довжини вхідних сигналів (звичайно МSK1 टोकониM SK2 Виход МSK3 групування !
public async Task<string> 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<string>();
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<string>();
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);
}
2. Утримуючи форматування
Марка-даун , HTML, та інші маркери можуть заплутати NMT моделіM SK2
public async Task<string> 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. Batch Processing для ефективності
Перекладати одну речення одночасно - повільне.
public async Task<Dictionary<string, string>> TranslateBatch(
IEnumerable<string> texts,
string targetLang)
{
const int batchSize = 32;
var results = new Dictionary<string, string>();
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<TranslationResponse>();
for (int i = 0; i < batch.Length; i++)
{
results[batch[i]] = result.Translated[i];
}
}
return results;
}
Характеристики ефективності
Усвідомлення обчислювальних витрат допомагає розробляти кращі рішення:
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
Типова продуктивність (за речення на GPU
- Малі моделі (100M парамиM SK1 МSK2м
- Середні моделі (500M парамиM SK1 МSK2м
- Великі моделі МSK0B+ парамиM SK2 МSK3 секунд
ЦП проти ЦП: GPU швидший для NMT
Обробка пакетів: Здатний досягти МSK1 реченьM SK2секунди з байтингом
Завершення
Нейронний машинний переклад може здатися магічним, але насправді це - елегантна комбінація кількох розумних ідей.
- Вбудова: Визначати слова як вектори, що захоплюють значення
- Нейронні мережі: Навчіться шаблонів з мільйонів прикладів
- Увага: зосередитися на відповідних частинах входу
- Кодувальник-кодувальник: Відокремлене розуміння від покоління
- Перетворювачі: Застосувати все паралельно
Дивовижно те, що сучасні системи NMT не мають жодних конкретних правил щодо граматики. МSK1, синтаксису, МSK2 чи еквівалентів перекладу.
Якщо ви ' працюєте з НМТ в галузі виробництва МSK1 так, як я роблю для цього блогу МSK2 порозуміння цих принципів допоможе вам :
- Проблеми розладівЧому модель перекладає МСК1банкМSK2 як МСК3банкМСК4 MSК5фінансовийМССК6, а не МСК7пливучийМСK8
- Оптимизувати ефективність: Я мушу подавати запити в партіюM SK1 Використовувати пошук проміжків ?
- Рух на крайі cases: Як я зберігаю кодові блоки в перекладеній позначціM SK1
- Налагодити очікування: Чому МСК1 не справляється з текстовими документами
Теорія все ще швидко розвивається. Моделі стають більшимиМSK1 швидшимиM SK2 і кращими щороку. Але головні концепції МСК4 вбудовані МСК5 увагуMСК6 кодувальникМ СК7 декодер M СК8 залишаються фундаментальними М СК9
Тепер, коли ви натиснете " перевести " на ваші блогові пости МSK2 ви МСК3 точно знатимете, що відбувається під капюшоном MСК5 М СК6
Дальне читання
Якщо ви хочете зануритися глибше:
- Увага - це все, що вам потрібно - Оригинальний папір трансформатора
- Ілюстрований трансформатор - Прекрасні візуальні пояснення
- Нейронний машинний переклад за допомогою спільного навчання до порівнювання та перекладу - Документ про механізм уваги
- Мої статті про EasyNMT - Практичні деталі застосування