Embedding Spaceとは

Embedding Space（埋め込み空間）は、単語、文、画像、音声などのデータを高次元ベクトルとして表現する数学的空間です。この空間では、意味的に類似したアイテムが近くに配置され、関係性が幾何学的な距離や方向として表現されます。機械学習、特に自然言語処理において、データの意味的構造を捉える基盤技術として重要な役割を果たし、類似性計算、アナロジー推論、分類タスクなどを可能にします。Word2Vec、BERT、GPTなどの技術により、より洗練された埋め込み空間の構築が可能になっています。

背景と重要性

従来のコンピューターサイエンスでは、記号的な表現（文字列、ID）が主流でしたが、これらは意味的関係を直接表現できませんでした。Embedding Spaceは、人間の直感的な「類似性」や「関連性」を数学的に扱える形で表現することを可能にします。

Embedding Spaceは、

• 意味的関係の数学的表現
• 高効率な類似性計算
• 機械学習アルゴリズムとの互換性

を実現することで、より人間的で直感的なAIシステムの構築を可能にします。現代のAI技術の多くは、この概念に基づいて設計されています。

主な構成要素

次元（Dimensions）

空間の軸数。通常50-1024次元程度が使用されます。

ベクトル（Vectors）

各データアイテムの空間内での位置を表す数値列です。

距離関数（Distance Function）

ベクトル間の類似性を測定する数学的関数です。

近傍構造（Neighborhood Structure）

類似アイテムが形成するクラスターや領域です。

方向性（Directionality）

意味的関係を表すベクトルの方向です。

位相的性質（Topological Properties）

空間全体の構造的特徴です。

主な特徴

意味保持性

元データの意味的関係を空間的配置で保持します。

計算効率

ベクトル演算による高速な類似性計算が可能です。

汎用性

様々なデータタイプと機械学習タスクに適用できます。

Embedding Spaceの数学的基礎

ベクトル空間の性質

基本的な数学的構造：

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity, euclidean_distances

def embedding_space_basics():
    """埋め込み空間の基本的な性質"""
    
    # サンプル埋め込みベクトル（3次元で可視化）
    words = {
        'king': np.array([0.1, 0.3, 0.8]),
        'queen': np.array([0.2, 0.9, 0.7]),
        'man': np.array([0.0, 0.1, 0.9]),
        'woman': np.array([0.1, 0.8, 0.8]),
        'dog': np.array([0.7, 0.2, 0.1]),
        'cat': np.array([0.8, 0.3, 0.2])
    }
    
    # ベクトル間の距離計算
    word_list = list(words.keys())
    vectors = np.array(list(words.values()))
    
    print("=== コサイン類似度 ===")
    cos_sim = cosine_similarity(vectors)
    for i, word1 in enumerate(word_list):
        for j, word2 in enumerate(word_list):
            if i < j:
                print(f"{word1} - {word2}: {cos_sim[i][j]:.3f}")
    
    print("\n=== ユークリッド距離 ===")
    euc_dist = euclidean_distances(vectors)
    for i, word1 in enumerate(word_list):
        for j, word2 in enumerate(word_list):
            if i < j:
                print(f"{word1} - {word2}: {euc_dist[i][j]:.3f}")
    
    return words, cos_sim, euc_dist

words_dict, cos_similarities, euc_distances = embedding_space_basics()

線形関係とアナロジー

有名なWord2Vecアナロジー：

