import gensim.downloader as api
from gensim.models import KeyedVectors
from sklearn.decomposition import PCA
from sklearn.preprocessing import normalize
import matplotlib.pyplot as plt
import japanize_matplotlib
from adjustText import adjust_text
import os
import warnings
warnings.filterwarnings('ignore')

# モデルのパス設定
ORIGINAL_MODEL_PATH = 'GoogleNews-vectors-negative300.bin'
LIGHT_MODEL_PATH = 'GoogleNews-vectors-negative300.kv'

# モデルのロード関数
def load_word2vec_model():
    # 軽量フォーマットが存在する場合
    if os.path.exists(LIGHT_MODEL_PATH):
        print("軽量フォーマットのモデルを読み込んでいます...")
        return KeyedVectors.load(LIGHT_MODEL_PATH)
    
    # オリジナルのバイナリファイルが存在する場合
    if os.path.exists(ORIGINAL_MODEL_PATH):
        print("オリジナルのモデルを読み込み、軽量フォーマットに変換しています...")
        model = KeyedVectors.load_word2vec_format(ORIGINAL_MODEL_PATH, binary=True)
        model.save(LIGHT_MODEL_PATH)
        return model
    
    # どちらも存在しない場合、ダウンロードを試みる
    print("モデルが見つかりません。word2vec-google-news-300をダウンロードします...")
    try:
        model = api.load('word2vec-google-news-300')
        print("ダウンロードが完了しました。軽量フォーマットに変換して保存します...")
        model.save(LIGHT_MODEL_PATH)
        return model
    except Exception as e:
        raise Exception(f"モデルのダウンロードに失敗しました: {str(e)}")

# モデルのロード
model = load_word2vec_model()

# 単語ベクトルの次元数を表示
print(f"単語ベクトルの次元数: {model.vector_size}")

# カテゴリ分け
categories = {
    '人': ['king', 'queen', 'prince', 'princess', 'man', 'woman', 'boy', 'girl', 'child', 'adult',
           'engineer', 'architect', 'doctor', 'nurse', 'pilot', 'teacher', 'student', 'professor', 
           'researcher', 'scientist', 'artist', 'writer', 'musician', 'actor', 'actress',
           'entrepreneur', 'investor', 'attorney', 'judge', 'police', 'detective', 'spy'],
    '動植物': ['cat', 'lion', 'tiger', 'dog', 'wolf', 'mammal', 'hawk', 'eagle', 'bird', 
            'ant', 'bee', 'butterfly', 'insects', 'tree', 'plant', 'flower', 'grass'],
    '自然物': ['nature', 'sky', 'cloud', 'sun', 'moon', 'star', 'water', 'river', 'sea', 'ocean', 
            'lake', 'fire', 'flame', 'smoke', 'bank'],
    '人工物': ['car', 'truck', 'bicycle', 'motorcycle', 'vehicle', 'machine', 'house', 'building', 
            'apartment', 'home', 'room', 'fireplace', 'fireworks'],
    '概念': ['joy', 'anger', 'sadness', 'fear', 'surprise', 'money', 'wealth', 'poverty', 'poor']
}

# 色の定義
category_colors = {
    '人': 'blue',
    '動植物': 'green',
    '自然物': 'red',
    '人工物': 'black',
    '概念': 'purple'
}

# 単語ベクトルを辞書に格納
word_vectors = {}
# categoriesから全ての単語を取得し、重複を排除
words = []
for category, word_list in categories.items():
    for word in word_list:
        if word not in words:  # 重複チェック
            words.append(word)

for word in words:
    try:
        word_vectors[word] = model.get_vector(word)
    except KeyError:
        print(f"警告: '{word}' はモデル内に見つかりませんでした。")

# ベクトルリストの準備
vectors = list(word_vectors.values())
labels = list(word_vectors.keys())

# ベクトルの正規化
normalized_vectors = normalize(vectors)

# PCAで次元削減
pca = PCA(n_components=2, random_state=42)
reduced_vectors = pca.fit_transform(normalized_vectors)

# 寄与率の取得
explained_variance_ratio = pca.explained_variance_ratio_

