RELATÓRIO FINAL — PageRank Aplicado à Rede de Filmes

import pandas as pd
import json
import networkx as nx
import numpy as np
import matplotlib.pyplot as plt
from itertools import combinations

# Carregamento dos dados
movies = pd.read_csv("movies_metadata.csv", low_memory=False)
credits = pd.read_csv("credits.csv")

# Seleção dos 300 filmes mais relevantes (por número de votos)
movies = movies.sort_values("vote_count", ascending=False).head(300)

print(f"Total de filmes: {len(movies)}")
print(f"Período: {movies['release_date'].min()} a {movies['release_date'].max()}")

def safe_load_list(x):
    try:
        return json.loads(x.replace("'", '"'))
    except:
        return []

def get_director(crew):
    crew_list = safe_load_list(crew)
    for c in crew_list:
        if c.get("job") == "Director":
            return c.get("name")
    return None

def get_main_cast(cast):
    cast_list = safe_load_list(cast)
    return [c["name"] for c in cast_list[:3]]

# Mapear dados
merged = pd.merge(credits, movies[['id', 'title']], left_on='movie_id', right_on='id')

movie_cast = {}
movie_director = {}

for idx, row in merged.iterrows():
    movie_cast[row['movie_id']] = get_main_cast(row['cast'])
    movie_director[row['movie_id']] = get_director(row['crew'])

# Remover entradas inválidas
invalid_count = 0
for movie_id in list(movie_cast.keys()):
    if not movie_cast[movie_id] and movie_director[movie_id] is None:
        del movie_cast[movie_id]
        del movie_director[movie_id]
        invalid_count += 1

print(f"Filmes válidos: {len(movie_cast)}")
print(f"Atores únicos: {len(set([a for cast in movie_cast.values() for a in cast]))}")
print(f"Diretores únicos: {len(set(d for d in movie_director.values() if d))}")

# Criar grafo não direcionado
G_undirected = nx.Graph()
G_undirected.add_nodes_from(movie_cast.keys())

# Adicionar arestas (filmes conectados por atores ou diretor)
edges_added = 0
for i, j in combinations(movie_cast.keys(), 2):
    # Compartilham ator?
    if set(movie_cast[i]).intersection(movie_cast[j]):
        G_undirected.add_edge(i, j)
        edges_added += 1
    # Compartilham diretor?
    elif movie_director[i] == movie_director[j] and movie_director[i] is not None:
        G_undirected.add_edge(i, j)
        edges_added += 1

# Componente principal
largest_cc = max(nx.connected_components(G_undirected), key=len)
G_main = G_undirected.subgraph(largest_cc).copy()

# Converter para direcionado e garantir bidirecionalidade
G = G_main.to_directed()
for i, j in list(G.edges()):
    if not G.has_edge(j, i):
        G.add_edge(j, i)

print(f"Nós: {G.number_of_nodes()}")
print(f"Arestas: {G.number_of_edges()}")
print(f"Densidade: {nx.density(G):.4f}")

def build_transition_matrix(G):
    """Constrói matriz de transição M"""
    nodes = list(G.nodes())
    M = nx.to_numpy_array(G, nodelist=nodes, dtype=np.float64)

    # Normalizar colunas
    col_sums = M.sum(axis=0)
    col_sums[col_sums == 0] = 1
    M = M / col_sums

    return M, nodes

M, nodes = build_transition_matrix(G)
N = len(nodes)
print(f"Matriz de transição: {M.shape}")

def pagerank_power_iteration(M, d=0.85, tol=1e-9, max_iter=1000):
    """
    Calcula PageRank: p = d * M * p + (1-d)/N * e
    """
    N = M.shape[0]
    p = np.ones(N) / N

    for iteration in range(max_iter):
        p_new = d * M.dot(p) + (1 - d) / N
        error = np.abs(p_new - p).sum()

        if error < tol:
            print(f"Convergência: {iteration + 1} iterações (d={d})")
            return p_new

        p = p_new

    return p

# Testar diferentes damping factors
results = {}
for d in [0.50, 0.85, 0.99]:
    results[d] = pagerank_power_iteration(M, d=d)
    print(f"d={d}: min={results[d].min():.6f}, max={results[d].max():.6f}")

# Comparar com implementação oficial
nx_pagerank = nx.pagerank(G, alpha=0.85)
nx_vals = np.array([nx_pagerank[node] for node in nodes])
our_vals = results[0.85]

diff_max = np.abs(nx_vals - our_vals).max()
print(f"Diferença máxima vs NetworkX: {diff_max:.2e}")
print(f"✓ Validação OK!" if diff_max < 1e-5 else "⚠ Há discrepâncias")

d_final = 0.85
pagerank_final = results[d_final]

# Criar ranking
pagerank_dict = {}
for i, node in enumerate(nodes):
    title = movies.loc[node, 'title'] if node in movies.index else f"Filme {node}"
    pagerank_dict[title] = pagerank_final[i]