def analogy_computation():
    """埋め込み空間でのアナロジー計算"""
    
    # 単語ベクトルの定義（概念的な例）
    embeddings = {
        'king': np.array([0.1, 0.3, 0.8, 0.2]),
        'queen': np.array([0.2, 0.9, 0.7, 0.8]),
        'man': np.array([0.0, 0.1, 0.9, 0.1]),
        'woman': np.array([0.1, 0.8, 0.8, 0.9]),
        'france': np.array([0.6, 0.4, 0.2, 0.3]),
        'paris': np.array([0.7, 0.5, 0.3, 0.4]),
        'italy': np.array([0.5, 0.6, 0.1, 0.2]),
        'rome': np.array([0.6, 0.7, 0.2, 0.3])
    }
    
    def find_analogy(a, b, c, embeddings, top_k=1):
        """a:b = c:? の形のアナロジーを解く"""
        # ベクトル演算: b - a + c
        if a in embeddings and b in embeddings and c in embeddings:
            target_vector = embeddings[b] - embeddings[a] + embeddings[c]
            
            # 全単語との類似度を計算
            similarities = {}
            for word, vector in embeddings.items():
                if word not in [a, b, c]:  # 入力単語を除外
                    sim = cosine_similarity([target_vector], [vector])[0][0]
                    similarities[word] = sim
            
            # 上位k個を返す
            sorted_words = sorted(similarities.items(), key=lambda x: x[1], reverse=True)
            return sorted_words[:top_k]
        
        return None
    
    # アナロジーテスト
    analogies = [
        ('king', 'queen', 'man'),  # king:queen = man:?
        ('france', 'paris', 'italy'),  # france:paris = italy:?
    ]
    
    print("=== アナロジー推論 ===")
    for a, b, c in analogies:
        result = find_analogy(a, b, c, embeddings)
        if result:
            predicted_word, confidence = result[0]
            print(f"{a}:{b} = {c}:{predicted_word} (confidence: {confidence:.3f})")
    
    return embeddings

embeddings_dict = analogy_computation()

空間の幾何学的性質

クラスタリングと分離性：

from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

def analyze_embedding_geometry():
    """埋め込み空間の幾何学的性質の分析"""
    
    # より大きなサンプル埋め込み空間
    np.random.seed(42)
    
    # カテゴリごとにベクトルを生成
    categories = {
        'animals': ['dog', 'cat', 'horse', 'cow', 'pig'],
        'countries': ['japan', 'usa', 'france', 'germany', 'italy'],
        'colors': ['red', 'blue', 'green', 'yellow', 'purple'],
        'numbers': ['one', 'two', 'three', 'four', 'five']
    }
    
    # カテゴリごとに異なる中心を持つベクトル生成
    embeddings = {}
    all_vectors = []
    labels = []
    
    centers = {
        'animals': np.array([1.0, 0.0]),
        'countries': np.array([0.0, 1.0]),
        'colors': np.array([-1.0, 0.0]),
        'numbers': np.array([0.0, -1.0])
    }
    
    for category, words in categories.items():
        center = centers[category]
        for word in words:
            # 中心周辺にランダムな変動を加える
            vector = center + np.random.normal(0, 0.3, 2)
            embeddings[word] = vector
            all_vectors.append(vector)
            labels.append(category)
    
    all_vectors = np.array(all_vectors)
    
    # K-meansクラスタリング
    kmeans = KMeans(n_clusters=4, random_state=42)
    cluster_labels = kmeans.fit_predict(all_vectors)
    
    # 可視化
    plt.figure(figsize=(12, 5))
    
    # 元のカテゴリ
    plt.subplot(1, 2, 1)
    colors_map = {'animals': 'red', 'countries': 'blue', 'colors': 'green', 'numbers': 'orange'}
    for i, (category, color) in enumerate(colors_map.items()):
        category_vectors = [all_vectors[j] for j, label in enumerate(labels) if label == category]
        if category_vectors:
            category_vectors = np.array(category_vectors)
            plt.scatter(category_vectors[:, 0], category_vectors[:, 1], 
                       c=color, label=category, alpha=0.7)
    
    plt.title('Original Categories')
    plt.xlabel('Dimension 1')
    plt.ylabel('Dimension 2')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    # クラスタリング結果
    plt.subplot(1, 2, 2)
    plt.scatter(all_vectors[:, 0], all_vectors[:, 1], c=cluster_labels, cmap='viridis', alpha=0.7)
    plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], 
               c='red', marker='x', s=200, linewidths=3)
    plt.title('K-means Clustering')
    plt.xlabel('Dimension 1')
    plt.ylabel('Dimension 2')
    plt.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.show()
    
    return embeddings, all_vectors, labels, cluster_labels

# embeddings, vectors, labels, clusters = analyze_embedding_geometry()

実世界のEmbedding Space

Word2Vec埋め込み空間

Word2Vecモデルの構築と分析：

