new-value-analysis 0.1.0__py3-none-any.whl

new_value_analysis/__init__.py

@@ -0,0 +1,14 @@
+"""new_value_analysis
+
+New Value Analysis(신규가치분석)용 유틸리티 패키지입니다.
+
+구성
+- action_finder: 토픽 모델링 기반 Action 추출/할당
+- actor_finder: 문서 임베딩(Doc2Vec) + 군집 진단
+- opportunity_area_analysis: 기회영역 스케일링/시각화
+"""
+
+from . import action_finder, actor_finder, opportunity_area_analysis
+
+__all__ = ["action_finder", "actor_finder", "opportunity_area_analysis"]
+__version__ = "0.1.0"

new_value_analysis/action_finder/__init__.py

@@ -0,0 +1,8 @@
+"""action_finder 서브패키지
+
+토픽 모델링 기반으로 'Action(행동)'을 추출/할당하는 기능을 제공합니다.
+"""
+
+from .topic_modeling import *  # noqa
+from .find_topicnum import *  # noqa
+from .select_action_number import *  # noqa

new_value_analysis/action_finder/find_topicnum.py

@@ -0,0 +1,91 @@
+"""토픽 개수(토픽 수) 탐색/평가 관련 함수 모음.
+
+- Perplexity, Coherence 등 지표를 이용해 적절한 토픽 개수를 탐색합니다.
+"""
+
+def lda_perplexity_coherence_plot(
+    corpus,
+    word_dict,
+    all_documents,
+    fixed_topn=10,          # 각 토픽에서 고려할 상위 단어 개수(10개로 고정)
+    topic_range=range(2,10),
+    passes=10,
+    iterations=20,
+    random_state=2025,
+    figsize=(12,5)
+):
+    import gensim
+    from gensim.models import CoherenceModel
+    from tqdm.auto import tqdm
+    import matplotlib.pyplot as plt
+
+    perplexity_values = []
+    coherence_values = []
+
+    # 2 ~ 9까지의 토픽 개수에 대해 perplexity & coherence 계산
+    for i in tqdm(topic_range):
+        # 1. LDA 모델 생성(코퍼스,단어사전,생성할 토픽의 개수,토픽재할당기준 2가지, random_state)
+        ldamodel = gensim.models.ldamodel.LdaModel(
+            corpus, # 각 문서를 단어 빈도수(BOW) 형태로 표현한 코퍼스
+            id2word = word_dict, # 단어 사전 : 각 단어의 고유 ID와 실제 단어를 매핑하는 딕셔너리 객체(초기 할당에 활용)
+            num_topics = i, # 생성할 토픽의
+
+            # passes, iterations : 두 인자를 통해 LDA모델은 문서(리뷰)와 단어의 토픽 할당을 더욱 정교하게 조정
+            passes = passes, # 전체 코퍼스를 대상으로 토픽 재할당 과정을 10번 반복
+                             # passes 값이 높을수록 모델은 전체 데이터에 대해 여러번 학습하며
+                             # 전반적인 토픽 구조를 더 안정적으로 추정할 수 있으나, 계산 비용이 증가함
+
+            iterations = iterations, # 각 문서(리뷰) 내에서 토픽 할당을 최적화하는 내부 알고리즘을 20번 반복 수행
+                                     # iterations 값이 높으면 각 문서의 토픽 할당이 더욱 세밀하게 조정되지만,
+                                     # 과도한 반복은 과적합이나 계산 시간 증가 위험이 있음
+
+            random_state = random_state # 난수 시드 값 : 결과 재현성을 위해 고정
+        )
+
+        # 2. Perplexity 계산(perplexity_score 변수에 담아주기)
+        perplexity_score = ldamodel.log_perplexity(corpus)
+
+        # 3. 2번에서 구한 값 perplexity_values 에 추가하기
+        perplexity_values.append(perplexity_score)
+
+        # 4. Coherence 모델 초기화
+        coherence_model = CoherenceModel(
+            model = ldamodel, # 평가 대상 LDA 모델 : 이 모델에서 생성된 토픽들의 일관성을 측정함
+            texts = all_documents, # 토큰화된 문서 리스트 : 모델 생성에 사용된 문서(리뷰)들을 기반으로 토픽 간
+                                   # 단어 관련성을 평가함
+            dictionary = word_dict, # 단어 사전 : 각 단어와 고유 ID의 매핑 정보를 제공, 텍스트 내 단어들이 유효한지
+                                    # 확인하는 역할
+            topn = fixed_topn       # 각 토픽에서 고려할 상위 단어의 개수 : 토픽의 대표 단어들을 선택하여
+                                    # 일관성 점수를 산출하는데 사용됨
+        )
+
+        # 5. Coherence 계산(coherence_score 변수에 담아주기)
+        coherence_score = coherence_model.get_coherence()
+
+        # 6. 5번에서 구한 값 coherence_values 에 추가하기
+        coherence_values.append(coherence_score)
+
+    x = list(topic_range) # 토픽 개수(2~9)
+
+    # 하나의 Figure 안에 여러 개의 서브 플롯(axes)을 생성
+    fig, ax = plt.subplots(
+        1,2, # 1행 2열의 서브 플롯을 생성
+        figsize=figsize # 전체 Figure 크기를 가로 12인치, 세로 5인치로 설정
+    )
+
+    # Perplexity 시각화
+    # ax[0] : 0번째 서브 플롯
+    ax[0].plot(x, perplexity_values, marker='o', linestyle='-')
+    ax[0].set_xlabel('Topic Counts')
+    ax[0].set_ylabel('Perplexity scores')
+    ax[0].set_title('Perplexity Changes')
+
+    # Coherence 시각화
+    # ax[1] : 1번째 서브 플롯
+    ax[1].plot(x, coherence_values, marker='o', linestyle='-', color='orange')
+    ax[1].set_xlabel('Topic Counts')
+    ax[1].set_ylabel('Coherence Scores')
+    ax[1].set_title('Coherence Changes')
+
+    plt.tight_layout() # 서브 플롯 간의 레이아웃 간격을 자동으로 조정하여 겹치지 않도록
+    plt.show()

