# Conceptual multilingual embedding space

class MultilingualEmbedding:
    """Shared embedding space for multiple languages."""

    def __init__(self, languages):
        self.languages = languages
        self.shared_encoder = TransformerEncoder()

    def encode(self, text, language):
        """Encode text into shared multilingual space."""

        # Language-agnostic encoding
        embedding = self.shared_encoder(text)

        # Similar concepts cluster together regardless of language
        # e.g., "hello" (English), "bonjour" (French), "你好" (Chinese)
        # all map to nearby points in embedding space

        return embedding

    def find_similar(self, query_embedding, top_k=5):
        """Find similar concepts across languages."""

        similarities = []
        for lang in self.languages:
            for word in self.vocabulary[lang]:
                word_embedding = self.encode(word, lang)
                similarity = cosine_similarity(query_embedding, word_embedding)
                similarities.append((word, lang, similarity))

        return sorted(similarities, reverse=True)[:top_k]

# TrOCR-style architecture

class TrOCR:
    """[Transformer-based OCR](/articles/vision-transformers-ocr) with cross-lingual capabilities."""

    def __init__(self):
        # Vision encoder: Process image
        self.vision_encoder = VisionTransformer(
            image_size=384,
            patch_size=16,
            embed_dim=768,
            depth=12,
            num_heads=12
        )

        # Text decoder: Generate text autoregressively
        self.text_decoder = TransformerDecoder(
            vocab_size=50000,  # Large multilingual vocabulary
            embed_dim=768,
            depth=12,
            num_heads=12
        )

    def recognize(self, image):
        """Recognize text in image."""

        # Encode image to visual features
        visual_features = self.vision_encoder(image)

        # Generate text token by token
        generated_tokens = []
        current_token = START_TOKEN

        while current_token != END_TOKEN and len(generated_tokens) < max_length:
            # Predict next token based on image and previous tokens
            logits = self.text_decoder(
                visual_features,
                previous_tokens=generated_tokens
            )

            # Sample most likely token
            current_token = torch.argmax(logits, dim=-1)
            generated_tokens.append(current_token)

        # Decode tokens to text
        text = self.decode_tokens(generated_tokens)

        return text

# PARSeq permutation language modeling

class PARSeq:
    """Permutation-based sequence modeling for OCR."""

    def __init__(self):
        self.encoder = ImageEncoder()
        self.decoder = PermutationDecoder()

    def train_with_permutations(self, image, target_text):
        """Train using all possible character orderings."""

        # Encode image
        visual_features = self.encoder(image)

        # Generate random permutation of target text
        # Example: "HELLO" → "LOLHE" or "OLELH" or "HELLO"
        permuted_order = torch.randperm(len(target_text))
        permuted_text = target_text[permuted_order]

        # Predict characters in permuted order
        predictions = self.decoder(visual_features, permuted_order)

        # Loss: correct characters regardless of order
        loss = self.compute_permutation_loss(predictions, permuted_text)

        return loss

    def recognize(self, image):
        """Recognize text using learned permutation invariance."""

        visual_features = self.encoder(image)

        # Try multiple permutation orders and ensemble results
        predictions = []
        for order in self.sample_permutations(num_samples=10):
            pred = self.decoder(visual_features, order)
            predictions.append(pred)

        # Combine predictions
        final_text = self.ensemble_predictions(predictions)

        return final_text

# Language-agnostic encoder for OCR

class LanguageAgnosticOCR:
    """OCR using language-agnostic encoders."""

    def __init__(self):
        # Pre-trained multilingual encoder
        self.language_encoder = LaBSE()

        # Vision encoder
        self.vision_encoder = VisionTransformer()

        # Cross-modal alignment
        self.alignment_layer = CrossModalAlignment()

    def align_vision_language(self, images, texts, languages):
        """
        Align visual and textual representations across languages.

        Training objective: Images and their text should have similar
        embeddings regardless of language.
        """

        # Encode images
        visual_embeddings = self.vision_encoder(images)

        # Encode texts (language-agnostic)
        text_embeddings = self.language_encoder(texts, languages)

        # Align embeddings
        loss = contrastive_loss(visual_embeddings, text_embeddings)

        return loss

    def recognize_unseen_language(self, image):
        """Recognize text in unseen language."""

        # Encode image
        visual_embedding = self.vision_encoder(image)

        # Project to shared language-agnostic space
        shared_embedding = self.alignment_layer(visual_embedding)

        # Decode to text (language automatically inferred)
        text = self.language_encoder.decode(shared_embedding)

        return text

# Multilingual sampling strategy

class MultilingualSampler:
    """Sample training data from multiple languages."""

    def __init__(self, language_datasets, temperature=0.5):
        """
        Args:
            language_datasets: Dict mapping language → dataset
            temperature: Sampling temperature (0.5 = sqrt sampling)
        """
        self.datasets = language_datasets
        self.temperature = temperature

        # Calculate sampling weights
        self.weights = self._calculate_weights()

    def _calculate_weights(self):
        """Calculate sampling weight for each language."""
        sizes = {lang: len(dataset) for lang, dataset in self.datasets.items()}

        # Apply temperature
        weights = {
            lang: size ** self.temperature
            for lang, size in sizes.items()
        }

        # Normalize
        total = sum(weights.values())
        weights = {lang: w / total for lang, w in weights.items()}

        return weights

    def sample_batch(self, batch_size):
        """Sample batch with language balancing."""

        batch = []

        for _ in range(batch_size):
            # Sample language according to weights
            language = np.random.choice(
                list(self.weights.keys()),
                p=list(self.weights.values())
            )

            # Sample example from that language
            example = random.choice(self.datasets[language])
            batch.append((example, language))

        return batch

