Кластерный анализ модели предоставления разрешений в Tessa

# 1. Загрузка и подготовка данных
data = pd.read_csv('df_permission.csv', encoding='utf-8-sig')

print('Анализ данных:')
print(f'Размер: {data.shape}')
data.head(3)

# Преобразуем все в строки и заполняем пропуски
data = data.astype(str).fillna('Unknown')

# Убираем логически не нужные поля
#data = data.drop(['rule_id', 'rule_name', 'role_id', 'document_type_id', 'condition'], axis=1)

print(data.info())
print()
display(data.describe())
print()
data.head(5)

# 2. Анализ уникальных значений
print("Уникальные значения по полям:")
for col in data.columns:
    unique_count = data[col].nunique()
    print(f"{col}: {unique_count} уникальных значений")

# 3. Упрощенное кодирование категориальных признаков
def simple_category_encoding(data):
    """Упрощенное кодирование категориальных признаков"""
    encoded_data = pd.DataFrame()
    
    for col in data.columns:
        unique_count = data[col].nunique()
        
        if unique_count <= 20:
            # One-Hot для малого количества категорий
            dummies = pd.get_dummies(data[col], prefix=col)
            encoded_data = pd.concat([encoded_data, dummies], axis=1)
        else:
            # Frequency encoding для большого количества категорий
            freq_map = data[col].value_counts().to_dict()
            encoded_data[col] = data[col].map(freq_map)
    
    return encoded_data

print("Кодирование признаков...")
encoded_data = simple_category_encoding(data)
print(f"После кодирования: {encoded_data.shape} признаков")
encoded_data.head(5)

# 4. Стандартизация
scaler = StandardScaler()
scaled_data = scaler.fit_transform(encoded_data)
scaled_data

# 5. Уменьшение размерности с проверкой
if scaled_data.shape[1] > 2:
    # Используем PCA только если много признаков
    pca = PCA(n_components=0.9)  # 90% дисперсии
    reduced_data = pca.fit_transform(scaled_data)
    print(f"После PCA: {reduced_data.shape[1]} компонент")
else:
    reduced_data = scaled_data
    print("PCA не применен - мало признаков")

print(reduced_data.shape)
reduced_data

def find_optimal_clusters(data, max_k=8):
    """Подбор оптимального числа кластеров с анализом 'локтя' и методом силуэта"""
    best_score = -1
    best_k = 2
    wcss = []  # Within-cluster sum of squares

    # Зависимость количества кластеров 
    # от количества объектов в датафрейме
    if len(data) <= 10:
        max_k = int(len(data) / 2)
    elif 10 < len(data) <= 100:
        max_k = int(len(data) / 10)
    elif 100 < len(data) <= 1000:
        max_k = 10 + int(len(data) / 100)
    elif 1000 < len(data):
        max_k = 20 + int(len(data) / 10000)
        if max_k > 50: max_k = 50

    for k in range(2, max_k + 1):
        kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
        labels = kmeans.fit_predict(data)
        score = silhouette_score(data, labels)
        silhouette_vals = silhouette_samples(data, labels)

        # Рассчитываем сумму квадратов расстояний
        wcss.append(kmeans.inertia_)

        # Вычисляем статистику для значений силуэта
        min_val = np.min(silhouette_vals)
        mean_val = np.mean(silhouette_vals)
        median_val = np.median(silhouette_vals)
        max_val = np.max(silhouette_vals)

        print(f'Кластеров: {k}. Score: {score:.3f}')
        print(f'Silhouette values statistics:')
        #print(f"  Min: {min_val:.3f}")
        #print(f"  Mean: {mean_val:.3f}")
        #print(f"  Median: {median_val:.3f}")
        #print(f"  Max: {max_val:.3f}")
        display(pd.DataFrame({'Min':[min_val], 'Mean':[mean_val], 'Median':[median_val], 'Max':[max_val]}).round(3))

        if score > best_score:
            best_score = score
            best_k = k
            
            best_min_val = min_val
            best_mean_val = mean_val
            best_median_val = median_val
            best_max_val = max_val

    # Выводим оптимальное число кластеров по методу силуэта
    print(f'\nОптимальное число кластеров, выбранное "методом cилуэта": {best_k}. Score: {best_score:.3f}')
    print(f'Silhouette values statistics:')
    display(pd.DataFrame({'Min':[best_min_val], 'Mean':[best_mean_val], 'Median':[best_median_val], 'Max':[best_max_val]}).round(3))

    # Строим график для анализа 'локтя'
    print('\nВизуальная проверка выбранного количества кластеров "методом локтя" (Elbow Method):')
    plt.figure(figsize=(10, 6))
    plt.plot(range(2, max_k + 1), wcss, marker='o')
    plt.title('Метод локтя (Elbow Method)')
    plt.xlabel('Количество кластеров')
    plt.ylabel('Сумма квадратов расстояний (WCSS)')
    plt.grid(True)
    plt.show()

    return best_k