new_value_analysis/action_finder/select_action_number.py

@@ -0,0 +1,33 @@
+"""문서(리뷰)별 토픽 분포에서 최빈/최대 확률 토픽(행동 번호)을 할당하는 함수 모음.
+
+- 문서별 토픽 분포를 순회하며 가장 높은 확률의 토픽 번호를 선택합니다.
+"""
+
+def assign_action_number(ldamodel, corpus):
+    import numpy as np
+
+    # 각 문서(리뷰)에서 가장 높은 확률을 가진 토픽 번호(액션 번호)를 저장할 리스트
+    action_number_assignment = []
+
+    # 모든 문서(리뷰)에 대해 토픽 분포를 순회하며, 가장 높은 확률의 토픽(행동) 번호를 선택
+    for doc_topic_distribution in ldamodel.get_document_topics(corpus):
+        # ldamodel.get_document_topics(corpus) : 각 문서(리뷰)의 토픽 분포
+        # print(doc_topic_distribution)
+
+        topic_ids = [] # 문서(리뷰)에 할당된 토픽 번호들을 저장할 리스트
+        topic_probabilities = [] # 각 토픽 확률들을 저장할 리스트
+
+        # 각(토픽,확률) 튜플 분해
+        for topic_info in doc_topic_distribution:
+            # doc_topic_distribution : 토픽 분포의 토픽과 토픽 확률에 대한 튜플
+            topic_ids.append(topic_info[0]) # 토픽 번호
+            topic_probabilities.append(topic_info[1]) # 해당 토픽의 확률 값
+
+        # 각 토픽에서 가장 높은 확률을 가진 토픽의 인덱스 찾기
+        max_index = np.argmax(topic_probabilities)
+        selected_action = topic_ids[max_index] # 가장 높은 확률의 토픽 번호 선택
+
+        # 선택 된 토픽 번호(액션 번호)를 결과 리스트에 추가
+        action_number_assignment.append(selected_action)
+
+    return action_number_assignment

new_value_analysis/action_finder/topic_modeling.py