from gensim.models import Word2Vec
from sklearn.decomposition import PCA

def build_word2vec_space():
    """Word2Vec埋め込み空間の構築と分析"""
    
    # サンプル文書コーパス
    sentences = [
        ['machine', 'learning', 'is', 'powerful', 'technology'],
        ['deep', 'learning', 'uses', 'neural', 'networks'],
        ['artificial', 'intelligence', 'includes', 'machine', 'learning'],
        ['neural', 'networks', 'are', 'computational', 'models'],
        ['data', 'science', 'involves', 'machine', 'learning'],
        ['python', 'is', 'programming', 'language', 'for', 'data', 'science'],
        ['algorithms', 'process', 'data', 'to', 'extract', 'patterns'],
        ['statistics', 'and', 'mathematics', 'are', 'foundation', 'of', 'data', 'science'],
        ['visualization', 'helps', 'understand', 'data', 'patterns'],
        ['big', 'data', 'requires', 'scalable', 'processing', 'methods']
    ]
    
    # Word2Vecモデル訓練
    model = Word2Vec(
        sentences,
        vector_size=50,     # 埋め込み次元
        window=5,           # コンテキスト窓
        min_count=1,        # 最小出現回数
        workers=4,          # 並列処理数
        sg=1,              # Skip-gram
        epochs=100
    )
    
    # 語彙の取得
    vocabulary = list(model.wv.index_to_key)
    
    # 埋め込みベクトルの抽出
    embedding_matrix = np.array([model.wv[word] for word in vocabulary])
    
    # PCAで2次元に削減（可視化用）
    pca = PCA(n_components=2)
    embedding_2d = pca.fit_transform(embedding_matrix)
    
    # 単語間類似度の計算
    def get_similar_words(word, topn=5):
        if word in model.wv:
            return model.wv.most_similar(word, topn=topn)
        return []
    
    # 関連語の検索
    target_words = ['machine', 'learning', 'data', 'neural']
    
    print("=== Word2Vec 埋め込み空間分析 ===")
    for word in target_words:
        similar = get_similar_words(word, 3)
        print(f"{word} の類似語: {similar}")
    
    # 可視化
    plt.figure(figsize=(12, 8))
    plt.scatter(embedding_2d[:, 0], embedding_2d[:, 1], alpha=0.6)
    
    # 重要な単語にラベル付け
    important_words = ['machine', 'learning', 'data', 'neural', 'science', 'python']
    for word in important_words:
        if word in vocabulary:
            idx = vocabulary.index(word)
            plt.annotate(word, (embedding_2d[idx, 0], embedding_2d[idx, 1]),
                        fontsize=10, alpha=0.8)
    
    plt.title('Word2Vec Embedding Space (PCA projection)')
    plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.3f})')
    plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.3f})')
    plt.grid(True, alpha=0.3)
    plt.show()
    
    return model, embedding_matrix, embedding_2d, vocabulary

# w2v_model, embeddings, embeddings_2d, vocab = build_word2vec_space()

BERT埋め込み空間

文脈依存埋め込みの分析：

# from transformers import BertTokenizer, BertModel
# import torch