optimal_clusters = find_optimal_clusters(reduced_data)

# 7. Финальная кластеризация
kmeans = KMeans(n_clusters=optimal_clusters, random_state=42, n_init=10)
clusters = kmeans.fit_predict(reduced_data)
silhouette_vals = silhouette_samples(reduced_data, clusters)

# Предварительный просмотр результатов кластерного анализа
data_with_clusters = data.copy()
data_with_clusters['cluster'] = clusters
data_with_clusters['silhouette_vals'] = silhouette_vals

data_with_clusters.to_excel('data_with_clusters.xlsx')

print('Предварительный просмотр результатов кластерного анализа:')
#pd.DataFrame({'clusters': clusters, 'silhouette_vals': silhouette_vals})
data_with_clusters.head(5)

# 8. Визуализация результатов
plt.figure(figsize=(15, 5))

# Визуализация кластеров (первые 2 компоненты)
plt.subplot(1, 3, 1)
if reduced_data.shape[1] >= 2:
    plt.scatter(reduced_data[:, 0], reduced_data[:, 1], c=clusters, cmap='tab10', alpha=0.6)
    plt.xlabel('Компонента 1')
    plt.ylabel('Компонента 2')
else:
    # Если одна компонента - гистограмма
    for cluster in range(optimal_clusters):
        cluster_data = reduced_data[clusters == cluster, 0]
        plt.hist(cluster_data, alpha=0.6, label=f'Cluster {cluster}')
    plt.xlabel('Значение компоненты')
    plt.ylabel('Частота')
    plt.legend()

plt.title('Визуализация кластеров')

# Размеры кластеров
plt.subplot(1, 3, 2)
cluster_sizes = pd.Series(clusters).value_counts().sort_index()
plt.bar(cluster_sizes.index, cluster_sizes.values)
plt.xlabel('Кластер')
plt.ylabel('Количество объектов')
plt.title('Размеры кластеров')

for i, size in enumerate(cluster_sizes.values):
    plt.text(i, size, str(size), ha='center', va='bottom')

# Качество кластеризации по кластерам
plt.subplot(1, 3, 3)
from sklearn.metrics import silhouette_samples
silhouette_vals = silhouette_samples(reduced_data, clusters)