@@ -0,0 +1,34 @@
+"""토픽 모델링(LDA) 학습 관련 함수 모음.
+
+- LDA 모델 학습 및 관련 결과를 생성하는 기능을 제공합니다.
+"""
+
+def LDA_train(
+    corpus,
+    word_dict,
+    topic_num=3,   # 생성할 토픽의 개수를 3으로 설정(임의로 설정)
+    passes=10,
+    iterations=20,
+    random_state=2025
+):
+    import gensim
+
+    # LDA 모델 생성 : 코퍼스 내 문서(리뷰)들을 대상으로 토픽을 추출
+    ldamodel = gensim.models.ldamodel.LdaModel(
+        corpus, # 각 문서를 단어 빈도수(BOW) 형태로 표현한 코퍼스
+        id2word = word_dict, # 단어 사전 : 각 단어의 고유 ID와 실제 단어를 매핑하는 딕셔너리 객체(초기 할당에 활용)
+        num_topics = topic_num, # 생성할 토픽의
+
+        # passes, iterations : 두 인자를 통해 LDA모델은 문서(리뷰)와 단어의 토픽 할당을 더욱 정교하게 조정
+        passes = passes, # 전체 코퍼스를 대상으로 토픽 재할당 과정을 10번 반복
+                         # passes 값이 높을수록 모델은 전체 데이터에 대해 여러번 학습하며
+                         # 전반적인 토픽 구조를 더 안정적으로 추정할 수 있으나, 계산 비용이 증가함
+
+        iterations = iterations, # 각 문서(리뷰) 내에서 토픽 할당을 최적화하는 내부 알고리즘을 20번 반복 수행
+                                 # iterations 값이 높으면 각 문서의 토픽 할당이 더욱 세밀하게 조정되지만,
+                                 # 과도한 반복은 과적합이나 계산 시간 증가 위험이 있음
+
+        random_state = random_state # 난수 시드 값 : 결과 재현성을 위해 고정
+    )
+
+    return ldamodel

new_value_analysis/actor_finder/__init__.py

@@ -0,0 +1,9 @@
+"""actor_finder 서브패키지
+
+Doc2Vec 임베딩 및 군집 진단(실루엣/덴드로그램) 관련 기능을 제공합니다.
+"""
+
+from .doc2vec import *  # noqa
+from .find_right_silhouette import *  # noqa
+from .silhouette_plot import *  # noqa
+from .visualize_dendrogram import *  # noqa

new_value_analysis/actor_finder/doc2vec.py

@@ -0,0 +1,79 @@
+"""Doc2Vec 기반 문서 임베딩 학습 함수 모음.
+
+- 토큰화된 문서(리뷰)로 Doc2Vec 모델을 학습하고 문서 벡터를 추출합니다.
+"""
+
+
+
+
+def train_doc2vec_module(
+    df,
+    token_col="tagged_review",
+    vector_size=100,
+    alpha=0.025,
+    min_alpha=0.001,
+    window=8,
+    epochs=5,
+    tag_prefix="document"
+):
+  # 자연어처리, 토픽 모델링을 위한 라이브러리
+    import gensim
+    from gensim.models.doc2vec import TaggedDocument # 문서 태깅 클래스
+    from gensim.models import doc2vec
+    """
+    df[token_col]에 토큰 리스트가 들어있다고 가정하고,
+    Doc2Vec 학습 + 문서벡터 리스트를 반환하는 모듈.
+
+    Returns
+    -------
+    model : gensim.models.doc2vec.Doc2Vec
+    vector_list : List[np.ndarray]
+    tagged_corpus_list : List[TaggedDocument]
+    """
+
+    # TaggedDocument 예시
+    TaggedDocument(
+        tags = ['document'], # 각 문서를 구분할 수 있는 태그(문서 ID)
+        words = df[token_col][1] # 해당 문서를 구성하는 단어(토큰) 목록
+    )
+
+    # tags의 경우, 리스트로 패킹해서 여러 문서 태그를 부여할 수도 있지만,
+    # 보통은 문서별로 하나의 태그(예 : 'document 1')만 사용하는 편이 많음
+
+    tagged_corpus_list = [] # 문서 태깅 결과를 담아둘 리스트
+
+    # 각 문서에 접근하여 문서 ID 태깅
+    for i, tokens in enumerate(df[token_col]):
+        tag = f"{tag_prefix} {i}"
+        tagged_doc = TaggedDocument(
+            tags = [tag],
+            words = tokens
+        )
+        tagged_corpus_list.append(tagged_doc)
+
+    # 1. doc2vec 모델 초기화
+    model = doc2vec.Doc2Vec(
+        vector_size = vector_size, # 학습할 벡터(임베딩)의 차원 수(예 : 100차원)
+        alpha = alpha, # 초기 학습률(learning rate)
+        min_alpha = min_alpha, # 학습 진행 중에 점차 감소시킬 최소 학습률
+        window = window # 주변 단어(window) 범위 설정(앞뒤 8개 단어)
+    )
+
+    # 2. 단어 사전(vocabulary) 생성
+    # TaggedDocument 리스트를 토대로 전체에 등장하는 단어들을 파악하고 모델에 등록
+    model.build_vocab(tagged_corpus_list)
+
+    # doc2vec 모델 학습 - 문서 벡터와 단어 벡터를 기반으로 학습
+    model.train(
+        tagged_corpus_list,
+        total_examples = model.corpus_count, # 전체 문서 개수
+        epochs = epochs # 학습 반복 횟수(너무 크면 과적합의 가능성 / 학습속도 느려짐)
+    )
+
+    vector_list = [] # 문서 벡터들을 담아둘 리스트
+
+    for i in range(len(df)):
+        doc2vec_vector = model.dv[f'{tag_prefix} {i}'] # 각 문서 벡터에 접근
+        vector_list.append(doc2vec_vector)
+
+    return model, vector_list, tagged_corpus_list