# Synthetic data generation for any language

class SyntheticOCRDataGenerator:
    """Generate synthetic OCR training data."""

    def __init__(self):
        self.fonts = self.load_unicode_fonts()
        self.backgrounds = self.load_background_textures()
        self.augmentor = ImageAugmentor()

    def generate_sample(self, text, language, script):
        """Generate synthetic training sample."""

        # Select appropriate font for script
        font = self.select_font(script)

        # Render text
        image = self.render_text(text, font)

        # Add realistic background
        image = self.add_background(image, self.backgrounds)

        # Apply augmentations (blur, noise, perspective)
        image = self.augmentor.apply(image)

        return {
            'image': image,
            'text': text,
            'language': language,
            'script': script
        }

    def generate_corpus(self, language, num_samples=10000):
        """Generate full corpus for a language."""

        # Get text corpus (e.g., Wikipedia, Common Crawl)
        texts = self.get_language_corpus(language)

        # Identify script
        script = self.detect_script(texts[0])

        # Generate samples
        samples = []
        for _ in range(num_samples):
            text = random.choice(texts)
            sample = self.generate_sample(text, language, script)
            samples.append(sample)

        return samples

# Meta-learning for rapid language adaptation

class MetaLearningOCR:
    """OCR that quickly adapts to new languages."""

    def __init__(self):
        self.model = BaseOCRModel()
        self.meta_optimizer = torch.optim.Adam(self.model.parameters())

    def meta_train(self, language_datasets):
        """
        Meta-training: Learn initialization that adapts quickly.

        For each iteration:
          1. Sample batch of languages
          2. For each language:
             - Split into support (train) and query (test)
             - Adapt model on support set
             - Evaluate on query set
          3. Update meta-parameters to minimize query loss
        """

        for iteration in range(num_meta_iterations):
            meta_loss = 0

            # Sample batch of languages
            sampled_languages = random.sample(language_datasets.keys(), k=5)

            for language in sampled_languages:
                # Split data
                support_set, query_set = self.split_data(
                    language_datasets[language]
                )

                # Clone model
                adapted_model = self.model.clone()

                # Adapt on support set (few gradient steps)
                for _ in range(5):  # 5 adaptation steps
                    loss = adapted_model.compute_loss(support_set)
                    adapted_model.adapt(loss)

                # Evaluate on query set
                query_loss = adapted_model.compute_loss(query_set)
                meta_loss += query_loss

            # Update meta-parameters
            meta_loss.backward()
            self.meta_optimizer.step()

    def adapt_to_new_language(self, new_language_samples):
        """Quickly adapt to new language (5-10 examples)."""

        # Clone meta-learned model
        adapted_model = self.model.clone()

        # Fine-tune on few examples
        for _ in range(10):
            loss = adapted_model.compute_loss(new_language_samples)
            adapted_model.adapt(loss)

        return adapted_model

# Contrastive learning for cross-lingual OCR

class ContrastiveOCR:
    """Learn cross-lingual representations via contrastive learning."""

    def __init__(self):
        self.encoder = ImageEncoder()
        self.temperature = 0.07

    def contrastive_loss(self, images, translations):
        """
        Contrastive loss on translation pairs.

        Args:
            images: Images of text in different languages
            translations: Which images are translations of each other

        Example:
            images = [img_en, img_fr, img_de, img_zh, ...]
            translations = {
                0: [1, 2],  # img_en translations: img_fr, img_de
                3: [4],     # img_zh translation: img_ja
            }
        """

        # Encode all images
        embeddings = self.encoder(images)

        # For each image
        total_loss = 0
        for i, embedding in enumerate(embeddings):
            # Positive examples: translations
            positives = translations.get(i, [])

            # Negative examples: all other images
            negatives = [j for j in range(len(images)) if j != i and j not in positives]

            # Compute contrastive loss
            loss = self._compute_nce_loss(
                embedding,
                embeddings[positives],
                embeddings[negatives]
            )

            total_loss += loss

        return total_loss / len(embeddings)

    def _compute_nce_loss(self, anchor, positives, negatives):
        """Noise Contrastive Estimation loss."""

        # Similarity to positives
        pos_sim = torch.cosine_similarity(
            anchor.unsqueeze(0),
            positives
        ) / self.temperature

        # Similarity to negatives
        neg_sim = torch.cosine_similarity(
            anchor.unsqueeze(0),
            negatives
        ) / self.temperature

        # NCE loss: maximize similarity to positives,
        # minimize similarity to negatives
        loss = -torch.log(
            torch.exp(pos_sim).sum() /
            (torch.exp(pos_sim).sum() + torch.exp(neg_sim).sum())
        )

        return loss