# 可視化（カテゴリごとに色分け）
plt.figure(figsize=(14, 12))

# 各カテゴリごとに点をプロット
for category, color in category_colors.items():
    # カテゴリに含まれる単語のインデックスを取得
    indices = [i for i, label in enumerate(labels) if label in categories[category]]
    
    # そのカテゴリの単語をプロット
    if indices:
        plt.scatter(
            [reduced_vectors[i, 0] for i in indices],
            [reduced_vectors[i, 1] for i in indices],
            color=color,
            label=category,
            s=20,
            alpha=0.8
        )

# ラベルの追加
texts = []
for i, label in enumerate(labels):
    # 単語が属するカテゴリの色を取得
    category = next((cat for cat, words_list in categories.items() if label in words_list), None)
    color = category_colors.get(category, 'black')
    
    # テキストを追加
    texts.append(plt.text(reduced_vectors[i, 0], reduced_vectors[i, 1], label, color=color, fontsize=9))

plt.title(f'Word2VecのPCA射影（{model.vector_size}次元から2次元） - カテゴリ別色分け')
plt.xlabel(f'PCA次元1 (寄与率: {explained_variance_ratio[0]:.2%})')
plt.ylabel(f'PCA次元2 (寄与率: {explained_variance_ratio[1]:.2%})')
plt.grid(True, alpha=0.3)
plt.legend(loc='upper right')

# テキスト位置の調整
adjust_text(texts,
    arrowprops=dict(arrowstyle='->', color='red', lw=1.0, alpha=1.0),
        force_points=(0.1, 0.2),
        force_text=(0.5, 1.0),
        expand_points=(1.5, 1.5),
        expand_text=(1.5, 1.5),
        only_move={'points':'xy', 'text':'xy'})

plt.show() 

import torch
from transformers import AutoModel, AutoTokenizer
import numpy as np
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
import japanize_matplotlib
from adjustText import adjust_text

# モデルとトークナイザーのロード
model_name = "tohoku-nlp/bert-base-japanese-v3"
model = AutoModel.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# テキストの例
ikimono_sentences = ["猫は生物です", "犬は生物です", "鳥は生物です", "魚は生物です", "虫は生物です", "象は生物です", "蛇は生物です", "クジラは生物です", "きのこは生物です", "人間は生物です", "生物多様性", "生物兵器は禁止されています", "地球上に最初に現れた生物は？", "火星に生物がいるかどうか研究している"]
namamono_sentences = ["刺身は生物です", "お寿司は生物です", "生牡蠣は生物です", "生卵は生物です", "生ハムは生物です", "生肉は生物です", "生魚は生物です", "生野菜は生物です", "生フルーツは生物です", "生クリームは生物です", "生物には注意が必要です", "生物でお腹を壊した", "生物は加熱した方がいい", "生物は消費期限に注意が必要"]

texts = ikimono_sentences + namamono_sentences

seibutsu_embeddings = []  # 「生物」トークンの埋め込みを文と一緒に保存するリスト

# テキストリストから各テキストを処理
for i, text in enumerate(texts):
    print(f"\n===== テキスト {i+1}: '{text}' =====")
    
    # トークナイズ
    inputs = tokenizer(text, return_tensors="pt")
    
    # モデルに入力して埋め込みを取得
    outputs = model(**inputs)
    
    # 埋め込みの取得
    embeddings = outputs.last_hidden_state
    
    # トークンインデックスの取得
    token_ids = inputs.input_ids[0]
    token_embeddings = embeddings[0]
    
    # トークンごとの埋め込みを取得
    for token_id, embedding in zip(token_ids, token_embeddings):
        token_text = tokenizer.convert_ids_to_tokens(token_id.item())
        
        # トークンが「生物」の場合のみ処理して保存
        if token_text == "生物":
            print(f"Token ID: {token_id}, トークン: {token_text}, 埋め込み次元数: {embedding.size(0)}")
            
            # 文と埋め込みをセットで保存
            seibutsu_embeddings.append({
                "text": text,
                "embedding": embedding.detach().numpy()  # テンソルをNumPy配列に変換して保存
            })