new_value_analysis/actor_finder/find_right_silhouette.py

@@ -0,0 +1,47 @@
+"""계층적 군집(AgglomerativeClustering)에서 실루엣 점수 기반 최적 군집 수 탐색.
+
+- 군집 수(n_clusters)를 변화시키며 실루엣 점수를 계산하고 적절한 값을 찾습니다.
+"""
+
+def agglomerative_silhouette_module(
+    df,
+    vector_col="vector",
+    n_clusters=2,
+    linkage="ward",
+    n_cluster_range=range(2, 10),
+    plot=True
+):
+    from sklearn.cluster import AgglomerativeClustering # 병합 군집, 어글로머레이티브
+    from sklearn.metrics.cluster import silhouette_score # 실루엣 계수 평균값 계산 도구
+    import matplotlib.pyplot as plt
+
+    # 1. 클러스터 초기화
+    cluster = AgglomerativeClustering(n_clusters=n_clusters, linkage=linkage)
+
+    # 2. 클러스터링(군집화)
+    cluster_label = cluster.fit_predict(list(df[vector_col])) # 군집 알고리즘에서 요구하는 입력포맷에 맞에 형변환
+
+    # 3. 평균 실루엣 지수 계산
+    silhouette_avg = silhouette_score(list(df[vector_col]), cluster_label)
+
+    # -1 ~ 1 사이의 값, 1에 가까울수록 잘 군집하였다고 판단
+
+    # 각 클러스터별 평균 실루엣 지수 확인
+    n_cluster = n_cluster_range # 클러스터 범위
+    scores = [] # 각 클러스터 별 실루엣 지수를 담아둘 리스트
+
+    for n in n_cluster:
+        cluster = AgglomerativeClustering(n_clusters=n, linkage=linkage) # 1. 클러스터 초기화
+        cluster_labels = cluster.fit_predict(list(df[vector_col])) # 2. 클러스터링
+        silhouette_avg_n = silhouette_score(list(df[vector_col]), cluster_labels) # 3. 평균 실루엣 지수 계산
+
+        scores.append(silhouette_avg_n)
+
+    # 각 클러스터별 평균 실루엣 지수 시각화
+    if plot:
+        plt.plot(list(n_cluster), scores)
+        plt.xlabel('Number of Clusters')
+        plt.ylabel('Silhouette Score')
+        plt.show()
+
+    # 군집 개수 3이 가장 높은 평균 실루엣 지수를 보임 (데이터에 따라 달라짐)

