i want you to review this code below and fix the issues 
import pandas as pd
import networkx as nx
import matplotlib.pyplot as plt
import community

# Read the data from CSV file
data = pd.read_csv("cleaned_data.csv")

# Select the first 15 users as main users
main_users = data["User"][:15]

# Create an undirected graph
G = nx.Graph()

# Add main users as nodes to the graph
for user in main_users:
    G.add_node(user, main_user=True)

# Add followers and following relationships as edges to the graph
for i in range(len(data)):
    user = data.iloc[i]["User"]
    followers = data.iloc[i]["Followers"].split(",")
    following = data.iloc[i]["Following"].split(",")

    if followers[0] != 'nan' and followers[0] != '':
        for follower in followers:
            G.add_edge(follower, user, relationship='follower')  # Add follower relationship edge
            if not G.has_node(follower):
                G.add_node(follower, main_user=False)
    else:
        G.add_node(f"user_{i}", main_user=False)

    if following[0] != 'nan' and following[0] != '':
        for follow in following:
            G.add_edge(user, follow, relationship='following')  # Add following relationship edge
            if not G.has_node(follow):
                G.add_node(follow, main_user=False)
    else:
        G.add_node(f"user_{i+len(data)}", main_user=False)

# Remove the 'nan' node if it exists
if 'nan' in G:
    G.remove_node('nan')

# Convert the directed graph to an undirected graph
G_undirected = G.to_undirected()

# Perform community detection using Louvain algorithm on the undirected graph
partition = community.best_partition(G_undirected)

# Rest of the code remains the same...


# Convert the partition into a dictionary format
partition_dict = {}
for node, community_id in partition.items():
    partition_dict[node] = community_id

# Visualize subgraphs by community
graphs_data = []
for community_num in set(partition.values()):
    subgraph_nodes = [node for node in G.nodes if partition[node] == community_num]
    subgraph = G.subgraph(subgraph_nodes)
    graphs_data.append(subgraph)

plt.figure(figsize=(30, 20))
pos = nx.circular_layout(G)
node_colors = ['red' if 'main_user' in G.nodes[node] and G.nodes[node]['main_user'] else 'skyblue' for node in G.nodes]
edge_colors = ['red' if G.edges[edge]['relationship'] == 'follower' else 'gray' for edge in G.edges]
for subgraph in graphs_data:
    nx.draw_networkx(subgraph, pos, with_labels=True, node_color=node_colors, edge_color=edge_colors, node_size=24000, font_size=12)

# Add text with graph information
plt.text(1.1, 0.9, f"Nodes: {G.number_of_nodes()}", transform=plt.gca().transAxes, fontsize=14)
plt.text(1.1, 0.85, f"Edges: {G.number_of_edges()}", transform=plt.gca().transAxes, fontsize=14)
plt.text(1.1, 0.8, f"Connected Users: {len(main_users)}", transform=plt.gca().transAxes, fontsize=14)
plt.text(1.1, 0.75, f"Main User: {', '.join(main_users)}", transform=plt.gca().transAxes, fontsize=14)

plt.tight_layout()
plt.savefig("graph.png")
plt.close()



eigenvector_centrality = nx.eigenvector_centrality(G, max_iter=1000)


# Remove the temporary nodes and edges
from networkx.algorithms.community import greedy_modularity_communities

# Perform community detection using greedy modularity
communities = greedy_modularity_communities(G)

# Convert the communities to a partition dictionary
partition = {}
for i, comm in enumerate(communities):
    for node in comm:
        partition[node] = i

# Remove the 'nan' node from the partition dictionary
partition.pop('nan', None)

# Visualize subgraphs by community
graphs_data = []
for community_num in set(partition_dict.values()):
    subgraph_nodes = [node for node in G.nodes if partition_dict[node] == community_num]
    subgraph = G.subgraph(subgraph_nodes)

    plt.figure(figsize=(25, 15))
    pos = nx.kamada_kawai_layout(subgraph)
    node_colors = ['red' if 'main_user' in subgraph.nodes[node] and subgraph.nodes[node]['main_user'] else 'skyblue' for node in subgraph.nodes]
    nx.draw_networkx(subgraph, pos, with_labels=True, node_color=node_colors, edge_color='gray', node_size=19000, font_size=11)

    # Add text with subgraph information
    plt.text(0.95, 0.95, f"Community: {community_num}", transform=plt.gca().transAxes, fontsize=14, ha='right', va='top')
    plt.text(0.95, 0.9, f"Nodes: {subgraph.number_of_nodes()}", transform=plt.gca().transAxes, fontsize=14, ha='right', va='top')
    plt.text(0.95, 0.85, f"Edges: {subgraph.number_of_edges()}", transform=plt.gca().transAxes, fontsize=14, ha='right', va='top')
    plt.text(0.95, 0.8, f"Connected Users: {len(main_users)}", transform=plt.gca().transAxes, fontsize=14, ha='right', va='top')
    plt.text(0.95, 0.75, f"Main User: {', '.join(main_users)}", transform=plt.gca().transAxes, fontsize=14, ha='right', va='top')

    plt.tight_layout()
    plt.savefig(f"graph_community_{community_num}.png")
    plt.close()

    graph_data = {
        'Community': community_num,
        'Nodes': subgraph.number_of_nodes(),
        'Edges': subgraph.number_of_edges(),
        'Density': nx.density(subgraph),
    }
    graphs_data.append(graph_data)


# Calculate graph metrics
density = nx.density(G)
number_of_edges = G.number_of_edges()
unique_edges = G.size(weight="weight")
eigenvector_centrality_top_10 = sorted([(node, eigenvector_centrality[node]) for node in main_users if node in eigenvector_centrality.keys()], key=lambda x: x[1], reverse=True)[:10]

# Print graph metrics
print("Graph Density:", density)
print("Number of Edges:", number_of_edges)
print("Unique Edges:", unique_edges)
print("Eigenvector Centrality (Top 10 nodes):", eigenvector_centrality_top_10)

# Save graphs and metrics data to CSV files
graphs_df = pd.DataFrame(graphs_data)
graphs_df.to_csv('graphs_data.csv', index=False)

metrics_data = {
    'Graph Density': density,
    'Number of Edges': number_of_edges,
    'Unique Edges': unique_edges,
    'Eigenvector Centrality (Top 10 nodes)': eigenvector_centrality_top_10,
}

metrics_df = pd.DataFrame([metrics_data])
metrics_df.to_csv('metrics_data.csv', index=False)