y_lower = 10
for i in range(optimal_clusters):
    cluster_silhouette_vals = silhouette_vals[clusters == i]
    cluster_silhouette_vals.sort()
    
    plt.barh(range(y_lower, y_lower + len(cluster_silhouette_vals)),
             cluster_silhouette_vals, height=1)
    plt.text(-0.05, y_lower + len(cluster_silhouette_vals) // 2, str(i))
    y_lower += len(cluster_silhouette_vals) + 10

plt.xlabel('Silhouette Score')
plt.ylabel('Кластер')
plt.title('Silhouette Analysis')

plt.tight_layout()
plt.show()

# Анализ параметров кластеров
def analyzing_cluster_parameters(data_with_clusters, cluster_nums, minimum_cluster_share):
    ''' Анализ параметров кластеров '''
    # data_with_clusters - датафрейм с указанием принадлежности к кластерам
    # cluster_nums - функция типа range(optimal_clusters) 
    #                для задания номеров кластеров для их перебора циклом
    # minimum_cluster_share - минимальная доля категории внутри кластера для ее учета
    
    analysis_cols = []
    for col in data.columns:
        if 2 <= data[col].nunique() <= 50:
            analysis_cols.append(col)
        if len(analysis_cols) >= 30: 
            break
    
    if not analysis_cols:
        # Если не нашли подходящие, берем первые 3 с наименьшим количеством категорий
        col_stats = [(col, data[col].nunique()) for col in data.columns]
        col_stats.sort(key=lambda x: x[1])
        analysis_cols = [col for col, count in col_stats[:3]]
    
    for cluster_num in cluster_nums:
        cluster_data = data_with_clusters[data_with_clusters['cluster'] == cluster_num]
        print(f"\n\n--- Кластер {cluster_num} ({len(cluster_data)} объектов, {len(cluster_data)/len(data_with_clusters):.1%}) ---")
        
        print('\nКачество объектов кластера:')
        display(pd.DataFrame({'Min':[data_with_clusters.loc[data_with_clusters['cluster'] == cluster_num, 'silhouette_vals'].min()], 
                              'Mean':[data_with_clusters.loc[data_with_clusters['cluster'] == cluster_num, 'silhouette_vals'].mean()], 
                              'Median':[data_with_clusters.loc[data_with_clusters['cluster'] == cluster_num, 'silhouette_vals'].median()], 
                              'Max':[data_with_clusters.loc[data_with_clusters['cluster'] == cluster_num, 'silhouette_vals'].max()]}).round(3))
        
        col = []
        value = []
        count = []
        percentage = []
        for c in analysis_cols:
            top_value = cluster_data[c].value_counts().head(1)
            if len(top_value) > 0:
                col.append(c)
                value.append(top_value.index[0])
                count.append(top_value.values[0])
                #percentage.append(f'{count[-1] / len(cluster_data):.1%}')
                percentage.append(count[-1] / len(cluster_data))
                #print(f"{col}:\t'{value}'\t({percentage:.1%})")
        #display(pd.DataFrame({'Параметр':col, 'Модальное значение':value, 'Количество':count, 'Доля в кластере':percentage}))
        print('\nКлючевые параметры, характеризующие кластер:')
        display_claster = pd.DataFrame({'Параметр':col, 'Модальное значение':value, 'Количество':count, 'Доля в кластере':percentage})
        display(display_claster[display_claster['Доля в кластере'] > minimum_cluster_share])
    
        print('\nПримеры объектов кластера:')
        display(data_with_clusters[data_with_clusters['cluster'] == cluster_num].head(5))

analyzing_cluster_parameters(data_with_clusters, range(optimal_clusters), .75)

# Табличное представление параметров кластеров
cluster_parameters = data_with_clusters.groupby(['cluster']).agg(lambda x: x.mode().iloc[0]).reset_index()
#cluster_parameters = data_with_clusters.groupby(['cluster']).agg(lambda x: x.mode()).reset_index()
cluster_parameters['silhouette_vals'] = data_with_clusters.groupby(['cluster'])['silhouette_vals'].mean()
cluster_parameters['cluster_size'] = data_with_clusters.groupby(['cluster']).size()
cluster_parameters['percentage_cluster_size'] = cluster_parameters['cluster_size'] / len(data_with_clusters)

cluster_parameters.to_excel('cluster_parameters.xlsx')

print('Табличное представление медианных значений ключевых параметров кластеров:')
cluster_parameters

# 10. Итоговая информация
silhouette_avg = silhouette_score(reduced_data, clusters)
print(f"\n=== ИТОГИ ===")
print(f"Исходные данные: {data.shape[1]} категориальных признаков")
print(f"После кодирования: {encoded_data.shape[1]} признаков")
print(f"Для кластеризации: {reduced_data.shape[1]} компонент")
print(f"Число кластеров: {optimal_clusters}")
print(f"Общее качество (silhouette): {silhouette_avg:.3f}")
print(f"Распределение по кластерам:")
for cluster_num in range(optimal_clusters):
    count = (clusters == cluster_num).sum()
    print(f"  Кластер {cluster_num}: {count} объектов ({count/len(clusters):.1%})")

# Анализ выбросов по сущствующим кластерам
analyzing_cluster_parameters(data_with_clusters[data_with_clusters['silhouette_vals'] < 0], 
                             data_with_clusters[data_with_clusters['silhouette_vals'] < 0]['cluster'].unique(), 
                             .75)

# Анализ выбросов с объединением выбросов в отдельный кластер

cluster_data = data_with_clusters[data_with_clusters['silhouette_vals'] < 0]
print(f"\n\n--- Кластер выбросов ({len(cluster_data)} объектов, {len(cluster_data)/len(data_with_clusters):.1%}) ---")

analysis_cols = []
for col in data.columns:
    if 2 <= data[col].nunique() <= 50:
        analysis_cols.append(col)
    if len(analysis_cols) >= 30: 
        break

if not analysis_cols:
    # Если не нашли подходящие, берем первые 3 с наименьшим количеством категорий
    col_stats = [(col, data[col].nunique()) for col in data.columns]
    col_stats.sort(key=lambda x: x[1])
    analysis_cols = [col for col, count in col_stats[:3]]

print('\nКачество объектов кластера:')
display(pd.DataFrame({'Min':[cluster_data['silhouette_vals'].min()], 
                      'Mean':[cluster_data['silhouette_vals'].mean()], 
                      'Median':[cluster_data['silhouette_vals'].median()], 
                      'Max':[cluster_data['silhouette_vals'].max()]}).round(3))

col = []
value = []
count = []
percentage = []
for c in analysis_cols:
    top_value = cluster_data[c].value_counts().head(1)
    if len(top_value) > 0:
        col.append(c)
        value.append(top_value.index[0])
        count.append(top_value.values[0])
        percentage.append(count[-1] / len(cluster_data))
print('\nКлючевые параметры, характеризующие кластер:')
display_claster = pd.DataFrame({'Параметр':col, 'Модальное значение':value, 'Количество':count, 'Доля в кластере':percentage})
display(display_claster[display_claster['Доля в кластере'] > .75])

print('\nПримеры объектов кластера:')
display(cluster_data.head(5))