def analyze_bert_embeddings():
    """BERT埋め込み空間の分析"""
    
    # 文脈により異なる意味を持つ文
    sentences = [
        "The bank is located near the river.",
        "I need to go to the bank to withdraw money.",
        "The bank of the river was muddy.",
        "He works at an investment bank."
    ]
    
    # 概念的な実装（実際のBERTエンベディング）
    def mock_bert_embedding(sentence, target_word):
        # 実際にはBERTによる文脈依存埋め込み
        import hashlib
        hash_input = sentence + target_word
        hash_val = int(hashlib.md5(hash_input.encode()).hexdigest(), 16)
        np.random.seed(hash_val % (2**32))
        return np.random.randn(768)  # BERT-baseの隠れ状態次元
    
    # 各文における'bank'の埋め込み
    bank_embeddings = []
    for sentence in sentences:
        if 'bank' in sentence:
            embedding = mock_bert_embedding(sentence, 'bank')
            bank_embeddings.append(embedding)
    
    bank_embeddings = np.array(bank_embeddings)
    
    # 文脈間の類似度計算
    print("=== BERT 文脈依存埋め込み ===")
    print("'bank' の文脈間類似度:")
    for i in range(len(sentences)):
        for j in range(i+1, len(sentences)):
            if 'bank' in sentences[i] and 'bank' in sentences[j]:
                sim = cosine_similarity([bank_embeddings[i]], [bank_embeddings[j]])[0][0]
                print(f"文 {i+1} vs 文 {j+1}: {sim:.3f}")
                print(f"  文 {i+1}: {sentences[i]}")
                print(f"  文 {j+1}: {sentences[j]}")
                print()
    
    # PCAで可視化
    if len(bank_embeddings) >= 2:
        pca = PCA(n_components=2)
        bank_2d = pca.fit_transform(bank_embeddings)
        
        plt.figure(figsize=(10, 6))
        plt.scatter(bank_2d[:, 0], bank_2d[:, 1], s=100, alpha=0.7)
        
        for i, sentence in enumerate(sentences):
            if 'bank' in sentence:
                plt.annotate(f"文{i+1}", (bank_2d[i, 0], bank_2d[i, 1]),
                           fontsize=10, alpha=0.8)
        
        plt.title("BERT: 'bank' の文脈依存埋め込み")
        plt.xlabel('PC1')
        plt.ylabel('PC2')
        plt.grid(True, alpha=0.3)
        plt.show()
    
    return bank_embeddings, sentences

# bert_embeddings, bert_sentences = analyze_bert_embeddings()

埋め込み空間の操作と応用

空間内でのベクトル演算

意味的操作の実装：

class EmbeddingSpaceOperations:
    def __init__(self, embeddings_dict):
        self.embeddings = embeddings_dict
        self.words = list(embeddings_dict.keys())
        self.vectors = np.array(list(embeddings_dict.values()))
    
    def find_closest(self, target_vector, exclude_words=None, top_k=1):
        """指定ベクトルに最も近い単語を検索"""
        if exclude_words is None:
            exclude_words = []
        
        similarities = {}
        for word, vector in self.embeddings.items():
            if word not in exclude_words:
                sim = cosine_similarity([target_vector], [vector])[0][0]
                similarities[word] = sim
        
        sorted_words = sorted(similarities.items(), key=lambda x: x[1], reverse=True)
        return sorted_words[:top_k]
    
    def analogy(self, a, b, c, top_k=1):
        """a:b = c:? 形式のアナロジー"""
        if all(word in self.embeddings for word in [a, b, c]):
            result_vector = self.embeddings[b] - self.embeddings[a] + self.embeddings[c]
            return self.find_closest(result_vector, exclude_words=[a, b, c], top_k=top_k)
        return None
    
    def interpolate(self, word1, word2, alpha=0.5):
        """2つの単語間の補間"""
        if word1 in self.embeddings and word2 in self.embeddings:
            interpolated = (1 - alpha) * self.embeddings[word1] + alpha * self.embeddings[word2]
            return self.find_closest(interpolated, exclude_words=[word1, word2])
        return None
    
    def cluster_analysis(self, n_clusters=3):
        """埋め込み空間のクラスター分析"""
        from sklearn.cluster import KMeans
        
        kmeans = KMeans(n_clusters=n_clusters, random_state=42)
        cluster_labels = kmeans.fit_predict(self.vectors)
        
        # クラスターごとの単語をグループ化
        clusters = {}
        for i, word in enumerate(self.words):
            cluster_id = cluster_labels[i]
            if cluster_id not in clusters:
                clusters[cluster_id] = []
            clusters[cluster_id].append(word)
        
        return clusters, cluster_labels

# 使用例
sample_embeddings = {
    'king': np.array([0.1, 0.3, 0.8, 0.2]),
    'queen': np.array([0.2, 0.9, 0.7, 0.8]),
    'man': np.array([0.0, 0.1, 0.9, 0.1]),
    'woman': np.array([0.1, 0.8, 0.8, 0.9]),
    'dog': np.array([0.7, 0.2, 0.1, 0.3]),
    'cat': np.array([0.8, 0.3, 0.2, 0.4]),
    'house': np.array([0.5, 0.5, 0.5, 0.5]),
    'home': np.array([0.6, 0.6, 0.4, 0.4])
}

