Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-3-7-sonnet-20250219· AnthropicHugging Face LMArena Human Preference 140K

Напиши код на питоне, отображающий корреляционные плеяды: плеяды должны быть в…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-pro-preview-05-06’s answer.
  1. User

    Напиши код на питоне, отображающий корреляционные плеяды: плеяды должны быть в чёрно-белом стиле. Вот эти данные: Копинг-стратегия rS Жизнестойкость (суммарный показатель) Стрессоустойчивость Снижение значения 0,569396** 0,456470** Самоодобрение 0,433096** 0,264605* Самооправдание 0,562062** 0,491853** Отвлечение 0,570737** 0,412497** Замещение 0,611584** 0,477012** Самоутверждение 0,613830** 0,572066** Психомышечная релаксация 0,534910** 0,405464** Контроль над ситуацией 0,642145** 0,505721** Самоконтроль 0,650619** 0,542279** Позитивная самомотивация 0,522509** 0,384182** Поиск социальной поддержки –0,338233** –0,225177 Антиципирующее избегание –0,495930** –0,454909** Бегство от стрессовой ситуации –0,150345 –0,158840 Социальная замкнутость –0,130122 –0,055698 Заезженная пластинка –0,110317 –0,118082* Беспомощность –0,398868** –0,272497* Жалость к себе –0,712386** –0,559201** Самообвинение –0,528319** –0,351987** Агрессия –0,494614** –0,366506** Прием лекарств –0,409118** –0,319972**

  2. Claude Assistant

    Вот код на Python для отображения корреляционных плеяд в черно-белом стиле:

    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import networkx as nx
    
    # Создаем DataFrame из данных
    data = {
        'Копинг-стратегия': [
            'Снижение значения', 'Самоодобрение', 'Самооправдание', 'Отвлечение', 
            'Замещение', 'Самоутверждение', 'Психомышечная релаксация', 
            'Контроль над ситуацией', 'Самоконтроль', 'Позитивная самомотивация', 
            'Поиск социальной поддержки', 'Антиципирующее избегание', 
            'Бегство от стрессовой ситуации', 'Социальная замкнутость', 
            'Заезженная пластинка', 'Беспомощность', 'Жалость к себе', 
            'Самообвинение', 'Агрессия', 'Прием лекарств'
        ],
        'Жизнестойкость': [
            0.569396, 0.433096, 0.562062, 0.570737, 0.611584, 0.613830, 0.534910,
            0.642145, 0.650619, 0.522509, -0.338233, -0.495930, -0.150345, 
            -0.130122, -0.110317, -0.398868, -0.712386, -0.528319, -0.494614, -0.409118
        ],
        'Стрессоустойчивость': [
            0.456470, 0.264605, 0.491853, 0.412497, 0.477012, 0.572066, 0.405464,
            0.505721, 0.542279, 0.384182, -0.225177, -0.454909, -0.158840, 
            -0.055698, -0.118082, -0.272497, -0.559201, -0.351987, -0.366506, -0.319972
        ]
    }
    
    df = pd.DataFrame(data)
    
    # Функция для создания корреляционных плеяд
    def plot_correlation_pleiad(df, threshold=0.3):
        # Создаем граф
        G = nx.Graph()
        
        # Добавляем узлы
        G.add_node("Жизнестойкость", pos=(0, 0))
        G.add_node("Стрессоустойчивость", pos=(10, 0))
        
        # Добавляем узлы копинг-стратегий и связи
        for i, row in df.iterrows():
            strategy = row['Копинг-стратегия']
            G.add_node(strategy, pos=(5, i))
            
            # Добавляем связи, если корреляция выше порога
            if abs(row['Жизнестойкость']) >= threshold:
                G.add_edge("Жизнестойкость", strategy, weight=abs(row['Жизнестойкость']), 
                           style='solid' if row['Жизнестойкость'] > 0 else 'dashed')
            
            if abs(row['Стрессоустойчивость']) >= threshold:
                G.add_edge("Стрессоустойчивость", strategy, weight=abs(row['Стрессоустойчивость']), 
                           style='solid' if row['Стрессоустойчивость'] > 0 else 'dashed')
        
        # Получаем позиции узлов
        pos = nx.get_node_attributes(G, 'pos')
        
        # Создаем рисунок
        plt.figure(figsize=(12, 14))
        
        # Рисуем узлы
        nx.draw_networkx_nodes(G, pos, 
                              nodelist=["Жизнестойкость", "Стрессоустойчивость"],
                              node_size=2000, 
                              node_color='black')
        
        nx.draw_networkx_nodes(G, pos, 
                              nodelist=[n for n in G.nodes() if n not in ["Жизнестойкость", "Стрессоустойчивость"]],
                              node_size=1500, 
                              node_color='white', 
                              edgecolors='black')
        
        # Рисуем ребра с разной толщиной в зависимости от веса
        for (u, v, d) in G.edges(data=True):
            if d['style'] == 'solid':
                nx.draw_networkx_edges(G, pos, edgelist=[(u, v)], width=d['weight']*3, 
                                      edge_color='black')
            else:
                nx.draw_networkx_edges(G, pos, edgelist=[(u, v)], width=d['weight']*3, 
                                      edge_color='black', style='dashed')
        
        # Добавляем метки
        nx.draw_networkx_labels(G, pos, font_size=10, font_family='sans-serif')
        
        plt.axis('off')
        plt.title('Корреляционные плеяды копинг-стратегий', fontsize=16)
        plt.tight_layout()
        plt.show()
    
    # Строим корреляционные плеяды с порогом 0.3
    plot_correlation_pleiad(df, threshold=0.3)
    

    Хотите, чтобы я объяснил или разбил этот код?

  3. User

    На линиях пиши коэффициенты корреляции. От черных кругов откажись. И сделай так, чтобы плеяда все-таки хорошо различалась. Внизу оставь примечание под звёздочкой как отображены прямые и обратные связи.

  4. Claude Assistant

    Вот обновленный код с учетом ваших требований:

    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import networkx as nx
    
    # Создаем DataFrame из данных
    data = {
        'Копинг-стратегия': [
            'Снижение значения', 'Самоодобрение', 'Самооправдание', 'Отвлечение', 
            'Замещение', 'Самоутверждение', 'Психомышечная релаксация', 
            'Контроль над ситуацией', 'Самоконтроль', 'Позитивная самомотивация', 
            'Поиск социальной поддержки', 'Антиципирующее избегание', 
            'Бегство от стрессовой ситуации', 'Социальная замкнутость', 
            'Заезженная пластинка', 'Беспомощность', 'Жалость к себе', 
            'Самообвинение', 'Агрессия', 'Прием лекарств'
        ],
        'Жизнестойкость': [
            0.569396, 0.433096, 0.562062, 0.570737, 0.611584, 0.613830, 0.534910,
            0.642145, 0.650619, 0.522509, -0.338233, -0.495930, -0.150345, 
            -0.130122, -0.110317, -0.398868, -0.712386, -0.528319, -0.494614, -0.409118
        ],
        'Стрессоустойчивость': [
            0.456470, 0.264605, 0.491853, 0.412497, 0.477012, 0.572066, 0.405464,
            0.505721, 0.542279, 0.384182, -0.225177, -0.454909, -0.158840, 
            -0.055698, -0.118082, -0.272497, -0.559201, -0.351987, -0.366506, -0.319972
        ]
    }
    
    df = pd.DataFrame(data)
    
    # Функция для создания корреляционных плеяд
    def plot_correlation_pleiad(df, threshold=0.3):
        # Создаем граф
        G = nx.Graph()
        
        # Добавляем узлы
        G.add_node("Жизнестойкость", pos=(0, 0))
        G.add_node("Стрессоустойчивость", pos=(10, 0))
        
        # Словари для хранения меток ребер
        edge_labels_zhizn = {}
        edge_labels_stress = {}
        
        # Добавляем узлы копинг-стратегий и связи
        for i, row in df.iterrows():
            strategy = row['Копинг-стратегия']
            G.add_node(strategy, pos=(5, i))
            
            # Добавляем связи, если корреляция выше порога
            if abs(row['Жизнестойкость']) >= threshold:
                G.add_edge("Жизнестойкость", strategy, weight=abs(row['Жизнестойкость']), 
                           style='solid' if row['Жизнестойкость'] > 0 else 'dashed',
                           correlation=row['Жизнестойкость'])
                edge_labels_zhizn[("Жизнестойкость", strategy)] = f"{row['Жизнестойкость']:.2f}"
            
            if abs(row['Стрессоустойчивость']) >= threshold:
                G.add_edge("Стрессоустойчивость", strategy, weight=abs(row['Стрессоустойчивость']), 
                           style='solid' if row['Стрессоустойчивость'] > 0 else 'dashed',
                           correlation=row['Стрессоустойчивость'])
                edge_labels_stress[(strategy, "Стрессоустойчивость")] = f"{row['Стрессоустойчивость']:.2f}"
        
        # Получаем позиции узлов
        pos = nx.get_node_attributes(G, 'pos')
        
        # Создаем рисунок
        plt.figure(figsize=(14, 16))
        
        # Рисуем узлы
        nx.draw_networkx_nodes(G, pos, 
                              node_size=1800, 
                              node_color='white', 
                              edgecolors='black')
        
        # Рисуем ребра с разной толщиной в зависимости от веса
        solid_edges = [(u, v) for u, v, d in G.edges(data=True) if d['style'] == 'solid']
        dashed_edges = [(u, v) for u, v, d in G.edges(data=True) if d['style'] == 'dashed']
        
        # Получаем веса для ребер
        solid_weights = [G[u][v]['weight']*2 for u, v in solid_edges]
        dashed_weights = [G[u][v]['weight']*2 for u, v in dashed_edges]
        
        # Рисуем ребра
        nx.draw_networkx_edges(G, pos, edgelist=solid_edges, width=solid_weights, edge_color='black')
        nx.draw_networkx_edges(G, pos, edgelist=dashed_edges, width=dashed_weights, 
                              edge_color='black', style='dashed')
        
        # Добавляем метки узлов
        nx.draw_networkx_labels(G, pos, font_size=11, font_family='sans-serif')
        
        # Добавляем метки ребер (коэффициенты корреляции)
        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels_zhizn, font_size=9)
        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels_stress, font_size=9)
        
        plt.axis('off')
        plt.title('Корреляционные плеяды копинг-стратегий', fontsize=16)
        
        # Добавляем примечание внизу
        plt.figtext(0.5, 0.01, 
                    "* Сплошные линии - прямые связи (положительная корреляция)\n"
                    "* Пунктирные линии - обратные связи (отрицательная корреляция)", 
                    ha="center", fontsize=12, bbox={"facecolor":"white", "alpha":0.8, "pad":5})
        
        plt.tight_layout(rect=[0, 0.03, 1, 0.97])  # Оставляем место для примечания
        plt.show()
    
    # Строим корреляционные плеяды с порогом 0.3
    plot_correlation_pleiad(df, threshold=0.3)
    

    Хотите, чтобы я объяснил или разбил этот код?

  5. User

    Ок, этот вариант очень неплох. Только фон должен быть белым, а коэффициенты отделяются не точкой, а запятой целые и десятичные части.

  6. Claude Assistant

    Вот обновленный код с белым фоном и коэффициентами, где десятичные части отделены запятой:

    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import networkx as nx
    import matplotlib as mpl
    
    # Настройка для использования запятой вместо точки в числах
    mpl.rcParams['axes.formatter.use_locale'] = True
    import locale
    locale.setlocale(locale.LC_NUMERIC, 'ru_RU.UTF-8')  # Установка русской локали
    
    # Создаем DataFrame из данных
    data = {
        'Копинг-стратегия': [
            'Снижение значения', 'Самоодобрение', 'Самооправдание', 'Отвлечение', 
            'Замещение', 'Самоутверждение', 'Психомышечная релаксация', 
            'Контроль над ситуацией', 'Самоконтроль', 'Позитивная самомотивация', 
            'Поиск социальной поддержки', 'Антиципирующее избегание', 
            'Бегство от стрессовой ситуации', 'Социальная замкнутость', 
            'Заезженная пластинка', 'Беспомощность', 'Жалость к себе', 
            'Самообвинение', 'Агрессия', 'Прием лекарств'
        ],
        'Жизнестойкость': [
            0.569396, 0.433096, 0.562062, 0.570737, 0.611584, 0.613830, 0.534910,
            0.642145, 0.650619, 0.522509, -0.338233, -0.495930, -0.150345, 
            -0.130122, -0.110317, -0.398868, -0.712386, -0.528319, -0.494614, -0.409118
        ],
        'Стрессоустойчивость': [
            0.456470, 0.264605, 0.491853, 0.412497, 0.477012, 0.572066, 0.405464,
            0.505721, 0.542279, 0.384182, -0.225177, -0.454909, -0.158840, 
            -0.055698, -0.118082, -0.272497, -0.559201, -0.351987, -0.366506, -0.319972
        ]
    }
    
    df = pd.DataFrame(data)
    
    # Функция для создания корреляционных плеяд
    def plot_correlation_pleiad(df, threshold=0.3):
        # Создаем граф
        G = nx.Graph()
        
        # Добавляем узлы
        G.add_node("Жизнестойкость", pos=(0, 0))
        G.add_node("Стрессоустойчивость", pos=(10, 0))
        
        # Словари для хранения меток ребер
        edge_labels_zhizn = {}
        edge_labels_stress = {}
        
        # Добавляем узлы копинг-стратегий и связи
        for i, row in df.iterrows():
            strategy = row['Копинг-стратегия']
            G.add_node(strategy, pos=(5, i))
            
            # Добавляем связи, если корреляция выше порога
            if abs(row['Жизнестойкость']) >= threshold:
                G.add_edge("Жизнестойкость", strategy, weight=abs(row['Жизнестойкость']), 
                           style='solid' if row['Жизнестойкость'] > 0 else 'dashed',
                           correlation=row['Жизнестойкость'])
                # Используем запятую вместо точки
                edge_labels_zhizn[("Жизнестойкость", strategy)] = f"{row['Жизнестойкость']:.2f}".replace('.', ',')
            
            if abs(row['Стрессоустойчивость']) >= threshold:
                G.add_edge("Стрессоустойчивость", strategy, weight=abs(row['Стрессоустойчивость']), 
                           style='solid' if row['Стрессоустойчивость'] > 0 else 'dashed',
                           correlation=row['Стрессоустойчивость'])
                # Используем запятую вместо точки
                edge_labels_stress[(strategy, "Стрессоустойчивость")] = f"{row['Стрессоустойчивость']:.2f}".replace('.', ',')
        
        # Получаем позиции узлов
        pos = nx.get_node_attributes(G, 'pos')
        
        # Создаем рисунок с белым фоном
        plt.figure(figsize=(14, 16), facecolor='white')
        ax = plt.gca()
        ax.set_facecolor('white')
        
        # Рисуем узлы
        nx.draw_networkx_nodes(G, pos, 
                              node_size=1800, 
                              node_color='white', 
                              edgecolors='black')
        
        # Рисуем ребра с разной толщиной в зависимости от веса
        solid_edges = [(u, v) for u, v, d in G.edges(data=True) if d['style'] == 'solid']
        dashed_edges = [(u, v) for u, v, d in G.edges(data=True) if d['style'] == 'dashed']
        
        # Получаем веса для ребер
        solid_weights = [G[u][v]['weight']*2 for u, v in solid_edges]
        dashed_weights = [G[u][v]['weight']*2 for u, v in dashed_edges]
        
        # Рисуем ребра
        nx.draw_networkx_edges(G, pos, edgelist=solid_edges, width=solid_weights, edge_color='black')
        nx.draw_networkx_edges(G, pos, edgelist=dashed_edges, width=dashed_weights, 
                              edge_color='black', style='dashed')
        
        # Добавляем метки узлов
        nx.draw_networkx_labels(G, pos, font_size=11, font_family='sans-serif')
        
        # Добавляем метки ребер (коэффициенты корреляции)
        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels_zhizn, font_size=9)
        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels_stress, font_size=9)
        
        plt.axis('off')
        plt.title('Корреляционные плеяды копинг-стратегий', fontsize=16)
        
        # Добавляем примечание внизу
        plt.figtext(0.5, 0.01, 
                    "* Сплошные линии - прямые связи (положительная корреляция)\n"
                    "* Пунктирные линии - обратные связи (отрицательная корреляция)", 
                    ha="center", fontsize=12, bbox={"facecolor":"white", "alpha":1.0, "pad":5})
        
        plt.tight_layout(rect=[0, 0.03, 1, 0.97])  # Оставляем место для примечания
        plt.show()
    
    # Строим корреляционные плеяды с порогом 0.3
    plot_correlation_pleiad(df, threshold=0.3)
    

    Хотите, чтобы я объяснил или разбил этот код?

  7. User

    Копинг-стратегия rS Жизнестойкость (суммарный показатель) Стрессоустойчивость Снижение значения 0,569396** 0,456470** Самоодобрение 0,433096** 0,264605* Самооправдание 0,562062** 0,491853** Отвлечение 0,570737** 0,412497** Замещение 0,611584** 0,477012** Самоутверждение 0,613830** 0,572066** Психомышечная релаксация 0,534910** 0,405464** Контроль над ситуацией 0,642145** 0,505721** Самоконтроль 0,650619** 0,542279** Позитивная самомотивация 0,522509** 0,384182** Поиск социальной поддержки –0,338233** –0,225177 Антиципирующее избегание –0,495930** –0,454909** Бегство от стрессовой ситуации –0,150345 –0,158840 Социальная замкнутость –0,130122 –0,055698 Заезженная пластинка –0,110317 –0,118082* Беспомощность –0,398868** –0,272497* Жалость к себе –0,712386** –0,559201** Самообвинение –0,528319** –0,351987** Агрессия –0,494614** –0,366506** Прием лекарств –0,409118** –0,319972** И не теряй значения. Где-то не прорисованы корреляции к жизнестойкости

  8. Claude Assistant

    Вот обновленный код, который сохраняет все значения корреляций и обеспечивает отображение всех связей с жизнестойкостью:

    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import networkx as nx
    
    # Создаем DataFrame из данных
    data = {
        'Копинг-стратегия': [
            'Снижение значения', 'Самоодобрение', 'Самооправдание', 'Отвлечение', 
            'Замещение', 'Самоутверждение', 'Психомышечная релаксация', 
            'Контроль над ситуацией', 'Самоконтроль', 'Позитивная самомотивация', 
            'Поиск социальной поддержки', 'Антиципирующее избегание', 
            'Бегство от стрессовой ситуации', 'Социальная замкнутость', 
            'Заезженная пластинка', 'Беспомощность', 'Жалость к себе', 
            'Самообвинение', 'Агрессия', 'Прием лекарств'
        ],
        'Жизнестойкость': [
            0.569396, 0.433096, 0.562062, 0.570737, 0.611584, 0.613830, 0.534910,
            0.642145, 0.650619, 0.522509, -0.338233, -0.495930, -0.150345, 
            -0.130122, -0.110317, -0.398868, -0.712386, -0.528319, -0.494614, -0.409118
        ],
        'Стрессоустойчивость': [
            0.456470, 0.264605, 0.491853, 0.412497, 0.477012, 0.572066, 0.405464,
            0.505721, 0.542279, 0.384182, -0.225177, -0.454909, -0.158840, 
            -0.055698, -0.118082, -0.272497, -0.559201, -0.351987, -0.366506, -0.319972
        ],
        'Значимость_Жизнестойкость': [
            '**', '**', '**', '**', '**', '**', '**', '**', '**', '**', 
            '**', '**', '', '', '', '**', '**', '**', '**', '**'
        ],
        'Значимость_Стрессоустойчивость': [
            '**', '*', '**', '**', '**', '**', '**', '**', '**', '**', 
            '', '**', '', '', '*', '*', '**', '**', '**', '**'
        ]
    }
    
    df = pd.DataFrame(data)
    
    # Функция для создания корреляционных плеяд
    def plot_correlation_pleiad(df, threshold=0.0):  # Изменен порог на 0.0, чтобы отображать все связи
        # Создаем граф
        G = nx.Graph()
        
        # Добавляем узлы
        G.add_node("Жизнестойкость", pos=(0, 0))
        G.add_node("Стрессоустойчивость", pos=(10, 0))
        
        # Словари для хранения меток ребер
        edge_labels_zhizn = {}
        edge_labels_stress = {}
        
        # Добавляем узлы копинг-стратегий и связи
        for i, row in df.iterrows():
            strategy = row['Копинг-стратегия']
            G.add_node(strategy, pos=(5, i))
            
            # Добавляем связи для жизнестойкости
            corr_zhizn = row['Жизнестойкость']
            sign_zhizn = row['Значимость_Жизнестойкость']
            G.add_edge("Жизнестойкость", strategy, weight=abs(corr_zhizn), 
                       style='solid' if corr_zhizn > 0 else 'dashed',
                       correlation=corr_zhizn)
            # Формируем метку с запятой и звездочками
            label_zhizn = f"{corr_zhizn:.2f}".replace('.', ',')
            if sign_zhizn:
                label_zhizn += sign_zhizn
            edge_labels_zhizn[("Жизнестойкость", strategy)] = label_zhizn
            
            # Добавляем связи для стрессоустойчивости
            corr_stress = row['Стрессоустойчивость']
            sign_stress = row['Значимость_Стрессоустойчивость']
            G.add_edge("Стрессоустойчивость", strategy, weight=abs(corr_stress), 
                       style='solid' if corr_stress > 0 else 'dashed',
                       correlation=corr_stress)
            # Формируем метку с запятой и звездочками
            label_stress = f"{corr_stress:.2f}".replace('.', ',')
            if sign_stress:
                label_stress += sign_stress
            edge_labels_stress[(strategy, "Стрессоустойчивость")] = label_stress
        
        # Получаем позиции узлов
        pos = nx.get_node_attributes(G, 'pos')
        
        # Создаем рисунок с белым фоном
        plt.figure(figsize=(14, 16), facecolor='white')
        ax = plt.gca()
        ax.set_facecolor('white')
        
        # Рисуем узлы
        nx.draw_networkx_nodes(G, pos, 
                              node_size=1800, 
                              node_color='white', 
                              edgecolors='black')
        
        # Рисуем ребра с разной толщиной в зависимости от веса
        solid_edges = [(u, v) for u, v, d in G.edges(data=True) if d['style'] == 'solid']
        dashed_edges = [(u, v) for u, v, d in G.edges(data=True) if d['style'] == 'dashed']
        
        # Получаем веса для ребер
        solid_weights = [max(G[u][v]['weight']*2, 0.5) for u, v in solid_edges]  # Минимальная толщина 0.5
        dashed_weights = [max(G[u][v]['weight']*2, 0.5) for u, v in dashed_edges]  # Минимальная толщина 0.5
        
        # Рисуем ребра
        nx.draw_networkx_edges(G, pos, edgelist=solid_edges, width=solid_weights, edge_color='black')
        nx.draw_networkx_edges(G, pos, edgelist=dashed_edges, width=dashed_weights, 
                              edge_color='black', style='dashed')
        
        # Добавляем метки узлов
        nx.draw_networkx_labels(G, pos, font_size=11, font_family='sans-serif')
        
        # Добавляем метки ребер (коэффициенты корреляции)
        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels_zhizn, font_size=9)
        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels_stress, font_size=9)
        
        plt.axis('off')
        plt.title('Корреляционные плеяды копинг-стратегий', fontsize=16)
        
        # Добавляем примечание внизу
        plt.figtext(0.5, 0.01, 
                    "* Сплошные линии - прямые связи (положительная корреляция)\n"
                    "* Пунктирные линии - обратные связи (отрицательная корреляция)\n"
                    "* p < 0,05; ** p < 0,01", 
                    ha="center", fontsize=12, bbox={"facecolor":"white", "alpha":1.0, "pad":5})
        
        plt.tight_layout(rect=[0, 0.03, 1, 0.97])  # Оставляем место для примечания
        plt.show()
    
    # Строим корреляционные плеяды, отображая все связи
    plot_correlation_pleiad(df)
    

    Хотите, чтобы я объяснил или разбил этот код?

  9. User

    Выпрями линии корреляции так, чтобы не смазывались коэффициенты корреляции по краям, а также сделай более явным знак минус к отрицательным корреляциям

  10. Claude Assistant

    Вот обновленный код с прямыми линиями корреляции и более явным отображением отрицательных корреляций:

    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import networkx as nx
    import matplotlib.patheffects as pe
    
    # Создаем DataFrame из данных
    data = {
        'Копинг-стратегия': [
            'Снижение значения', 'Самоодобрение', 'Самооправдание', 'Отвлечение', 
            'Замещение', 'Самоутверждение', 'Психомышечная релаксация', 
            'Контроль над ситуацией', 'Самоконтроль', 'Позитивная самомотивация', 
            'Поиск социальной поддержки', 'Антиципирующее избегание', 
            'Бегство от стрессовой ситуации', 'Социальная замкнутость', 
            'Заезженная пластинка', 'Беспомощность', 'Жалость к себе', 
            'Самообвинение', 'Агрессия', 'Прием лекарств'
        ],
        'Жизнестойкость': [
            0.569396, 0.433096, 0.562062, 0.570737, 0.611584, 0.613830, 0.534910,
            0.642145, 0.650619, 0.522509, -0.338233, -0.495930, -0.150345, 
            -0.130122, -0.110317, -0.398868, -0.712386, -0.528319, -0.494614, -0.409118
        ],
        'Стрессоустойчивость': [
            0.456470, 0.264605, 0.491853, 0.412497, 0.477012, 0.572066, 0.405464,
            0.505721, 0.542279, 0.384182, -0.225177, -0.454909, -0.158840, 
            -0.055698, -0.118082, -0.272497, -0.559201, -0.351987, -0.366506, -0.319972
        ],
        'Значимость_Жизнестойкость': [
            '**', '**', '**', '**', '**', '**', '**', '**', '**', '**', 
            '**', '**', '', '', '', '**', '**', '**', '**', '**'
        ],
        'Значимость_Стрессоустойчивость': [
            '**', '*', '**', '**', '**', '**', '**', '**', '**', '**', 
            '', '**', '', '', '*', '*', '**', '**', '**', '**'
        ]
    }
    
    df = pd.DataFrame(data)
    
    # Функция для создания корреляционных плеяд
    def plot_correlation_pleiad(df):
        # Создаем граф
        G = nx.Graph()
        
        # Добавляем узлы
        G.add_node("Жизнестойкость", pos=(-5, 0))
        G.add_node("Стрессоустойчивость", pos=(5, 0))
        
        # Словари для хранения меток ребер
        edge_labels = {}
        
        # Добавляем узлы копинг-стратегий и связи
        for i, row in df.iterrows():
            strategy = row['Копинг-стратегия']
            G.add_node(strategy, pos=(0, -i))
            
            # Добавляем связи для жизнестойкости
            corr_zhizn = row['Жизнестойкость']
            sign_zhizn = row['Значимость_Жизнестойкость']
            G.add_edge("Жизнестойкость", strategy, weight=abs(corr_zhizn), 
                       style='solid' if corr_zhizn > 0 else 'dashed',
                       correlation=corr_zhizn)
            
            # Формируем метку с запятой и звездочками
            if corr_zhizn < 0:
                label_zhizn = f"–{abs(corr_zhizn):.2f}".replace('.', ',')  # Явный минус
            else:
                label_zhizn = f"{corr_zhizn:.2f}".replace('.', ',')
            
            if sign_zhizn:
                label_zhizn += sign_zhizn
            
            # Позиционируем метки ближе к центру линии
            edge_labels[("Жизнестойкость", strategy)] = label_zhizn
            
            # Добавляем связи для стрессоустойчивости
            corr_stress = row['Стрессоустойчивость']
            sign_stress = row['Значимость_Стрессоустойчивость']
            G.add_edge("Стрессоустойчивость", strategy, weight=abs(corr_stress), 
                       style='solid' if corr_stress > 0 else 'dashed',
                       correlation=corr_stress)
            
            # Формируем метку с запятой и звездочками
            if corr_stress < 0:
                label_stress = f"–{abs(corr_stress):.2f}".replace('.', ',')  # Явный минус
            else:
                label_stress = f"{corr_stress:.2f}".replace('.', ',')
            
            if sign_stress:
                label_stress += sign_stress
            
            edge_labels[(strategy, "Стрессоустойчивость")] = label_stress
        
        # Получаем позиции узлов
        pos = nx.get_node_attributes(G, 'pos')
        
        # Создаем рисунок с белым фоном
        plt.figure(figsize=(14, 16), facecolor='white')
        ax = plt.gca()
        ax.set_facecolor('white')
        
        # Рисуем узлы
        nx.draw_networkx_nodes(G, pos, 
                              node_size=1800, 
                              node_color='white', 
                              edgecolors='black')
        
        # Рисуем ребра с разной толщиной в зависимости от веса
        solid_edges = [(u, v) for u, v, d in G.edges(data=True) if d['style'] == 'solid']
        dashed_edges = [(u, v) for u, v, d in G.edges(data=True) if d['style'] == 'dashed']
        
        # Получаем веса для ребер
        solid_weights = [max(G[u][v]['weight']*2, 0.5) for u, v in solid_edges]  # Минимальная толщина 0.5
        dashed_weights = [max(G[u][v]['weight']*2, 0.5) for u, v in dashed_edges]  # Минимальная толщина 0.5
        
        # Рисуем ребра
        nx.draw_networkx_edges(G, pos, edgelist=solid_edges, width=solid_weights, edge_color='black')
        nx.draw_networkx_edges(G, pos, edgelist=dashed_edges, width=dashed_weights, 
                              edge_color='black', style='dashed')
        
        # Добавляем метки узлов
        nx.draw_networkx_labels(G, pos, font_size=11, font_family='sans-serif')
        
        # Добавляем метки ребер (коэффициенты корреляции) с белым фоном для лучшей читаемости
        for (u, v, d), label in zip(G.edges(data=True), edge_labels.items()):
            edge_x = (pos[u][0] + pos[v][0]) / 2.0
            edge_y = (pos[u][1] + pos[v][1]) / 2.0
            
            # Создаем белый фон для текста
            plt.text(edge_x, edge_y, edge_labels[label], 
                     fontsize=9, 
                     horizontalalignment='center',
                     verticalalignment='center',
                     bbox=dict(facecolor='white', alpha=1.0, edgecolor='none', pad=1),
                     zorder=3)  # zorder выше, чтобы текст был поверх линий
        
        plt.axis('off')
        plt.title('Корреляционные плеяды копинг-стратегий', fontsize=16)
        
        # Добавляем примечание внизу
        plt.figtext(0.5, 0.01, 
                    "* Сплошные линии - прямые связи (положительная корреляция)\n"
                    "* Пунктирные линии - обратные связи (отрицательная корреляция)\n"
                    "* p < 0,05; ** p < 0,01", 
                    ha="center", fontsize=12, bbox={"facecolor":"white", "alpha":1.0, "pad":5})
        
        plt.tight_layout(rect=[0, 0.03, 1, 0.97])  # Оставляем место для примечания
        plt.show()
    
    # Строим корреляционные плеяды
    plot_correlation_pleiad(df)
    

    Хотите, чтобы я объяснил или разбил этот код?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.