Управление качеством / 7 семестр / Новый текстовый документ

import sys
import numpy as np
import matplotlib.pyplot as plt
import networkx as nx
from concurrent.futures import ProcessPoolExecutor
from scipy.optimize import curve_fit

# Функция для экспоненциальной модели
def exp_model(alpha, a0, a1, a2):
    return np.exp(a0 + a1 * alpha + a2 * alpha**2)

# Функция для вычисления структурной надежности связности графа
def connectivity(matrix):
    n = matrix.shape[0]
    R = np.sum(matrix) // 2  # Количество рёбер в графе
    R_min = n - 1  # Минимальное количество рёбер для связности
    R_max = n * (n - 1) // 2  # Максимальное количество рёбер в графе
    if R < R_min:
        print('ОШИБКА - граф не связан, в модуле "вычиление запаса структурной надежности"')
        return -1  # Граф несвязный

    alpha = (R - R_min) / (R_max - R_min)
    return alpha

# Функция для вычисления центральности графа
def centrality_index(matrix):
    G = nx.from_numpy_array(matrix)  # Создаем граф из матрицы
    if not nx.is_connected(G):
        return 0
    centrality = nx.betweenness_centrality(G, k=min(10, matrix.shape[0]))
    return np.mean(list(centrality.values()))

# Эксперимент: вычисление структурной надежности и центральности
def experiment(n, show_intermediate=False):
    while True:  # Цикл для гарантии создания связного графа
        # Генерация полносвязного графа
        matrix = np.ones((n, n), dtype=int)
        np.fill_diagonal(matrix, 0)
        max_edges = n * (n - 1) // 2

        if show_intermediate:
            print(f"\nГенерация полносвязного графа с {n} вершинами")
            print(matrix)

        # Удаление случайных рёбер
        m = np.random.randint(int(0.4 * max_edges), int(0.7 * max_edges))
        edge_indices = [(i, j) for i in range(n) for j in range(i + 1, n)]
        random_edges = np.random.choice(len(edge_indices), size=m, replace=False)
        for idx in random_edges:
            i, j = edge_indices[idx]
            matrix[i, j] = 0
            matrix[j, i] = 0

        if show_intermediate:
            print(f"\nМатрица после удаления {m} рёбер:")
            print(matrix)

        # Проверка связности графа
        G = nx.from_numpy_array(matrix)
        if nx.is_connected(G):
            if show_intermediate:
                print("\nГраф связный.")
            break
        elif show_intermediate:
            print("\nГраф несвязный. Перегенерация...")

    # Вычисление структурной надежности
    alpha = connectivity(matrix)
    if show_intermediate:
        print(f"\nРезультат вычисления структурной надежности (α): {alpha}")

    # Вычисление центральности
    beta = centrality_index(matrix)
    if show_intermediate:
        print(f"Результат вычисления центральности (β): {beta}")

    return alpha, beta

# Главный цикл для экспериментов
N_values = [5, 10, 25, 50, 100]
scatter_data = {}

def run_experiments(n, show_intermediate_once):
    results = []
    for i in range(1000):  # Количество экспериментов фиксировано
        show_intermediate = show_intermediate_once and (i == 0)  # Промежуточные результаты только для первого графа
        alpha, beta = experiment(n, show_intermediate)
        results.append((alpha, beta))
    return results

def process_experiments(show_intermediate_once):
    with ProcessPoolExecutor() as executor:
        futures = {n: executor.submit(run_experiments, n, show_intermediate_once) for n in N_values}
        for n, future in futures.items():
            scatter_data[n] = future.result()

# Запуск экспериментов
if __name__ == '__main__':
    show_intermediate_once = input("Выводить промежуточные результаты для одного графа? (да/нет): ").strip().lower() == 'да'

    for i in range(len(N_values)):
        if N_values[i] <= 0:
            print("ОШИБКА - Число вершин должно быть > 0 ")
            sys.exit()
        if N_values[i] > 100:
            print("ОШИБКА - Число вершин должно быть < 100 ")
            sys.exit()

    process_experiments(show_intermediate_once)

    for n, data in scatter_data.items():
        data_array = np.array(data)
        alpha_values = data_array[:, 0]
        beta_values = data_array[:, 1]

        # Подгонка экспоненциальной модели
        popt, _ = curve_fit(exp_model, alpha_values, beta_values, p0=(0.1, 0.1, 0.1))
        a0, a1, a2 = popt

        # Генерация модели для визуализации
        alpha_model = np.linspace(min(alpha_values), max(alpha_values), 100)
        beta_model = exp_model(alpha_model, a0, a1, a2)

        # Визуализация
        plt.figure(figsize=(10, 6))
        plt.scatter(alpha_values, beta_values, color='blue', alpha=0.5, s=10, label='Экспериментальные данные')
        plt.plot(alpha_model, beta_model, color='red', lw=2, label=f'Экспоненциальная модель\n$a_0={a0:.3f}$, $a_1={a1:.3f}$, $a_2={a2:.3f}$')
        plt.title(f'Структурная надежность vs Центральность (n={n})')
        plt.xlabel('Структурная надежность (α)')
        plt.ylabel('Центральность (β)')
        plt.grid(True)
        plt.legend()
        plt.show()