app.py

import numpy as np
import pandas as pd
from gensim.models import Word2Vec
import gradio as gr
from sklearn.decomposition import PCA
import plotly.graph_objects as go
import nltk
from nltk.tokenize import word_tokenize
import nltk
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer, WordNetLemmatizer
from nltk.tag import pos_tag

nltk.download('punkt')
nltk.download('stopwords')
nltk.download('wordnet')
nltk.download('averaged_perceptron_tagger')

from docs import NOVEL_TEXT

# Initialize lemmatizer and stop words
lemmatizer = WordNetLemmatizer()
stop_words = set(stopwords.words('english'))

# Function to process each sentence
def process_text(text):
    # Tokenization
    tokens = word_tokenize(text.lower())

    # Remove stop words and apply lemmatization
    processed_tokens = [
        lemmatizer.lemmatize(token)
        for token in tokens if token.isalnum() and token not in stop_words
    ]

    return processed_tokens

# Split text into sentences
sentences = nltk.sent_tokenize(NOVEL_TEXT)

# Process each sentence in the corpus
processed_corpus = [process_text(sentence) for sentence in sentences]

import random

emotion_words = ['emotion', 'joy', 'fear', 'anger', 'sadness', 'disgust', 'anxiety', 'team', 'console', 'headquarters', 'feelings']
hockey_words = ['hockey', 'game', 'team', 'skates', 'stick', 'rink', 'practice', 'championship', 'score', 'goal', 'penalty']
memory_words = ['memory', 'sphere', 'shelves', 'life', 'experience', 'recall', 'remember', 'color', 'happy', 'sad', 'joyful']
friend_words = ['friend', 'riley', 'grace', 'bree', 'team', 'support', 'help', 'together', 'loyal', 'fun', 'friendship']
school_words = ['school', 'class', 'teacher', 'student', 'homework', 'study', 'exam', 'lesson', 'classmates', 'learn']

train_data = []

for _ in range(40):
    train_data.append(random.sample(emotion_words, k=random.randint(4, 6)))
    train_data.append(random.sample(hockey_words, k=random.randint(4, 6)))
    train_data.append(random.sample(memory_words, k=random.randint(4, 6)))
    train_data.append(random.sample(friend_words, k=random.randint(4, 6)))
    train_data.append(random.sample(school_words, k=random.randint(4, 6)))


random.shuffle(train_data)



def train_word2vec(sentences):
    model = Word2Vec(sentences, vector_size=100, window=3, min_count=2, workers=4, sg=0, epochs=100)
    return model

def apply_pca(word_vectors):
    pca = PCA(n_components=3)
    return pca.fit_transform(word_vectors)

    
def get_unique(model):
    vocablist1=list(model.wv.index_to_key)
    vocablist =[]
    for i in vocablist1:
        vocablist.append(i)
    return vocablist

def process_text(target_word):
    # 전처리
    sentences=X

    # Word2Vec 모델 학습
    model = train_word2vec(sentences)
    unique_words = get_unique(model)

    # 각 단어의 임베딩 벡터 추출
    word_vectors = np.array([model.wv[word] for word in unique_words])

    # PCA로 차원 축소
    word_vectors_3d = apply_pca(word_vectors)

    # 색상 설정 (투명도 추가)
    colors = ['rgba(128, 128, 128, 0.15)' if word != target_word else 'rgba(255, 0, 0, 1)' for word in unique_words]

    # 가장 가까운 단어 10개 찾기
    if target_word in model.wv:
        similar_words = model.wv.most_similar(target_word, topn=10)
        similar_word_indices = [unique_words.index(word) for word, _ in similar_words]
        for idx in similar_word_indices:
            colors[idx] = 'rgba(0, 255, 0, 1)'  # 가까운 단어들을 초록색으로 표시

    # 가장 먼 단어 10개 찾기
    if target_word in model.wv:
        all_words = model.wv.index_to_key  # 모델에 포함된 모든 단어 리스트
        dissimilar_words = sorted([(word, model.wv.similarity(target_word, word)) 
        for word in all_words if word != target_word],
            key=lambda x: x[1])[:10]  # 유사도가 가장 낮은 10개 단어 선택
    
        dissimilar_word_indices = [unique_words.index(word) for word, _ in dissimilar_words]
        for idx in dissimilar_word_indices:
            colors[idx] = 'rgba(128, 0, 128, 1)'  # 가장 먼 단어들을 보라색으로 표시

    # Plotly를 사용한 3D 산점도 생성
    fig = go.Figure(data=[go.Scatter3d(
        x=word_vectors_3d[:, 0],
        y=word_vectors_3d[:, 1],
        z=word_vectors_3d[:, 2],
        mode='markers+text',
        text=unique_words,
        textposition="top center",
        marker=dict(
            size=6,
            color=colors,
        )
    )])

    fig.update_layout(
        title="Word Embeddings 3D Visualization",
        scene=dict(
            xaxis_title="PCA 1",
            yaxis_title="PCA 2",
            zaxis_title="PCA 3"
        ),
        width=1000,
        height=1000
    )

    # 가장 가까운 단어 10개 목록 생성
    similar_words_text = ""
    if target_word in model.wv:
        similar_words_text = "가장 가까운 단어 10개:\n" + "\n".join([f"{word}: {score:.4f}" for word, score in similar_words])

    return fig, similar_words_text


# Gradio 인터페이스
with gr.Blocks() as iface:
    gr.Markdown("# Word Embedding 3D 시각화")
    gr.Markdown("단어를 입력하세요. Word2Vec과 PCA를 사용하여 단어 임베딩을 3D로 시각화합니다. 입력한 단어는 빨간색으로, 가장 유사한 10개 단어는 초록색, 가장 먼 단어는 보라색으로 강조됩니다. 유사한 단어 목록은 그래프 아래에 표시됩니다.")

    with gr.Row():
        # file_input = gr.File(label="텍스트 파일 업로드 (.txt)", file_types=[".txt"])
        word_input = gr.Textbox(label="강조할 단어 입력")
        submit_btn = gr.Button("제출")


    plot_output = gr.Plot(label="Word Embedding 3D 시각화")
    similar_words_output = gr.Textbox(label="유사한 단어")

    submit_btn.click(
        fn=process_text,
        inputs=[word_input],
        outputs=[plot_output, similar_words_output]
    )

if __name__ == "__main__":
    iface.launch()