pagerank_sorted = sorted(pagerank_dict.items(), key=lambda x: x[1], reverse=True)

print("\nTOP 10 FILMES POR PAGERANK:\n")
for i, (title, score) in enumerate(pagerank_sorted[:10], 1):
    print(f"{i:2d}. {title:<40s} {score:.6f}")

fig, axes = plt.subplots(1, 3, figsize=(16, 5))

for idx, d in enumerate([0.50, 0.85, 0.99]):
    axes[idx].hist(results[d], bins=40, edgecolor='black', alpha=0.7, color='#4ECDC4')
    axes[idx].set_xlabel('PageRank', fontweight='bold')
    axes[idx].set_ylabel('Frequência', fontweight='bold')
    axes[idx].set_title(f'd = {d}', fontweight='bold', fontsize=12)
    axes[idx].grid(axis='y', alpha=0.3)

plt.suptitle('Distribuição do PageRank para Diferentes Damping Factors', fontsize=14, fontweight='bold')
plt.tight_layout()
plt.savefig("./img/pagerank_distribution_by_d.png", dpi=300, bbox_inches='tight')
plt.show()

top_10_titles = [title for title, _ in pagerank_sorted[:10]]
top_10_scores = [score for _, score in pagerank_sorted[:10]]

fig, ax = plt.subplots(figsize=(12, 7))

colors = plt.cm.viridis(np.linspace(0.3, 0.9, len(top_10_titles)))
ax.barh(range(len(top_10_titles)), top_10_scores, color=colors, edgecolor='black', linewidth=1.5)

ax.set_yticks(range(len(top_10_titles)))
ax.set_yticklabels(top_10_titles[::-1], fontsize=11)
ax.set_xlabel('PageRank Score (d=0.85)', fontweight='bold', fontsize=12)
ax.set_title('Top 10 Filmes Mais Conectados da Rede', fontweight='bold', fontsize=13)
ax.grid(axis='x', alpha=0.3)

# Adicionar valores nas barras
for i, (title, score) in enumerate(zip(top_10_titles[::-1], top_10_scores[::-1])):
    ax.text(score + 0.0002, i, f'{score:.6f}', va='center', fontweight='bold')

plt.tight_layout()
plt.savefig("./img/top10_pagerank_d0_85.png", dpi=300, bbox_inches='tight')
plt.show()

# Layout Spring
pos = nx.spring_layout(G, k=0.5, iterations=50, seed=42)

# Cores e tamanhos baseados em PageRank
pagerank_array = np.array([pagerank_final[i] for i in range(len(nodes))])
node_sizes = 300 + (pagerank_array / pagerank_array.max()) * 2000
node_colors = pagerank_array

# Desenhar
fig, ax = plt.subplots(figsize=(16, 12))

nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color=node_colors,
                       cmap='viridis', alpha=0.8, ax=ax)
nx.draw_networkx_edges(G, pos, alpha=0.1, width=0.5, ax=ax)

# Labels apenas para top 20
top_20_nodes = [nodes[i] for i in np.argsort(pagerank_array)[-20:]]
top_20_pos = {node: pos[node] for node in top_20_nodes}
labels = {node: movies.loc[node, 'title'][:12] for node in top_20_nodes}
nx.draw_networkx_labels(G, top_20_pos, labels=labels, font_size=8, font_weight='bold', ax=ax)

ax.set_title('Rede de Filmes - PageRank Visualization (d=0.85)', fontweight='bold', fontsize=14)
ax.axis('off')

# Colorbar
sm = plt.cm.ScalarMappable(cmap='viridis', norm=plt.Normalize(vmin=pagerank_array.min(), vmax=pagerank_array.max()))
sm.set_array([])
cbar = plt.colorbar(sm, ax=ax, fraction=0.046, pad=0.04)
cbar.set_label('PageRank Score', fontweight='bold')

plt.tight_layout()
plt.savefig("./img/graph_pagerank_d0.85.png", dpi=300, bbox_inches='tight')
plt.show()

# Top atores e diretores nos 50 filmes mais importantes
pagerank_array = np.array([pagerank_final[i] for i in range(len(nodes))])
top_50_indices = [nodes[i] for i in np.argsort(pagerank_array)[-50:]]

actor_count = {}
director_count = {}

for movie_id in top_50_indices:
    for actor in movie_cast[movie_id]:
        actor_count[actor] = actor_count.get(actor, 0) + 1

    director = movie_director[movie_id]
    if director:
        director_count[director] = director_count.get(director, 0) + 1

print("TOP 5 ATORES:\n")
for actor, count in sorted(actor_count.items(), key=lambda x: x[1], reverse=True)[:5]:
    print(f"  {actor:<30s} → {count} filmes")

print("\nTOP 5 DIRETORES:\n")
for director, count in sorted(director_count.items(), key=lambda x: x[1], reverse=True)[:5]:
    print(f"  {director:<30s} → {count} filmes")