ops = EmbeddingSpaceOperations(sample_embeddings)

# アナロジー演算
analogy_result = ops.analogy('king', 'queen', 'man')
if analogy_result:
    print(f"king:queen = man:{analogy_result[0][0]} (confidence: {analogy_result[0][1]:.3f})")

# 補間
interpolation_result = ops.interpolate('king', 'queen', alpha=0.5)
if interpolation_result:
    print(f"king と queen の中間: {interpolation_result[0][0]} (similarity: {interpolation_result[0][1]:.3f})")

# クラスター分析
clusters, labels = ops.cluster_analysis(n_clusters=3)
print("\n=== クラスター分析 ===")
for cluster_id, words in clusters.items():
    print(f"クラスター {cluster_id}: {words}")

多言語埋め込み空間

言語横断的埋め込み：

def multilingual_embedding_space():
    """多言語埋め込み空間の概念実装"""
    
    # 概念的な多言語埋め込み
    multilingual_embeddings = {
        # 英語
        'dog_en': np.array([0.7, 0.2, 0.1, 0.3]),
        'cat_en': np.array([0.8, 0.3, 0.2, 0.4]),
        'house_en': np.array([0.3, 0.7, 0.6, 0.2]),
        
        # 日本語
        'dog_ja': np.array([0.6, 0.3, 0.2, 0.4]),  # 犬
        'cat_ja': np.array([0.7, 0.4, 0.3, 0.5]),  # 猫
        'house_ja': np.array([0.4, 0.6, 0.7, 0.3]), # 家
        
        # フランス語
        'dog_fr': np.array([0.65, 0.25, 0.15, 0.35]), # chien
        'cat_fr': np.array([0.75, 0.35, 0.25, 0.45]), # chat
        'house_fr': np.array([0.35, 0.65, 0.65, 0.25]) # maison
    }
    
    # 言語間類似度の計算
    languages = ['en', 'ja', 'fr']
    concepts = ['dog', 'cat', 'house']
    
    print("=== 多言語埋め込み空間分析 ===")
    for concept in concepts:
        print(f"\n{concept.upper()} の言語間類似度:")
        for i, lang1 in enumerate(languages):
            for j, lang2 in enumerate(languages):
                if i < j:
                    key1 = f"{concept}_{lang1}"
                    key2 = f"{concept}_{lang2}"
                    if key1 in multilingual_embeddings and key2 in multilingual_embeddings:
                        sim = cosine_similarity(
                            [multilingual_embeddings[key1]], 
                            [multilingual_embeddings[key2]]
                        )[0][0]
                        print(f"  {lang1}-{lang2}: {sim:.3f}")
    
    # 言語間でのアナロジー
    print(f"\n=== 言語間アナロジー ===")
    # dog_en : cat_en = dog_ja : ?
    if all(key in multilingual_embeddings for key in ['dog_en', 'cat_en', 'dog_ja']):
        target_vector = (multilingual_embeddings['cat_en'] - 
                        multilingual_embeddings['dog_en'] + 
                        multilingual_embeddings['dog_ja'])
        
        # 最も近い単語を検索
        best_match = None
        best_similarity = -1
        for key, vector in multilingual_embeddings.items():
            if key not in ['dog_en', 'cat_en', 'dog_ja']:
                sim = cosine_similarity([target_vector], [vector])[0][0]
                if sim > best_similarity:
                    best_similarity = sim
                    best_match = key
        
        print(f"dog_en : cat_en = dog_ja : {best_match} (similarity: {best_similarity:.3f})")
    
    return multilingual_embeddings

multi_embeddings = multilingual_embedding_space()

埋め込み空間の評価

品質評価指標

埋め込み品質の評価：