new_value_analysis/actor_finder/silhouette_plot.py

@@ -0,0 +1,55 @@
+"""KMeans 기반 실루엣 플롯 시각화 함수 모음.
+
+- 여러 K 값에 대해 실루엣 플롯을 그려 군집 품질을 비교합니다.
+"""
+
+import math
+import numpy as np
+import matplotlib.cm as cm
+import matplotlib.pyplot as plt
+from sklearn.datasets import make_blobs
+from sklearn.cluster import KMeans
+from sklearn.metrics import silhouette_samples, silhouette_score
+
+def visualize_silhouette(cluster_lists, X_features):
+    # 입력값으로 클러스터링 갯수들을 리스트로 받아서, 각 갯수별로 클러스터링을 적용하고 실루엣 개수를 구함
+    n_cols = len(cluster_lists)
+
+    # plt.subplots()으로 리스트에 기재된 클러스터링 수만큼의 sub figures를 가지는 axs 생성
+    fig, axs = plt.subplots(figsize=(4*n_cols, 4), nrows=1, ncols=n_cols)
+
+    # 리스트에 기재된 클러스터링 갯수들을 차례로 iteration 수행하면서 실루엣 개수 시각화
+    for ind, n_cluster in enumerate(cluster_lists):
+
+        # KMeans 클러스터링 수행하고, 실루엣 스코어와 개별 데이터의 실루엣 값 계산.
+        clusterer = KMeans(n_clusters = n_cluster, max_iter=500, random_state=0)
+        cluster_labels = clusterer.fit_predict(X_features)
+
+        sil_avg = silhouette_score(X_features, cluster_labels)
+        sil_values = silhouette_samples(X_features, cluster_labels)
+
+        y_lower = 10
+        axs[ind].set_title('Number of Cluster : '+ str(n_cluster)+'\n' \
+                          'Silhouette Score :' + str(round(sil_avg,3)) )
+        axs[ind].set_xlabel("The silhouette coefficient values")
+        axs[ind].set_ylabel("Cluster label")
+        axs[ind].set_xlim([-0.1, 1])
+        axs[ind].set_ylim([0, len(X_features) + (n_cluster + 1) * 10])
+        axs[ind].set_yticks([])
+        axs[ind].set_xticks([0, 0.2, 0.4, 0.6, 0.8, 1])
+
+        # 클러스터링 갯수별로 fill_betweenx( )형태의 막대 그래프 표현.
+        for i in range(n_cluster):
+            ith_cluster_sil_values = sil_values[cluster_labels==i]
+            ith_cluster_sil_values.sort()
+
+            size_cluster_i = ith_cluster_sil_values.shape[0]
+            y_upper = y_lower + size_cluster_i
+
+            color = cm.nipy_spectral(float(i) / n_cluster)
+            axs[ind].fill_betweenx(np.arange(y_lower, y_upper), 0, ith_cluster_sil_values, \
+                                facecolor=color, edgecolor=color, alpha=0.7)
+            axs[ind].text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
+            y_lower = y_upper + 10
+
+        axs[ind].axvline(x=sil_avg, color="red", linestyle="--")

new_value_analysis/actor_finder/visualize_dendrogram.py

