Upload 3 files

app.py

@@ -0,0 +1,217 @@
+import gradio as gr
+import pandas as pd
+import os
+from work import LDAAnalyzer
+from datetime import datetime
+import shutil
+
+BASE_OUTPUT_DIR = "output"
+os.makedirs(BASE_OUTPUT_DIR, exist_ok=True)
+
+def create_output_dir():
+    """Создание директории для текущего анализа"""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    output_dir = os.path.join(BASE_OUTPUT_DIR, timestamp)
+    os.makedirs(output_dir, exist_ok=True)
+    return output_dir
+
+def show_columns(file):
+    """Получение списка колонок из загруженного файла"""
+    if file is None:
+        return gr.Dropdown(
+            choices=[],
+            value=None,
+            interactive=False,
+            label="Сначала загрузите файл"
+        )
+    
+    try:
+        df = pd.read_excel(file.name)
+        columns = [f"{i}: {col}" for i, col in enumerate(df.columns)]
+        return gr.Dropdown(
+            choices=columns,
+            value=None,
+            interactive=True,
+            label="Выберите колонку для анализа"
+        )
+    except Exception as e:
+        return gr.Dropdown(
+            choices=[],
+            value=None,
+            interactive=False,
+            label=f"Ошибка чтения файла: {str(e)}"
+        )
+
+def perform_analysis(file, selected_column, progress=gr.Progress()):
+    """Выполнение LDA анализа"""
+    if file is None or selected_column is None:
+        return ["⚠️ Ошибка: Загрузите файл и выберите колонку", 
+                None, None, None, None, None]
+    
+    try:
+        output_dir = create_output_dir()
+        input_file_path = os.path.join(output_dir, "data.xlsx")
+        shutil.copy2(file.name, input_file_path)
+        
+        column_idx = int(selected_column.split(":")[0])
+        
+        progress(0, desc="Инициализация...")
+        analyzer = LDAAnalyzer(input_file_path, column_idx)
+        
+        # Загрузка данных
+        progress(0.2, desc="📂 Загрузка данных...")
+        analyzer.load_data()
+        
+        # Подготовка данных
+        progress(0.4, desc="🔄 Подготовка данных...")
+        analyzer.prepare_data()
+        
+        # Выполнение анализа
+        progress(0.6, desc="📊 Выполнение LDA анализа...")
+        analyzer.perform_lda()
+        
+        # Получение и подготовка результатов перед сохранением
+        progress(0.8, desc="📊 Формирование результатов...")
+        
+        # Получаем матрицы напрямую из анализатора
+        confusion_matrix, percentages, accuracy = analyzer.create_confusion_matrix()
+        coefficients = analyzer.get_coefficients()
+        
+        # Подготовка данных для отображения
+        
+        # 1. Матрица классификации
+        df1 = confusion_matrix.copy()
+        df1.index = [f"{i+1}.00" for i in range(len(df1))]
+        df1.insert(0, "Исходный", df1.index)
+        df1.insert(1, "Количество", df1["Всего"])
+        
+        # 2. Проценты классификации
+        df2 = pd.DataFrame(percentages)
+        df2.index = [f"{i+1}.00" for i in range(len(df2))]
+        df2.columns = df1.columns[2:]  # Используем те же заголовки
+        df2.insert(0, "Исходный", df2.index)
+        df2.insert(1, "Количество", confusion_matrix["Всего"])
+        
+        # Добавляем строку с примечанием
+        note_row = pd.DataFrame({
+            "Исходный": f"* Примечание: {accuracy:.1f}% наблюдений классифицированы правильно.",
+            "Количество": "",
+        }, index=[""])
+        df2 = pd.concat([df2, note_row])
+        
+        # 3. Коэффициенты
+        df3 = coefficients.copy()
+        df3.index.name = "Переменная"
+        df3 = df3.reset_index()
+        
+        # Сохранение результатов
+        progress(0.9, desc="💾 Сохранение результатов...")
+        analyzer.save_results(output_dir)
+        
+        # Пути к файлам
+        results_file = os.path.join(output_dir, 'lda_results.xlsx')
+        plot_file = os.path.join(output_dir, 'lda_visualization.png')
+        
+        progress(1.0, desc="✅ Готово!")
+        return [
+            f"✅ Анализ успешно завершен!\nРезультаты сохранены в: {output_dir}",
+            df1,
+            df2,
+            df3,
+            plot_file,
+            results_file
+        ]
+            
+    except Exception as e:
+        error_msg = f"❌ Ошибка при выполнении анализа: {str(e)}"
+        print(error_msg)  # для отладки
+        return [error_msg, None, None, None, None, None]
+
+with gr.Blocks(title="LDA Анализ", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 📊 LDA Анализ
+    ### Загрузите Excel файл и выберите колонку для анализа
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            file_input = gr.File(
+                label="📑 Excel файл",
+                file_types=[".xlsx", ".xls"],
+                type="filepath"
+            )
+            
+        with gr.Column(scale=1):
+            column_select = gr.Dropdown(
+                label="🎯 Выберите колонку",
+                choices=[],
+                interactive=False
+            )
+            
+        with gr.Column(scale=1):
+            start_btn = gr.Button(
+                "▶️ Начать анализ",
+                variant="primary"
+            )
+    
+    status = gr.Markdown("💡 Ожидание начала анализа...")
+    
+    with gr.Tabs() as tabs:
+        with gr.Tab("📋 Матрица классификации"):
+            df1 = gr.Dataframe(
+                label="Матрица классификации",
+                headers=None,
+                datatype="number",
+                wrap=True,
+            )
+            
+        with gr.Tab("📊 Проценты"):
+            df2 = gr.Dataframe(
+                label="Проценты классификации",
+                headers=None,
+                datatype="number",
+                wrap=True
+            )
+            
+        with gr.Tab("📈 Коэффициенты"):
+            df3 = gr.Dataframe(
+                label="Коэффициенты функций",
+                headers=None,
+                datatype="number",
+                wrap=True
+            )
+            
+        with gr.Tab("📉 Визуализация"):
+            with gr.Column():
+                results_plot = gr.Image(
+                    label="График результатов",
+                    show_label=True
+                )
+                
+        with gr.Tab("📁 Файлы"):
+            with gr.Column():
+                results_file = gr.File(
+                    label="📊 Скачать полный отчет",
+                    show_label=True
+                )
+    
+    # Обработчики событий
+    file_input.change(
+        fn=show_columns,
+        inputs=[file_input],
+        outputs=[column_select]
+    )
+    
+    start_btn.click(
+        fn=perform_analysis,
+        inputs=[file_input, column_select],
+        outputs=[
+            status,
+            df1, df2, df3,
+            results_plot, results_file
+        ],
+        show_progress=True
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,8 @@
+numpy>=1.20.0
+scikit-learn>=0.24.0
+matplotlib>=3.3.0
+seaborn>=0.11.0
+xlsxwriter>=3.0.0
+openpyxl>=3.0.0
+gradio>=5.0.0
+pandas==2.2.3

work.py

@@ -0,0 +1,435 @@
+import pandas as pd
+import numpy as np
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.decomposition import PCA
+from sklearn.feature_selection import SelectKBest, f_classif
+import matplotlib.pyplot as plt
+import seaborn as sns
+import logging
+import os
+from datetime import datetime
+from typing import Dict, Tuple, List, Optional, Any
+import xlsxwriter
+
+class LDAAnalyzer:
+    """
+    Класс для выполнения линейного дискриминантного анализа (LDA)
+    с расширенной функциональностью и форматированным выводом результатов
+    """
+    
+    def __init__(self, input_file: str, target_column: int):
+        """
+        Инициализация анализатора LDA
+        
+        Args:
+            input_file (str): Путь к входному файлу Excel
+            target_column (int): Номер столбца для классификации
+        """
+        self.input_file = input_file
+        self.target_column = target_column
+        self.data = None
+        self.X = None
+        self.y = None
+        self.X_transformed = None
+        self.lda = None
+        self.scaler = StandardScaler()
+        self.label_encoder = LabelEncoder()
+        self.feature_names = None
+        
+        # Настройка логирования
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(levelname)s - %(message)s',
+            handlers=[
+                logging.FileHandler('lda_analysis.log'),
+                logging.StreamHandler()
+            ]
+        )
+        self.logger = logging.getLogger(__name__)
+        
+        # Цветовая схема для визуализации
+        self.colors = ['lightblue', 'green', 'purple', 'yellow', 
+                      'red', 'orange', 'cyan', 'brown', 'pink']
+        
+        self.logger.info(f"Инициализация LDA анализатора с файлом: {input_file}")
+
+    def validate_data(self) -> None:
+        """Валидация входных данных"""
+        if self.data is None:
+            raise ValueError("Данные не загружены")
+            
+        # Проверка размерности
+        if self.data.shape[0] < 30:
+            raise ValueError("Недостаточно наблюдений (минимум 30)")
+            
+        # Проверка пропущенных значений
+        if self.data.isnull().any().any():
+            raise ValueError("Обнаружены пропущенные значения")
+            
+        # Проверка типов данных
+        numeric_cols = self.data.select_dtypes(include=[np.number]).columns
+        if len(numeric_cols) < self.data.shape[1] - 1:  # -1 для целевой переменной
+            raise ValueError("Обнаружены нечисловые признаки")
+
+    def load_data(self) -> None:
+        """Загрузка данных из Excel файла"""
+        try:
+            self.logger.info("Загрузка данных...")
+
+            # Загрузка данных
+            self.data = pd.read_excel(self.input_file)
+
+            # Преобразование имен колонок
+            self.data.columns = [str(col) for col in self.data.columns]
+
+            # Попытка преобразовать все колонки (кроме целевой) в числовой формат
+            for col in self.data.columns:
+                if self.data.columns.get_loc(col) != self.target_column:
+                    try:
+                        self.data[col] = pd.to_numeric(self.data[col], errors='coerce')
+                    except Exception as e:
+                        self.logger.warning(f"Не удалось преобразовать колонку {col} в числовой формат: {str(e)}")
+
+            self.validate_data()
+            self.logger.info(f"Данные загружены. Размерность: {self.data.shape}")
+
+        except Exception as e:
+            self.logger.error(f"Ошибка при загрузке данных: {str(e)}")
+            raise
+
+    
+    
+    def prepare_data(self) -> None:
+        """Подготовка данных для анализа"""
+        try:
+            self.logger.info("Подготовка данных...")
+
+            # Разделение на признаки и целевую переменную
+            X = self.data.drop(self.data.columns[self.target_column], axis=1)
+            y = self.data.iloc[:, self.target_column]
+
+            # Преобразование имен колонок в строки
+            X.columns = X.columns.astype(str)
+
+            # Кодирование меток классов
+            self.y = self.label_encoder.fit_transform(y) + 1
+
+            # Преобразование в числовой формат
+            X = X.apply(pd.to_numeric, errors='coerce')
+
+            # Проверка на пропущенные значения после преобразования
+            if X.isnull().any().any():
+                raise ValueError("После преобразования в числовой формат появились пропущенные значения")
+
+            # Стандартизация признаков
+            self.X = self.scaler.fit_transform(X)
+
+            # Проверка количества классов и наблюдений в каждом классе
+            class_counts = pd.Series(self.y).value_counts()
+            if (class_counts < 5).any():
+                self.logger.warning("Некоторые классы имеют менее 5 наблюдений")
+
+            self.logger.info(f"Данные подготовлены. X: {self.X.shape}, y: {self.y.shape}")
+            self.logger.info(f"Количество классов: {len(np.unique(self.y))}")
+
+        except Exception as e:
+            self.logger.error(f"Ошибка при подготовке данных: {str(e)}")
+            raise
+        
+    def perform_lda(self) -> None:
+        """Выполнение LDA анализа"""
+        try:
+            self.logger.info("Выполнение LDA анализа...")
+            
+            # Инициализация и обучение LDA
+            self.lda = LinearDiscriminantAnalysis(solver='svd')
+            self.X_transformed = self.lda.fit_transform(self.X, self.y)
+            
+            # Оценка качества модели
+            accuracy = self.lda.score(self.X, self.y)
+            self.logger.info(f"Общая точность модели: {accuracy:.3f}")
+            
+        except Exception as e:
+            self.logger.error(f"Ошибка при выполнении LDA: {str(e)}")
+            raise
+
+    def create_confusion_matrix(self) -> Tuple[pd.DataFrame, List[List[str]], float]:
+        """
+        Создание матрицы ошибок и расчет процентов классификации
+
+        Returns:
+            tuple: (матрица ошибок, проценты, общая точность)
+        """
+        try:
+            self.logger.info("Создание матрицы ошибок...")
+
+            # Получение предсказаний
+            y_pred = self.lda.predict(self.X)
+
+            # Создание матрицы ошибок
+            classes = sorted(np.unique(self.y))
+            n_classes = len(classes)
+            confusion_matrix = np.zeros((n_classes, n_classes))
+
+            for i in range(len(self.y)):
+                confusion_matrix[self.y[i]-1][y_pred[i]-1] += 1
+
+            # Создание DataFrame для матрицы ошибок
+            columns = [f"{i+1}.00" for i in range(n_classes)]
+            index = [f"{i+1}.00" for i in range(n_classes)]
+
+            df_confusion = pd.DataFrame(confusion_matrix, columns=columns, index=index)
+
+            # Добавление столбца "Всего"
+            df_confusion['Всего'] = df_confusion.sum(axis=1)
+
+            # Расчет процентов
+            percentages = np.zeros((n_classes, n_classes + 1))  # +1 для столбца "Всего"
+            for i in range(n_classes):
+                row_sum = confusion_matrix[i].sum()
+                if row_sum > 0:
+                    percentages[i, :-1] = (confusion_matrix[i] / row_sum) * 100
+                    percentages[i, -1] = 100.0
+
+            # Форматирование процентов
+            percentage_rows = []
+            for row in percentages:
+                formatted_row = [f"{x:.1f}" for x in row]
+                percentage_rows.append(formatted_row)
+
+            # Расчет общей точности
+            accuracy = (np.sum(np.diag(confusion_matrix)) / np.sum(confusion_matrix)) * 100
+
+            self.logger.info(f"Процент правильной классификации: {accuracy:.1f}%")
+
+            return df_confusion, percentage_rows, accuracy
+
+        except Exception as e:
+            self.logger.error(f"Ошибка при создании матрицы ошибок: {str(e)}")
+            raise
+
+    def get_coefficients(self) -> pd.DataFrame:
+        """
+        Получение коэффициентов дискриминантных функций
+        
+        Returns:
+            pd.DataFrame: таблица коэффициентов
+        """
+        try:
+            self.logger.info("Получение коэфф��циентов...")
+            
+            # Получение коэффициентов и размерностей
+            n_features = self.X.shape[1]
+            n_classes = len(np.unique(self.y))
+            n_components = min(n_classes - 1, n_features)
+            
+            # Создание списка имен переменных
+            var_names = [f"VAR{str(i+1).zfill(5)}" for i in range(n_features)]
+            
+            # Создание DataFrame с коэффициентами
+            coef_data = []
+            for i in range(n_components):
+                row_data = {}
+                for j, var_name in enumerate(var_names):
+                    row_data[var_name] = self.lda.coef_[i][j]
+                coef_data.append(row_data)
+            
+            df_coef = pd.DataFrame(coef_data, index=[f"Функция {i+1}" for i in range(n_components)])
+            
+            # Добавление константы (intercept)
+            const_data = {}
+            for j, var_name in enumerate(var_names):
+                const_data[var_name] = self.lda.intercept_[j] if j < len(self.lda.intercept_) else 0.0
+            
+            const_df = pd.DataFrame([const_data], index=['Константа'])
+            
+            # Объединение коэффициентов и константы
+            df_coef = pd.concat([df_coef, const_df])
+            
+            # Округление значений
+            df_coef = df_coef.round(3)
+            
+            self.logger.info("Коэффициенты получены")
+            return df_coef
+            
+        except Exception as e:
+            self.logger.error(f"Ошибка при получении коэффициентов: {str(e)}")
+            raise
+
+    def create_visualization(self) -> plt.Figure:
+        """
+        Создание визуализации результатов
+        
+        Returns:
+            plt.Figure: объект графика
+        """
+        try:
+            self.logger.info("Создание визуализации...")
+            
+            fig = plt.figure(figsize=(12, 8))
+            
+            # Построение точек для каждого класса
+            for class_num in np.unique(self.y):
+                mask = self.y == class_num
+                plt.scatter(
+                    self.X_transformed[mask, 0],
+                    self.X_transformed[mask, 1] if self.X_transformed.shape[1] > 1 
+                    else np.zeros_like(self.X_transformed[mask, 0]),
+                    c=[self.colors[(class_num-1) % len(self.colors)]],
+                    label=f'Группа {class_num}',
+                    alpha=0.7
+                )
+                
+                # Добавление центроидов
+                centroid = np.mean(self.X_transformed[mask, :2], axis=0)
+                plt.scatter(
+                    centroid[0],
+                    centroid[1] if self.X_transformed.shape[1] > 1 else 0,
+                    c='black',
+                    marker='s',
+                    s=100
+                )
+                plt.annotate(
+                    f'{class_num}',
+                    (centroid[0], centroid[1]),
+                    xytext=(5, 5),
+                    textcoords='offset points',
+                    fontsize=10,
+                    bbox=dict(facecolor='white', edgecolor='none', alpha=0.7)
+                )
+            
+            plt.xlabel('Первая каноническая функция')
+            plt.ylabel('Вторая каноническая функция')
+            plt.title('Канонические дискриминантные функции')
+            plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
+            plt.grid(True, alpha=0.3)
+            plt.tight_layout()
+            
+            self.logger.info("Визуализация создана")
+            return fig
+            
+        except Exception as e:
+            self.logger.error(f"Ошибка при создании визуализации: {str(e)}")
+            raise
+
+    def save_results(self, output_dir: str) -> None:
+        """
+        Сохранение всех результатов анализа
+
+        Args:
+            output_dir (str): директория для сохранения результатов
+        """
+        try:
+            self.logger.info(f"Сохранение результатов в {output_dir}...")
+
+            # Создание директории если её нет
+            os.makedirs(output_dir, exist_ok=True)
+
+            # Получение результатов
+            confusion_matrix, percentages, accuracy = self.create_confusion_matrix()
+            coefficients = self.get_coefficients()
+
+            # Сохранен��е в Excel
+            excel_path = os.path.join(output_dir, 'lda_results.xlsx')
+            with pd.ExcelWriter(excel_path, engine='xlsxwriter') as writer:
+                workbook = writer.book
+
+                # Форматы для Excel
+                header_format = workbook.add_format({
+                    'bold': True,
+                    'align': 'center',
+                    'valign': 'vcenter',
+                    'bg_color': '#D9D9D9',
+                    'border': 1
+                })
+
+                cell_format = workbook.add_format({
+                    'align': 'center',
+                    'border': 1
+                })
+
+                number_format = workbook.add_format({
+                    'align': 'center',
+                    'border': 1,
+                    'num_format': '0.000'
+                })
+
+                # 1. Матрица классификации
+                worksheet1 = workbook.add_worksheet('Матрица классификации')
+
+                # Записываем заголовки
+                headers = ['Исходный', 'Количество'] + \
+                         [f'{i+1}.00' for i in range(len(confusion_matrix.columns)-1)] + \
+                         ['Всего']
+                for col, header in enumerate(headers):
+                    worksheet1.write(0, col, header, header_format)
+                    worksheet1.set_column(col, col, 15)
+
+                # Записываем данные
+                for i, (index, row) in enumerate(confusion_matrix.iterrows()):
+                    worksheet1.write(i+1, 0, index, cell_format)
+                    worksheet1.write(i+1, 1, row['Всего'], cell_format)
+                    for j, val in enumerate(row):
+                        worksheet1.write(i+1, j+2, val, cell_format)
+
+                # 2. Проценты классификации
+                worksheet2 = workbook.add_worksheet('Проценты')
+
+                # Заголовки
+                for col, header in enumerate(headers):
+                    worksheet2.write(0, col, header, header_format)
+                    worksheet2.set_column(col, col, 15)
+
+                # Данные процентов
+                for i, row in enumerate(percentages):
+                    worksheet2.write(i+1, 0, f"{i+1}.00", cell_format)
+                    worksheet2.write(i+1, 1, confusion_matrix.iloc[i]['Всего'], cell_format)
+                    for j, val in enumerate(row):
+                        worksheet2.write(i+1, j+2, float(val.replace(',', '.')), number_format)
+
+                # Примечание
+                note_row = len(percentages) + 2
+                worksheet2.write(
+                    note_row, 0,
+                    f'* Примечание: {accuracy:.1f}% исходных сгруппированных наблюдений '
+                    f'классифицированы правильно.',
+                    workbook.add_format({'bold': True})
+                )
+
+                # 3. Коэффициенты функций
+                worksheet3 = workbook.add_worksheet('Коэффициенты')
+
+                # Записываем заголовки коэффициентов
+                worksheet3.write(0, 0, 'Переменная', header_format)
+                for i, col in enumerate(coefficients.columns):
+                    worksheet3.write(0, i+1, col, header_format)
+                    worksheet3.set_column(i+1, i+1, 15)
+
+                # Записываем данные коэффициентов
+                for i, (index, row) in enumerate(coefficients.iterrows()):
+                    worksheet3.write(i+1, 0, index, cell_format)
+                    for j, val in enumerate(row):
+                        worksheet3.write(i+1, j+1, val, number_format)
+
+                # Добавляем примечание к коэффициентам
+                worksheet3.write(
+                    len(coefficients)+1, 0,
+                    '*Нестандартизованные коэффициенты',
+                    workbook.add_format({'bold': True, 'italic': True})
+                )
+
+            # Сохранение визуализации
+            fig = self.create_visualization()
+            fig.savefig(
+                os.path.join(output_dir, 'lda_visualization.png'),
+                bbox_inches='tight',
+                dpi=300
+            )
+            plt.close(fig)
+
+            self.logger.info("Результаты успешно сохранены")
+
+        except Exception as e:
+            self.logger.error(f"Ошибка при сохранении результатов: {str(e)}")
+            raise