def evaluate_embedding_quality():
    """埋め込み空間の品質評価"""
    
    # 評価用のサンプルデータ
    word_pairs_similarity = [
        ('king', 'queen', 0.8),
        ('man', 'woman', 0.7),
        ('dog', 'cat', 0.6),
        ('house', 'home', 0.9),
        ('car', 'dog', 0.1),
        ('king', 'dog', 0.1)
    ]
    
    # サンプル埋め込み
    embeddings = {
        'king': np.array([0.1, 0.3, 0.8]),
        'queen': np.array([0.2, 0.9, 0.7]),
        'man': np.array([0.0, 0.1, 0.9]),
        'woman': np.array([0.1, 0.8, 0.8]),
        'dog': np.array([0.7, 0.2, 0.1]),
        'cat': np.array([0.8, 0.3, 0.2]),
        'house': np.array([0.5, 0.5, 0.5]),
        'home': np.array([0.6, 0.6, 0.4]),
        'car': np.array([0.3, 0.1, 0.7])
    }
    
    # 計算された類似度
    calculated_similarities = []
    expected_similarities = []
    
    for word1, word2, expected_sim in word_pairs_similarity:
        if word1 in embeddings and word2 in embeddings:
            calc_sim = cosine_similarity(
                [embeddings[word1]], 
                [embeddings[word2]]
            )[0][0]
            calculated_similarities.append(calc_sim)
            expected_similarities.append(expected_sim)
    
    # 相関係数の計算
    from scipy.stats import pearsonr, spearmanr
    
    pearson_corr, pearson_p = pearsonr(expected_similarities, calculated_similarities)
    spearman_corr, spearman_p = spearmanr(expected_similarities, calculated_similarities)
    
    print("=== 埋め込み品質評価 ===")
    print(f"Pearson相関: {pearson_corr:.3f} (p={pearson_p:.3f})")
    print(f"Spearman相関: {spearman_corr:.3f} (p={spearman_p:.3f})")
    
    # 詳細結果
    print("\n単語ペア別の類似度:")
    for i, (word1, word2, expected) in enumerate(word_pairs_similarity):
        if i < len(calculated_similarities):
            calculated = calculated_similarities[i]
            print(f"{word1}-{word2}: 期待値={expected:.2f}, 計算値={calculated:.3f}")
    
    return pearson_corr, spearman_corr, calculated_similarities, expected_similarities

pearson, spearman, calc_sims, exp_sims = evaluate_embedding_quality()

次元の重要性分析

PCAによる次元分析：

def analyze_embedding_dimensions():
    """埋め込み次元の重要性分析"""
    
    # より大きな埋め込みデータの生成
    np.random.seed(42)
    
    # カテゴリごとにベクトルを生成
    categories = ['animals', 'vehicles', 'foods', 'colors']
    n_words_per_category = 10
    embedding_dim = 50
    
    embeddings = {}
    category_labels = []
    all_vectors = []
    
    for i, category in enumerate(categories):
        # カテゴリごとに異なる方向を持つベクトル生成
        base_direction = np.zeros(embedding_dim)
        base_direction[i * 10:(i + 1) * 10] = 1.0  # 特定の次元を活性化
        
        for j in range(n_words_per_category):
            word = f"{category}_{j}"
            # ベース方向に小さなノイズを追加
            vector = base_direction + np.random.normal(0, 0.1, embedding_dim)
            embeddings[word] = vector
            category_labels.append(category)
            all_vectors.append(vector)
    
    all_vectors = np.array(all_vectors)
    
    # PCA分析
    pca = PCA()
    pca_vectors = pca.fit_transform(all_vectors)
    
    # 累積寄与率の計算
    cumulative_variance_ratio = np.cumsum(pca.explained_variance_ratio_)
    
    # 結果の表示
    print("=== 埋め込み次元分析 ===")
    print(f"元の次元数: {embedding_dim}")
    print(f"寄与率上位10次元: {pca.explained_variance_ratio_[:10]}")
    print(f"累積寄与率（上位10次元）: {cumulative_variance_ratio[9]:.3f}")
    
    # 次元数と性能の関係
    dimensions_to_test = [5, 10, 20, 30, 40, 50]
    reconstruction_errors = []
    
    for n_dim in dimensions_to_test:
        if n_dim <= embedding_dim:
            # n_dim次元で近似
            pca_reduced = PCA(n_components=n_dim)
            reduced_vectors = pca_reduced.fit_transform(all_vectors)
            reconstructed_vectors = pca_reduced.inverse_transform(reduced_vectors)
            
            # 再構成誤差
            mse = np.mean((all_vectors - reconstructed_vectors) ** 2)
            reconstruction_errors.append(mse)
        else:
            reconstruction_errors.append(0)
    
    print("\n次元数と再構成誤差:")
    for n_dim, error in zip(dimensions_to_test, reconstruction_errors):
        print(f"{n_dim}次元: MSE={error:.6f}")
    
    # 可視化
    plt.figure(figsize=(15, 5))
    
    # 寄与率
    plt.subplot(1, 3, 1)
    plt.plot(range(1, 21), pca.explained_variance_ratio_[:20], 'bo-')
    plt.xlabel('主成分')
    plt.ylabel('寄与率')
    plt.title('各主成分の寄与率')
    plt.grid(True, alpha=0.3)
    
    # 累積寄与率
    plt.subplot(1, 3, 2)
    plt.plot(range(1, 21), cumulative_variance_ratio[:20], 'ro-')
    plt.xlabel('主成分数')
    plt.ylabel('累積寄与率')
    plt.title('累積寄与率')
    plt.grid(True, alpha=0.3)
    
    # 2次元投影
    plt.subplot(1, 3, 3)
    colors = ['red', 'blue', 'green', 'orange']
    for i, category in enumerate(categories):
        category_indices = [j for j, label in enumerate(category_labels) if label == category]
        category_vectors = pca_vectors[category_indices, :2]
        plt.scatter(category_vectors[:, 0], category_vectors[:, 1], 
                   c=colors[i], label=category, alpha=0.7)
    
    plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.3f})')
    plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.3f})')
    plt.title('埋め込み空間の2次元投影')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.show()
    
    return pca, cumulative_variance_ratio, reconstruction_errors