@@ -0,0 +1,50 @@
+"""계층적 군집(덴드로그램) 시각화 함수 모음.
+
+- linkage 결과를 기반으로 덴드로그램을 출력합니다.
+"""
+
+def plot_dendrogram(
+    df,
+    vector_col="vector",
+    method="ward",
+    figsize=(15, 8),
+    orientation="top",
+    distance_sort="descending",
+    show_leaf_counts=True,
+    color_threshold=18,
+    show=True
+):
+    from scipy.cluster.hierarchy import dendrogram, linkage
+    import matplotlib.pyplot as plt
+
+    # dendrogram : 계층적 군집 결과(linked)를 트리 형태로 시각화
+    # linkage : 계층적 군집(Hierarchical Clustering)을 수행
+
+    # 계층적 군집 수행
+    linked = linkage(
+        list(df[vector_col]),  # 군집화 할 데이터 (군집 알고리즘에서 요구하는 입력포맷에 맞게 형변환)
+        # linkage : 2차원 배열형태 데이터 요구(지금 데이터는 vector리스트 담겨있기때문에 그대로 사용해도됨)
+        method  # 군집 방식 지정('ward' -> 군집 내 분산을 최소화)
+    )
+
+    # 덴드로그램 시각화
+    plt.figure(figsize=figsize)
+
+    dendrogram(
+        linked,  # 계층적 군집 결과
+        orientation=orientation,  # 덴드로그램의 방향(위에서 아래로 그리기(left,right,bottom))
+        distance_sort=distance_sort,  # 클러스터 간 거리를 기준으로 내림차순 정렬
+        show_leaf_counts=show_leaf_counts,  # 리프 노드(최종 말단)마다 샘플 개수 표시 여부
+        color_threshold=color_threshold  # y축 기준 -> 18 이상은 동일 색상(군집)으로 묶이지 않도록 설정
+    )
+
+    if show:
+        plt.show()
+
+    # y축 값이 낮은 지점에서 클러스터링 된 문서들은 서로 비슷한 내용일 가능성이 높음
+    # y축 값이 높은 곳에서 합쳐지는 문서들은 거리가 멀었다가 뒤늦게 합쳐진 것이므로, 서로 상이한 주제를 가질 수 있음
+
+    # 덴드로그램에서 threshold를 기준으로 크게 2개의 군집으로 나뉨
+    # 약 18지점에서 자르면 2개의 큰 군집으로 나누어지고, 더 아래로 자르면 3~4개 이상의 세부 군집으로 나눠볼 수도 있음(분석가의 몫)
+
+    return linked

new_value_analysis/opportunity_area_analysis/__init__.py

@@ -0,0 +1,7 @@
+"""opportunity_area_analysis 서브패키지
+
+Opportunity Area(기회영역) 분석을 위한 스케일링/시각화 기능을 제공합니다.
+"""
+
+from .satisfaction_scaling import *  # noqa
+from .opportunity_plot import *  # noqa

new_value_analysis/opportunity_area_analysis/opportunity_plot.py