# 保存したデータの確認
print(f"\n合計 {len(seibutsu_embeddings)} 個の「生物」埋め込みを保存しました")

# PCAの準備
embeddings_array = np.array([item["embedding"] for item in seibutsu_embeddings])
pca = PCA(n_components=2)
embeddings_2d = pca.fit_transform(embeddings_array)

# 可視化の準備
plt.figure(figsize=(10, 8))

# 各点のカテゴリを判断し、色を設定
texts_objects = []
for i, item in enumerate(seibutsu_embeddings):
    text = item["text"]
    x, y = embeddings_2d[i]
    
    # ikimono_sentencesの要素なら赤色、namamono_sentencesなら青色
    if text in ikimono_sentences:
        color = 'red'
        category = '生き物'
    else:
        color = 'blue'
        category = '生物（なまもの：食べ物）'
    
    plt.scatter(x, y, c=color)
    texts_objects.append(plt.text(x, y, text, fontsize=9))

# テキストの位置を自動調整
adjust_text(texts_objects, arrowprops=dict(arrowstyle='->', color='black', lw=0.5))

# グラフの設定
# 埋め込み次元数を動的に取得
embedding_dim = embeddings_array.shape[1]
plt.title(f'「生物」の埋め込みのPCA可視化（{embedding_dim}次元から2次元） - カテゴリ別色分け')
explained_variance = pca.explained_variance_ratio_
plt.xlabel(f'第1主成分(寄与率: {explained_variance[0]:.2%})')
plt.ylabel(f'第2主成分(寄与率: {explained_variance[1]:.2%})')

# 凡例の追加
from matplotlib.lines import Line2D
legend_elements = [
    Line2D([0], [0], marker='o', color='w', markerfacecolor='red', label='生き物', markersize=10),
    Line2D([0], [0], marker='o', color='w', markerfacecolor='blue', label='生物（なまもの：食べ物）', markersize=10)
]
plt.legend(handles=legend_elements)

# グリッド表示
plt.grid(True, linestyle='--', alpha=0.7)

# グラフの表示
plt.tight_layout()

plt.savefig('seibutsu_pca.png')
plt.show()

import torch
from transformers import AutoModel, AutoTokenizer
import numpy as np
import matplotlib.pyplot as plt
import japanize_matplotlib
from sklearn.metrics.pairwise import cosine_similarity
import pandas as pd
import seaborn as sns

# モデルとトークナイザーのロード
model_name = "tohoku-nlp/bert-base-japanese-v3"
model = AutoModel.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# テキストの例
ikimono_sentences = ["猫は生物です", "犬は生物です", "鳥は生物です", "魚は生物です", "虫は生物です", "象は生物です", "蛇は生物です", "クジラは生物です", "きのこは生物です", "人間は生物です", "生物多様性", "生物兵器は禁止されています", "地球上に最初に現れた生物は？", "火星に生物がいるかどうか研究している"]
namamono_sentences = ["刺身は生物です", "お寿司は生物です", "生牡蠣は生物です", "生卵は生物です", "生ハムは生物です", "生肉は生物です", "生魚は生物です", "生野菜は生物です", "生フルーツは生物です", "生クリームは生物です", "生物には注意が必要です", "生物でお腹を壊した", "生物は加熱した方がいい", "生物は消費期限に注意が必要"]

# ペット文を追加
pet_sentences = ["猫は世界中でペットとして飼われています"]
texts = ikimono_sentences + namamono_sentences + pet_sentences

seibutsu_embeddings = []  # 「生物」トークンの埋め込みを文と一緒に保存するリスト
pet_embeddings = []  # 「ペット」トークンの埋め込みを文と一緒に保存するリスト