# pca_result, cum_var, recon_errors = analyze_embedding_dimensions()

活用事例・ユースケース

Embedding Spaceは現代AIの様々な分野で基盤技術として使用されています。

推薦システム

ユーザーやアイテムを埋め込み空間で表現し、類似性に基づく推薦を実現。

情報検索

文書やクエリを埋め込み空間で表現し、意味的類似性による検索を実現。

機械翻訳

言語横断的な埋め込み空間で、意味保持的な翻訳を実現。

感情分析

テキストを埋め込み空間で表現し、感情軸での分類を実現。

画像検索

画像特徴を埋め込み空間で表現し、視覚的類似性による検索を実現。

学ぶためのおすすめリソース

書籍

「Distributed Representations of Words and Phrases」論文、「Neural Network Methods for Natural Language Processing」（Yoav Goldberg）

オンラインコース

Stanford CS224N「Natural Language Processing with Deep Learning」、Fast.ai「Practical Deep Learning」

実装ライブラリ

Gensim、Transformers、Word2Vec、FastText、Sentence-Transformers

論文

「Word2Vec」、「GloVe」、「BERT」、「GPT」シリーズ

よくある質問（FAQ）

Q. 埋め込み次元数はどう決めるべきですか？
A. 一般的に50-300次元（Word2Vec）、512-1024次元（Transformer）が使用されます。データサイズとタスクの複雑さに応じて調整してください。

Q. 文脈依存と文脈非依存の埋め込みの使い分けは？
A. 一般的なタスクなら文脈非依存（Word2Vec）、文脈が重要なタスクなら文脈依存（BERT）を選択します。

Q. 埋め込み空間の品質をどう評価できますか？
A. 人間評価との相関、アナロジータスクの性能、下流タスクでの性能で評価できます。

関連キーワード

ベクトル化、Word2Vec、BERT、分散表現、意味表現

まとめ

Embedding Spaceは、人間の言語や概念を数学的に表現するための重要な技術です。Word2VecからBERT、GPTまで、技術の進歩とともにより洗練された埋め込み空間が構築されています。意味的関係を幾何学的距離として表現することで、類似性計算、アナロジー推論、機械学習タスクを効果的に実行できます。今後も、より効率的で表現力豊かな埋め込み空間の設計により、AIシステムの理解力と推論能力がさらに向上することが期待されます。