@@ -0,0 +1,153 @@
+"""Opportunity Area(기회영역) 시각화 함수 모음.
+
+- 스케일링된 점수를 기반으로 Opportunity Area Plot을 생성합니다.
+"""
+
+# opportunity_plot.py
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from matplotlib.lines import Line2D
+
+
+@dataclass
+class OpportunityPlotConfig:
+    # 컬럼명
+    col_satisfaction: str = "satisfaction"
+    col_importance: str = "importance"
+    col_action: str = "Action"
+
+    # 축 범위
+    xlim: Tuple[float, float] = (1, 10)
+    ylim: Tuple[float, float] = (1, 10)
+
+    # 그림/스타일
+    figsize: Tuple[int, int] = (10, 8)
+    point_size: int = 35
+    edgecolor: str = "black"
+    label_fontsize: int = 10
+    show_grid: bool = True
+
+    # 평균선 색
+    line1_color: str = "r"
+    line2_color: str = "g"
+
+    # 범례
+    show_legend: bool = True
+    legend_title: str = "Actions"
+    legend_fontsize: int = 8
+    legend_title_fontsize: int = 10
+    legend_loc: str = "upper left"
+    legend_bbox_to_anchor: Tuple[float, float] = (1, 1)
+
+    # 저장 옵션
+    save_path: Optional[str] = "./data/Opportunity_area.png"
+    dpi: int = 300
+    bbox_inches: str = "tight"
+
+    # 색상 고정(재현성)
+    random_seed: Optional[int] = 42
+
+
+def plot_opportunity_area(
+    df: pd.DataFrame,
+    config: OpportunityPlotConfig = OpportunityPlotConfig(),
+    show: bool = True
+):
+    """
+    DataFrame을 입력으로 받아 Opportunity Area(중요도-만족도) 산점도를 그립니다.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        satisfaction, importance, Action 컬럼을 포함한 데이터프레임
+    config : OpportunityPlotConfig
+        컬럼명/스타일/저장옵션 설정
+    show : bool
+        True면 plt.show(), False면 figure 닫고 반환만
+
+    Returns
+    -------
+    (fig, ax)
+    """
+    # 1) 컬럼 추출
+    sat = df[config.col_satisfaction].to_numpy()
+    imp = df[config.col_importance].to_numpy()
+    act = df[config.col_action].astype(str).to_numpy()
+
+    # 2) 색상 생성(재현성)
+    rng = np.random.default_rng(config.random_seed) if config.random_seed is not None else np.random.default_rng()
+    colors = rng.random((len(act), 3))
+
+    # 3) figure 생성
+    fig, ax = plt.subplots(figsize=config.figsize)
+
+    # 4) 산점도
+    ax.scatter(
+        imp, sat,
+        s=config.point_size,
+        c=colors,
+        edgecolors=config.edgecolor
+    )
+
+    ax.set_xlabel("Importance")
+    ax.set_ylabel("Satisfaction")
+    ax.set_xlim(*config.xlim)
+    ax.set_ylim(*config.ylim)
+
+    # 5) 평균선(원본 로직 유지: 대각선 형태)
+    ax.plot(
+        [config.xlim[0], config.xlim[1]],
+        [sat.mean(), config.ylim[1]],
+        config.line1_color
+    )
+    ax.plot(
+        [imp.mean(), config.xlim[1]],
+        [config.ylim[0], config.ylim[1]],
+        config.line2_color
+    )
+
+    # 6) 텍스트 라벨
+    for i, a in enumerate(act):
+        ax.text(imp[i], sat[i], a, fontsize=config.label_fontsize, ha="left")
+
+    # 7) 범례 (더미 scatter 대신 handles 직접 생성 → 경고 없음)
+    if config.show_legend:
+        handles = [
+            Line2D(
+                [0], [0],
+                marker="o", linestyle="",
+                markerfacecolor=colors[i],
+                markeredgecolor=config.edgecolor,
+                markersize=6,
+                label=act[i]
+            )
+            for i in range(len(act))
+        ]
+        ax.legend(
+            handles=handles,
+            title=config.legend_title,
+            fontsize=config.legend_fontsize,
+            title_fontsize=config.legend_title_fontsize,
+            loc=config.legend_loc,
+            bbox_to_anchor=config.legend_bbox_to_anchor
+        )
+
+    if config.show_grid:
+        ax.grid(True)
+
+    # 8) 저장 (경로가 지정된 경우만)
+    if config.save_path:
+        fig.savefig(config.save_path, dpi=config.dpi, bbox_inches=config.bbox_inches)
+
+    if show:
+        plt.show()
+    else:
+        plt.close(fig)
+
+    return fig, ax

new_value_analysis/opportunity_area_analysis/satisfaction_scaling.py

@@ -0,0 +1,27 @@
+"""Opportunity Area 분석을 위한 점수 스케일링 함수 모음.
+
+- 만족도/중요도 등의 점수를 Min-Max 스케일링 등으로 정규화합니다.
+"""
+
+# sentiutils/scaling.py
+import numpy as np
+from sklearn.preprocessing import MinMaxScaler
+from typing import Dict, List, Union
+
+def minmax_scale_scores(
+    scores: Union[Dict, List],
+    feature_range: tuple = (1, 10),
+    round_digits: int = 4
+):
+    """
+    MinMaxScaler 기반 점수 스케일링 유틸
+    """
+    if isinstance(scores, dict):
+        scores = list(scores.values())
+
+    scores_array = np.array(scores).reshape(-1, 1)
+
+    scaler = MinMaxScaler(feature_range=feature_range)
+    scaled_scores = scaler.fit_transform(scores_array)
+
+    return [round(float(x), round_digits) for x in scaled_scores.flatten()]