# テキストリストから各テキストを処理
for i, text in enumerate(texts):
    print(f"\n===== テキスト {i+1}: '{text}' =====")
    
    # トークナイズ
    inputs = tokenizer(text, return_tensors="pt")
    
    # モデルに入力して埋め込みを取得
    outputs = model(**inputs)
    
    # 埋め込みの取得
    embeddings = outputs.last_hidden_state
    
    # トークンインデックスの取得
    token_ids = inputs.input_ids[0]
    token_embeddings = embeddings[0]
    
    # トークンごとの埋め込みを取得
    for token_id, embedding in zip(token_ids, token_embeddings):
        token_text = tokenizer.convert_ids_to_tokens(token_id.item())
        
        # トークンが「生物」の場合のみ処理して保存
        if token_text == "生物":
            print(f"Token ID: {token_id}, トークン: {token_text}, 埋め込み次元数: {embedding.size(0)}")
            
            # 文と埋め込みをセットで保存
            seibutsu_embeddings.append({
                "text": text,
                "embedding": embedding.detach().numpy(),
                "category": "生物"
            })
        
        # トークンが「ペット」の場合も処理して保存
        if token_text == "ペット":
            print(f"Token ID: {token_id}, トークン: {token_text}, 埋め込み次元数: {embedding.size(0)}")
            
            # 文と埋め込みをセットで保存
            pet_embeddings.append({
                "text": text,
                "embedding": embedding.detach().numpy(),
                "category": "ペット"
            })

# 保存したデータの確認
print(f"\n合計 {len(seibutsu_embeddings)} 個の「生物」埋め込みを保存しました")
print(f"合計 {len(pet_embeddings)} 個の「ペット」埋め込みを保存しました")

# 類似度計算（コサイン類似度）
print("\n===== 埋め込みの類似度計算 =====")

# 埋め込みをnumpy配列に変換
seibutsu_embeddings_array = np.array([item["embedding"] for item in seibutsu_embeddings])
pet_embeddings_array = np.array([item["embedding"] for item in pet_embeddings])

# ペットと生物の間の類似度行列を計算
similarity_matrix = cosine_similarity(pet_embeddings_array, seibutsu_embeddings_array)

# テキストとカテゴリの表示用リスト
pet_texts = [item["text"] for item in pet_embeddings]
seibutsu_texts = [item["text"] for item in seibutsu_embeddings]

# 類似度の結果をデータフレームとして整形
similarity_df = pd.DataFrame(similarity_matrix, 
                            index=[f"{text} (ペット)" for text in pet_texts],
                            columns=[f"{text} (生物)" for text in seibutsu_texts])

# 表形式でマークダウンとして保存
similarity_df.to_markdown('similarity_table.md')
print("ペットと生物間の類似度テーブルを similarity_table.md に保存しました")

# ヒートマップの描画
plt.figure(figsize=(15, 8))
sns.heatmap(similarity_matrix, annot=True, cmap='coolwarm', 
            xticklabels=seibutsu_texts, 
            yticklabels=pet_texts)
plt.title('ペットと生物の埋め込みのコサイン類似度')
plt.xlabel('生物トークンの埋め込み')
plt.ylabel('ペットトークンの埋め込み')
plt.tight_layout()
plt.savefig('pet_seibutsu_similarity_heatmap.png')
plt.show()

import torch
from transformers import AutoModel, AutoTokenizer
import numpy as np
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
import japanize_matplotlib
from adjustText import adjust_text

# モデルとトークナイザーのロード
model_name = "tohoku-nlp/bert-base-japanese-v3"
model = AutoModel.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# テキストの例
ikimono_sentences = ["猫は生物です", "犬は生物です", "鳥は生物です", "魚は生物です", "虫は生物です", "象は生物です", "蛇は生物です", "クジラは生物です", "きのこは生物です", "人間は生物です", "生物多様性", "生物兵器は禁止されています", "地球上に最初に現れた生物は？", "火星に生物がいるかどうか研究している"]
namamono_sentences = ["刺身は生物です", "お寿司は生物です", "生牡蠣は生物です", "生卵は生物です", "生ハムは生物です", "生肉は生物です", "生魚は生物です", "生野菜は生物です", "生フルーツは生物です", "生クリームは生物です", "生物には注意が必要です", "生物でお腹を壊した", "生物は加熱した方がいい", "生物は消費期限に注意が必要"]

# ペット文を追加
pet_sentences = ["犬はペットとして人気です", "猫は世界中でペットとして飼われています", "金魚もペットです", "ハムスターはかわいいペットです", "ペットの健康管理は大切です"]
texts = ikimono_sentences + namamono_sentences + pet_sentences

