Week Six: Bipartite Networks

Author

Tony Fraser and Mark Gonsalves

Published

March 8, 2025

github

The Two Women’s Communities

Show Code For Women’s Communities Visualization Code 
import networkx as nx
import matplotlib.pyplot as plt
from networkx.algorithms import community
import matplotlib.colors as mcolors
import base64
from io import BytesIO
from IPython.display import HTML

# Create the graph
G = nx.davis_southern_women_graph()

# Get women nodes
women = [n for n, d in G.nodes(data=True) if d['bipartite'] == 0]

# Project the bipartite graph onto women only
W = nx.bipartite.weighted_projected_graph(G, women)

# Find communities using the Girvan-Newman algorithm
communities = list(community.greedy_modularity_communities(W))

# Set up colors for different communities
colors = list(mcolors.TABLEAU_COLORS)

# Create a color map for nodes
color_map = []
for woman in W.nodes():
    for i, comm in enumerate(communities):
        if woman in comm:
            color_map.append(colors[i])
            break

# Create the visualization
plt.figure(figsize=(12, 8))
pos = nx.spring_layout(W, seed=42)  # Consistent layout
nx.draw_networkx_nodes(W, pos, node_size=700, node_color=color_map)
nx.draw_networkx_labels(W, pos, font_size=10, font_weight='bold')

# Draw edges with weights reflected in width
edge_weights = [W[u][v]['weight']/3 for u, v in W.edges()]
nx.draw_networkx_edges(W, pos, width=edge_weights, alpha=0.7)

plt.title("Southern Women Communities", fontsize=16)
plt.axis('off')
plt.tight_layout()

# Save the plot to a BytesIO object and encode it to base64
buf = BytesIO()
plt.savefig(buf, format='png', bbox_inches='tight', dpi=300)
plt.close()
img_base64 = base64.b64encode(buf.getvalue()).decode('utf-8')
img_html = f'<img src="data:image/png;base64,{img_base64}" alt="Southern Women Communities" />'

# Display the image
display(HTML(img_html))

# Print the communities
for i, comm in enumerate(communities):
    print(f"Community {i+1}:", sorted(list(comm)))
Southern Women Communities 
Community 1: ['Dorothy Murchison', 'Evelyn Jefferson', 'Flora Price', 'Helen Lloyd', 'Katherina Rogers', 'Myra Liddel', 'Nora Fayette', 'Olivia Carleton', 'Pearl Oglethorpe', 'Ruth DeSand', 'Sylvia Avondale', 'Theresa Anderson']
Community 2: ['Brenda Rogers', 'Charlotte McDowd', 'Eleanor Nye', 'Frances Anderson', 'Laura Mandeville', 'Verne Sanderson']

This visualization reveals the naturally occurring social communities among the Southern women based solely on their event attendance patterns. The network analysis automatically detects two distinct social groups (shown in different colors), without any prior knowledge of their relationships.

Key observations:

  • Two clear social circles: The women naturally divide into two distinct communities that align with what sociologists would later confirm through interviews.
  • Edge thickness: Thicker connections indicate women who attended more events together, revealing stronger social bonds.
  • Influential figures: Note central women like Evelyn Jefferson and Theresa Anderson who have multiple strong connections, indicating their social importance.
  • Bridge figures: Some women connect across the two communities, serving as bridges between the social circles.

This demonstrates how analyzing patterns of event attendance can reveal underlying social structures that might not be immediately obvious from raw data.

Event Attendance Heatmap

Show Code For Event Attendance Heatmap 
import networkx as nx
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
from networkx.algorithms import community
import base64
from io import BytesIO
from IPython.display import HTML

# Create the graph
G = nx.davis_southern_women_graph()

# Get women and events
women = sorted([n for n, d in G.nodes(data=True) if d['bipartite'] == 0])
events = [n for n, d in G.nodes(data=True) if d['bipartite'] == 1]
events = sorted(events, key=lambda x: int(x[1:]))  