new_value_analysis-0.1.0.dist-info/METADATA

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: new_value_analysis
+Version: 0.1.0
+Summary: New Value Analysis: actor/action/opportunity 분석 유틸리티 패키지
+Author: New Value Analysis contributors
+License: MIT
+Project-URL: Homepage, https://github.com/smhrdGit/new_value_analysis
+Project-URL: Repository, https://github.com/smhrdGit/new_value_analysis
+Project-URL: Issues, https://github.com/smhrdGit/new_value_analysis/issues
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: pandas>=1.5
+Requires-Dist: gensim>=4.3
+Requires-Dist: scikit-learn>=1.2
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: scipy>=1.10
+Dynamic: license-file
+
+# New Value Analysis
+
+`new_value_analysis`는 신규가치분석(New Value Analysis)을 위한 파이썬 유틸리티 패키지입니다.
+
+## 구성
+- `action_finder`: 토픽 모델링(LDA) 기반 Action(행동) 추출/할당
+- `actor_finder`: Doc2Vec 임베딩 + 군집 진단(실루엣/덴드로그램)
+- `opportunity_area_analysis`: Opportunity Area 스케일링/시각화
+
+## 설치(로컬 개발 모드)
+```bash
+pip install -U pip
+pip install -e .
+```
+
+## 사용 예시
+```python
+from new_value_analysis import action_finder, actor_finder, opportunity_area_analysis
+
+# 예: actor_finder 내부 함수 사용
+# model, vectors, tagged = actor_finder.train_doc2vec_module(df, token_col="tagged_review")
+```

new_value_analysis-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+new_value_analysis/__init__.py,sha256=NbX9b0Et4pRNDa6JT1Pm6_Z2m_YVioB44H64WD9Qfcs,461
+new_value_analysis/action_finder/__init__.py,sha256=OJOjsMv-j9sGwwiu_2e3VDZZ0XqusitXSAhdhIrUFyg,255
+new_value_analysis/action_finder/find_topicnum.py,sha256=CbGj-uP_a_BmEp-wHJjrMqs7KTgoWQDU2uuoxkI2lUs,4494
+new_value_analysis/action_finder/select_action_number.py,sha256=ySpa9L0FAdFC3U62qr6D-itjGraBXHbawPRhywgrKBQ,1674
+new_value_analysis/action_finder/topic_modeling.py,sha256=B0nf9ffu-8UBKh80AdevPXpvFSH48NlewuKd536heUM,1753
+new_value_analysis/actor_finder/__init__.py,sha256=HWORMWO33lTe7dTKUflMvs6AFN1akeBJo7fLvXaLRvQ,294
+new_value_analysis/actor_finder/doc2vec.py,sha256=lSl_iSjfY1-VvO5r_I3FFbKhTfZF-93WTyE6lEwzLjk,2801
+new_value_analysis/actor_finder/find_right_silhouette.py,sha256=EZONLNDggr4q1zXbGTkH0hlA5Iud1jMwY5Sevhx3hoc,1973
+new_value_analysis/actor_finder/silhouette_plot.py,sha256=BCy8h5Suce8Xfv3QS1XiwTi2JcJt_0JOCPyGR9xK1AQ,2589
+new_value_analysis/actor_finder/visualize_dendrogram.py,sha256=0cuZkxC26gdJ9-1GdfZ6ttbFrWheJOWmpvMve4Tba1E,2196
+new_value_analysis/opportunity_area_analysis/__init__.py,sha256=cPuB7XRX0xTPy43N3WWk37MzM8YMY09EcwbW-3d98pI,233
+new_value_analysis/opportunity_area_analysis/opportunity_plot.py,sha256=gpoj1g3M1cWiJlCAWXvCjuCLIy-5UGAA_zygWTJyAv0,4090
+new_value_analysis/opportunity_area_analysis/satisfaction_scaling.py,sha256=azsF46YjTaXAj7Q8UBqv_HtMlsUECWuHs6DeHndPlso,796
+new_value_analysis-0.1.0.dist-info/licenses/LICENSE,sha256=ESYyLizI0WWtxMeS7rGVcX3ivMezm-HOd5WdeOh-9oU,1056
+new_value_analysis-0.1.0.dist-info/METADATA,sha256=ShBHnRlzlUtrxsgN3ybcTOJc4FDyhQfM3fDmcH_0CIY,1447
+new_value_analysis-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+new_value_analysis-0.1.0.dist-info/top_level.txt,sha256=faC8m2gJvXl0zyiDG6eEtklFNwyI0OVpsnget5KrGNk,19
+new_value_analysis-0.1.0.dist-info/RECORD,,

new_value_analysis-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

new_value_analysis-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

new_value_analysis-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+new_value_analysis