seibutsu_embeddings = []  # 「生物」トークンの埋め込みを文と一緒に保存するリスト
pet_embeddings = []  # 「ペット」トークンの埋め込みを文と一緒に保存するリスト

# テキストリストから各テキストを処理
for i, text in enumerate(texts):
    print(f"\n===== テキスト {i+1}: '{text}' =====")
    
    # トークナイズ
    inputs = tokenizer(text, return_tensors="pt")
    
    # モデルに入力して埋め込みを取得
    outputs = model(**inputs)
    
    # 埋め込みの取得
    embeddings = outputs.last_hidden_state
    
    # トークンインデックスの取得
    token_ids = inputs.input_ids[0]
    token_embeddings = embeddings[0]
    
    # トークンごとの埋め込みを取得
    for token_id, embedding in zip(token_ids, token_embeddings):
        token_text = tokenizer.convert_ids_to_tokens(token_id.item())
        
        # トークンが「生物」の場合のみ処理して保存
        if token_text == "生物":
            print(f"Token ID: {token_id}, トークン: {token_text}, 埋め込み次元数: {embedding.size(0)}")
            
            # 文と埋め込みをセットで保存
            seibutsu_embeddings.append({
                "text": text,
                "embedding": embedding.detach().numpy(),
                "category": "生物"
            })
        
        # トークンが「ペット」の場合も処理して保存
        if token_text == "ペット":
            print(f"Token ID: {token_id}, トークン: {token_text}, 埋め込み次元数: {embedding.size(0)}")
            
            # 文と埋め込みをセットで保存
            pet_embeddings.append({
                "text": text,
                "embedding": embedding.detach().numpy(),
                "category": "ペット"
            })

# 保存したデータの確認
print(f"\n合計 {len(seibutsu_embeddings)} 個の「生物」埋め込みを保存しました")
print(f"合計 {len(pet_embeddings)} 個の「ペット」埋め込みを保存しました")

# すべての埋め込みを結合
all_embeddings = seibutsu_embeddings + pet_embeddings
embeddings_array = np.array([item["embedding"] for item in all_embeddings])
pca = PCA(n_components=2)
embeddings_2d = pca.fit_transform(embeddings_array)

# 可視化の準備
plt.figure(figsize=(12, 10))

# 各点のカテゴリを判断し、色を設定
texts_objects = []
for i, item in enumerate(all_embeddings):
    text = item["text"]
    x, y = embeddings_2d[i]
    
    if item["category"] == "ペット":
        color = 'green'
        category_name = 'ペット'
    elif text in ikimono_sentences:
        color = 'red'
        category_name = '生き物'
    else:
        color = 'blue'
        category_name = '生物（なまもの：食べ物）'
    
    plt.scatter(x, y, c=color)
    texts_objects.append(plt.text(x, y, text, fontsize=9))

# テキストの位置を自動調整
adjust_text(texts_objects, arrowprops=dict(arrowstyle='->', color='black', lw=0.5))

# グラフの設定
embedding_dim = embeddings_array.shape[1]
plt.title(f'「生物」と「ペット」の埋め込みのPCA可視化（{embedding_dim}次元から2次元）')
explained_variance = pca.explained_variance_ratio_
plt.xlabel(f'第1主成分(寄与率: {explained_variance[0]:.2%})')
plt.ylabel(f'第2主成分(寄与率: {explained_variance[1]:.2%})')

# 凡例の追加
from matplotlib.lines import Line2D
legend_elements = [
    Line2D([0], [0], marker='o', color='w', markerfacecolor='red', label='生き物', markersize=10),
    Line2D([0], [0], marker='o', color='w', markerfacecolor='blue', label='生物（なまもの：食べ物）', markersize=10),
    Line2D([0], [0], marker='o', color='w', markerfacecolor='green', label='ペット', markersize=10)
]
plt.legend(handles=legend_elements)

# グリッド表示
plt.grid(True, linestyle='--', alpha=0.7)

# グラフの表示
plt.tight_layout()

plt.savefig('seibutsu_pet_pca.png')
plt.show()