# # Better approach to ensure correct numerical ordering:
# events = [n for n, d in G.nodes(data=True) if d['bipartite'] == 1]
# events = sorted(events, key=lambda x: int(x))  # Sort numerically instead of lexicographically


# Project the graph to find communities
W = nx.bipartite.weighted_projected_graph(G, women)
communities = list(community.greedy_modularity_communities(W))

# Sort women by community
community_map = {}
for i, comm in enumerate(communities):
    for woman in comm:
        community_map[woman] = i

# Sort women by their community
sorted_women = sorted(women, key=lambda w: (community_map[w], w))

# Create attendance matrix
attendance = np.zeros((len(sorted_women), len(events)))
for i, woman in enumerate(sorted_women):
    for event in G.neighbors(woman):
        j = events.index(event)
        attendance[i, j] = 1

# Create DataFrame for the heatmap
df = pd.DataFrame(attendance, 
                  index=sorted_women,
                  columns=[f"E{e}" for e in events])

# Create the heatmap
plt.figure(figsize=(12, 10))
sns.heatmap(df, cmap="Blues", cbar_kws={'label': 'Attended'}, 
            linewidths=0.5, linecolor='lightgray')

# Add horizontal lines between communities
current_comm = community_map[sorted_women[0]]
for i in range(1, len(sorted_women)):
    if community_map[sorted_women[i]] != current_comm:
        plt.axhline(y=i, color='red', linestyle='-', linewidth=2)
        current_comm = community_map[sorted_women[i]]

plt.title("Women's Event Attendance by Community", fontsize=16)
plt.xlabel("Events", fontsize=12)
plt.ylabel("Women", fontsize=12)
plt.tight_layout()

# Save the plot to a BytesIO object and encode it to base64
buf = BytesIO()
plt.savefig(buf, format='png', bbox_inches='tight', dpi=300)
plt.close()
img_base64 = base64.b64encode(buf.getvalue()).decode('utf-8')
img_html = f'<img src="data:image/png;base64,{img_base64}" alt="Women Event Attendance Heatmap" />'

# Display the image
display(HTML(img_html))
Women Event Attendance Heatmap

This heatmap visualizes which women attended which events, with women grouped by their community membership (separated by the red horizontal line). Blue cells indicate attendance at an event.

Key patterns to observe:

  • Community-specific events: Notice how the early events (E1-E7) were primarily attended by one community, while later events (E8-E14) show more attendance from the other community.
  • Transitional events: Events around E8-E9 show attendance from both communities, suggesting these were bridge events.
  • Attendance clusters: Within each community, you can identify subclusters of women who consistently attended the same events together.
  • Event popularity: Some events (darker vertical columns) were more popular and attracted more attendees than others.

This visualization effectively shows how the community structure emerges naturally from different event attendance patterns and preferences.

Top Metrics Summary Table

Show Code for Top Metrics Summary Table 
import networkx as nx
import pandas as pd
from networkx.algorithms import community
from networkx.algorithms import centrality
import matplotlib.pyplot as plt
import seaborn as sns
import base64
from io import BytesIO
from IPython.display import HTML

# Create the graph
G = nx.davis_southern_women_graph()

# Get women and events
women = [n for n, d in G.nodes(data=True) if d['bipartite'] == 0]
events = [n for n, d in G.nodes(data=True) if d['bipartite'] == 1]

# Project the graph to find communities
W = nx.bipartite.weighted_projected_graph(G, women)
E = nx.bipartite.weighted_projected_graph(G, events)

# Calculate key metrics
degree_cent = nx.degree_centrality(W)
betweenness_cent = nx.betweenness_centrality(W)
eigenvector_cent = nx.eigenvector_centrality(W)

# Get top women by centrality measures
top_degree = sorted(degree_cent.items(), key=lambda x: x[1], reverse=True)[:5]
top_betweenness = sorted(betweenness_cent.items(), key=lambda x: x[1], reverse=True)[:5]
top_eigenvector = sorted(eigenvector_cent.items(), key=lambda x: x[1], reverse=True)[:5]

# Get event popularity
event_popularity = {}
for event in events:
    event_popularity[event] = len(list(G.neighbors(event)))
top_events = sorted(event_popularity.items(), key=lambda x: x[1], reverse=True)[:5]

# Find communities
communities = list(community.greedy_modularity_communities(W))

# Create DataFrames for visualization instead of just printing
# Top Central Women
central_women_df = pd.DataFrame(top_degree, columns=['Woman', 'Centrality'])
central_women_df['Centrality'] = central_women_df['Centrality'].round(3)

# Top Bridge Women
bridge_women_df = pd.DataFrame(top_betweenness, columns=['Woman', 'Betweenness'])
bridge_women_df['Betweenness'] = bridge_women_df['Betweenness'].round(3)

# Top Events
top_events_df = pd.DataFrame(top_events, columns=['Event', 'Attendance'])

# Create visual tables
fig, axes = plt.subplots(3, 1, figsize=(10, 12))

# Central Women Table
axes[0].axis('tight')
axes[0].axis('off')
table1 = axes[0].table(cellText=central_women_df.values,
                      colLabels=central_women_df.columns,
                      loc='center',
                      cellLoc='center')
table1.auto_set_font_size(False)
table1.set_fontsize(12)
table1.scale(1.2, 1.5)
axes[0].set_title("Top 5 Most Central Women (Degree Centrality)", fontsize=14, pad=20)

# Bridge Women Table
axes[1].axis('tight')
axes[1].axis('off')
table2 = axes[1].table(cellText=bridge_women_df.values,
                      colLabels=bridge_women_df.columns,
                      loc='center',
                      cellLoc='center')
table2.auto_set_font_size(False)
table2.set_fontsize(12)
table2.scale(1.2, 1.5)
axes[1].set_title("Top 5 Bridge Women (Betweenness Centrality)", fontsize=14, pad=20)

# Top Events Table
axes[2].axis('tight')
axes[2].axis('off')
table3 = axes[2].table(cellText=top_events_df.values,
                      colLabels=top_events_df.columns,
                      loc='center',
                      cellLoc='center')
table3.auto_set_font_size(False)
table3.set_fontsize(12)
table3.scale(1.2, 1.5)
axes[2].set_title("Top 5 Most Popular Events (Attendance)", fontsize=14, pad=20)

plt.tight_layout()

# Save the plot to a BytesIO object and encode it to base64
buf = BytesIO()
plt.savefig(buf, format='png', bbox_inches='tight', dpi=300)
plt.close()
img_base64 = base64.b64encode(buf.getvalue()).decode('utf-8')
img_html = f'<img src="data:image/png;base64,{img_base64}" alt="Network Metrics Tables" />'

# Display the image
display(HTML(img_html))

# Also print the community information as text
print("Community Breakdown:")
for i, comm in enumerate(communities):
    print(f"Community {i+1} ({len(comm)} women): {', '.join(sorted(list(comm)[:3]))}" + 
          (f", +{len(comm)-3} more" if len(comm) > 3 else ""))
Network Metrics Tables 
Community Breakdown:
Community 1 (12 women): Evelyn Jefferson, Flora Price, Sylvia Avondale, +9 more
Community 2 (6 women): Charlotte McDowd, Eleanor Nye, Verne Sanderson, +3 more

This analysis provides a concise summary of the key metrics from the Southern Women dataset, focusing on the most influential individuals and popular events.

Key insights to note:

  • Most central women: The women with highest degree centrality (Evelyn Jefferson, Theresa Anderson, etc.) are the social hubs of the network, connected to many other women through shared event attendance.
  • Bridge figures: Women with high betweenness centrality play crucial roles in connecting different parts of the social network. These women (often Evelyn Jefferson and Nora Fayette) attended events spanning both communities.
  • Event popularity: Events E8 and E9 were the most attended, bringing together women from across different social circles.
  • Community structure: The two detected communities are roughly equal in size, with specific key members in each group.

The metrics quantify what we observe visually in the network diagrams, providing statistical evidence for the social structures and highlighting the most influential individuals in this historical social network.