Análise de
Correlação

import numpy as np
from scipy import stats

# Dataset exemplo
x = np.array([2.1, 3.4, 4.7, 5.2, 6.8, 7.1, 8.3, 9.0])
y = np.array([1.8, 3.0, 5.2, 4.9, 7.4, 6.8, 9.1, 8.7])

# ── Cálculo manual ──────────────────────────────
n = len(x)
x_mean, y_mean = x.mean(), y.mean()

cov_xy = np.sum((x - x_mean) * (y - y_mean)) / (n - 1)
std_x  = np.sqrt(np.sum((x - x_mean)**2) / (n - 1))
std_y  = np.sqrt(np.sum((y - y_mean)**2) / (n - 1))

r_manual = cov_xy / (std_x * std_y)

# ── Teste-t para significância ──────────────────
t_stat  = r_manual * np.sqrt(n - 2) / np.sqrt(1 - r_manual**2)
p_value = 2 * stats.t.sf(np.abs(t_stat), df=n-2)  # bilateral

# ── Via scipy (validação) ───────────────────────
r_scipy, p_scipy = stats.pearsonr(x, y)

print(f"r manual  : {r_manual:.4f}")
print(f"r scipy   : {r_scipy:.4f}")
print(f"t-statistic: {t_stat:.4f}")
print(f"p-value   : {p_value:.4f}")
print(f"R² = {r_scipy**2:.4f}  →  explica {r_scipy**2*100:.1f}% da variância")

import pandas as pd
import numpy as np
from scipy import stats

def partial_corr(data: pd.DataFrame, x: str, y: str, z: list) -> dict:
    """
    Calcula correlação parcial de x e y controlando por z.
    Usa resíduos da regressão OLS para remover efeito de z.
    """
    from sklearn.linear_model import LinearRegression

    lr = LinearRegression()

    # Resíduos de X ~ Z
    lr.fit(data[z], data[x])
    res_x = data[x] - lr.predict(data[z])

    # Resíduos de Y ~ Z
    lr.fit(data[z], data[y])
    res_y = data[y] - lr.predict(data[z])

    # Correlação dos resíduos = correlação parcial
    r, p = stats.pearsonr(res_x, res_y)
    return {"r_partial": round(r, 4), "p_value": round(p, 4)}

# Exemplo: Temperatura afeta tanto consumo de sorvete quanto afogamentos?
# Sem controle: alta corr. sorvete ↔ afogamentos (confundidor: temperatura!)
df = pd.DataFrame({
    "sorvete":    [120, 200, 350, 450, 600, 700, 650, 500, 300, 150],
    "afogamentos":[  2,   3,   5,   8,  12,  15,  13,   9,   4,   2],
    "temperatura": [ 15,  18,  22,  26,  31,  35,  33,  28,  21,  16],
})

r_bruta, p_bruta = stats.pearsonr(df["sorvete"], df["afogamentos"])
r_parcial = partial_corr(df, "sorvete", "afogamentos", ["temperatura"])

print(f"Correlação bruta  sorvete↔afogamentos: r={r_bruta:.3f}")     # ~0.99 (!)
print(f"Corr. parcial (| temperatura):          r={r_parcial['r_partial']:.3f}")  # ~0.05
# → Relação espúria! Era toda explicada pela temperatura.

import numpy as np
import pandas as pd
from scipy import stats
from scipy.stats import pointbiserialr, kendalltau, spearmanr, pearsonr

# ─────────────────────────────────────────────────────────
#  1. PEARSON — relação linear, dados contínuos normais
# ─────────────────────────────────────────────────────────
r_pearson, p_pearson = pearsonr(x, y)

#  2. SPEARMAN — monotônico, robusto a outliers
r_spearman, p_spearman = spearmanr(x, y)

#  3. KENDALL — amostras pequenas, muitos empates
r_kendall, p_kendall = kendalltau(x, y)

#  4. POINT-BISERIAL — variável binária vs contínua
binary = np.array([0,1,0,1,1,0,1,0])
r_pb, p_pb = pointbiserialr(binary, y)

#  5. CRAMÉR'S V — variáveis categóricas
def cramers_v(x_cat, y_cat):
    confusion = pd.crosstab(x_cat, y_cat)
    chi2 = stats.chi2_contingency(confusion)[0]
    n = confusion.sum().sum()
    phi2 = chi2 / n
    r_dim, k_dim = confusion.shape
    return np.sqrt(phi2 / min(k_dim - 1, r_dim - 1))

#  6. DISTANCE CORRELATION — detecta qualquer dependência
def distance_corr(X, Y):
    """Distance Correlation de Székely et al. (2007)"""
    n = len(X)
    a = np.abs(X[:, None] - X[None, :])
    b = np.abs(Y[:, None] - Y[None, :])
    # Doubly center the distance matrices
    A = a - a.mean(axis=0) - a.mean(axis=1)[:, None] + a.mean()
    B = b - b.mean(axis=0) - b.mean(axis=1)[:, None] + b.mean()
    dcov2_xy = (A * B).mean()
    dcov2_xx = (A * A).mean()
    dcov2_yy = (B * B).mean()
    dcor = np.sqrt(np.maximum(dcov2_xy, 0) / np.sqrt(dcov2_xx * dcov2_yy))
    return dcor

import pingouin as pg
import pandas as pd

# pingouin retorna um DataFrame rico com r, CI, p, potência, n
result = pg.corr(x=df['peso_kg'], y=df['gmdd'], method='pearson')
print(result)
# Output:          n         r        CI95%         p-unc  BF10  power
#         pearson 150  0.7832  [0.70, 0.85]  3.21e-32  inf   1.000

# Correlação parcial com covariáveis
result_partial = pg.partial_corr(
    data=df,
    x='peso_kg',
    y='gmdd',         # ganho médio diário de peso
    covar=['idade_dias', 'raca_code']
)

# Matriz de correlação com p-values via pingouin
corr_matrix = pg.pairwise_corr(
    data=df[['peso', 'gmdd', 'temperatura', 'precipitacao']],
    method='spearman',
    padjust='bonferroni'    # correção para múltiplos testes!
)
print(corr_matrix[['X', 'Y', 'r', 'p-corr', 'CI95%']])

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

def plot_corr_heatmap(df: pd.DataFrame, method: str = 'pearson',
                       mask_upper: bool = True, annotate: bool = True):
    """Heatmap de correlação profissional com máscara triangular."""
    corr = df.corr(method=method)
    
    # Máscara triangular superior (evita redundância)
    mask = np.zeros_like(corr, dtype=bool)
    if mask_upper:
        mask[np.triu_indices_from(mask)] = True
    
    fig, ax = plt.subplots(figsize=(10, 8))
    
    cmap = sns.diverging_palette(220, 20, as_cmap=True)
    
    sns.heatmap(
        corr,
        mask=mask,
        cmap=cmap,
        center=0,
        vmin=-1, vmax=1,
        annot=annotate,
        fmt=".2f",
        square=True,
        linewidths=0.5,
        linecolor='#1a1d2e',
        cbar_kws={"shrink": 0.8, "label": f"r de {method.capitalize()}"},
        ax=ax
    )
    
    ax.set_title(f'Matriz de Correlação ({method.capitalize()})',
                fontsize=14, fontweight='bold', pad=20)
    plt.tight_layout()
    plt.savefig('correlation_heatmap.png', dpi=150, bbox_inches='tight')
    return fig

import seaborn as sns
from scipy.stats import pearsonr

def corrfunc(x, y, **kwargs):
    """Adiciona r e p-value em cada painel do pairplot."""
    r, p = pearsonr(x, y)
    ax = plt.gca()
    label = f"r = {r:.2f}\np = {p:.3f}"
    ax.annotate(label, xy=(0.05, 0.85), xycoords=ax.transAxes,
               fontsize=9, color='#10b981' if p < 0.05 else '#94a3b8')

g = sns.PairGrid(df, vars=['peso', 'gmdd', 'temperatura', 'precipitacao'],
                 hue='fazenda')
g.map_upper(sns.scatterplot, alpha=0.6, size=3)
g.map_lower(corrfunc)  # r + p nos painéis inferiores
g.map_diag(sns.kdeplot, fill=True)
g.add_legend()
plt.suptitle('Pair Plot com Correlações por Fazenda', y=1.02)

import plotly.graph_objects as go
import plotly.express as px

corr = df.corr()

fig = go.Figure(go.Heatmap(
    z=corr.values,
    x=corr.columns.tolist(),
    y=corr.index.tolist(),
    colorscale='RdBu_r',
    zmin=-1, zmax=1,
    text=corr.round(2).values,
    texttemplate="%{text}",
    hovertemplate="%{x} × %{y}: %{z:.3f}<extra></extra>",
    colorbar=dict(title="Pearson r"),
))

fig.update_layout(
    title="Matriz de Correlação Interativa",
    template="plotly_dark",
    width=700, height=600,
    xaxis=dict(tickangle=-45),
)

fig.write_html("correlation_interactive.html")
fig.show()

import networkx as nx
import matplotlib.pyplot as plt
import numpy as np

def correlation_network(df: pd.DataFrame, threshold: float = 0.5,
                          method: str = 'pearson'):
    """
    Gera grafo onde nós = variáveis, arestas = |r| >= threshold.
    Espessura da aresta proporcional a |r|, cor = sinal.
    """
    corr = df.corr(method=method)
    G = nx.Graph()
    G.add_nodes_from(corr.columns)

    for i in range(len(corr.columns)):
        for j in range(i + 1, len(corr.columns)):
            r = corr.iloc[i, j]
            if abs(r) >= threshold:
                G.add_edge(corr.columns[i], corr.columns[j],
                           weight=abs(r), sign=1 if r > 0 else -1)

    pos = nx.spring_layout(G, seed=42, k=2)
    edge_colors = ['#ef4444' if G[u][v]['sign'] > 0 else '#60a5fa'
                   for u, v in G.edges()]
    edge_widths = [G[u][v]['weight'] * 5 for u, v in G.edges()]

    fig, ax = plt.subplots(figsize=(12, 8))
    ax.set_facecolor('#0c0e14')
    fig.set_facecolor('#0c0e14')
    
    nx.draw_networkx(G, pos=pos, ax=ax,
        node_color='#6ee7b7', node_size=600,
        font_color='white', font_size=8,
        edge_color=edge_colors, width=edge_widths, alpha=0.9)
    
    ax.set_title(f'Grafo de Correlação (|r| ≥ {threshold})', color='white')
    return fig, G

import holoviews as hv
from holoviews import opts
hv.extension('bokeh')

corr = df.corr().abs()  # apenas magnitude
cols = corr.columns.tolist()

# Criar lista de conexões (source, target, valor)
links = []
for i, c1 in enumerate(cols):
    for j, c2 in enumerate(cols):
        if i < j and corr.loc[c1, c2] > 0.4:
            links.append((i, j, corr.loc[c1, c2]))

chord = hv.Chord((links, hv.Dataset(
    pd.DataFrame(enumerate(cols), columns=['index', 'name']),
    'index'))
).opts(
    opts.Chord(
        labels='name',
        cmap='Category20',
        edge_cmap='Category20',
        edge_color=hv.dim('source').str(),
        width=600, height=600,
        title='Chord Diagram de Correlações'
    )
)
hv.save(chord, 'chord_correlation.html')

import pandas as pd
import numpy as np
from statsmodels.tsa.stattools import ccf, adfuller
import matplotlib.pyplot as plt

def cross_lag_correlation(x: pd.Series, y: pd.Series,
                            max_lag: int = 24) -> pd.DataFrame:
    """
    Calcula correlação cruzada para diferentes lags.
    Útil para descobrir relações temporais defasadas.
    Ex: preço da ração hoje → peso do gado daqui a N dias?
    """
    # Verificar estacionariedade (ADF test)
    p_x = adfuller(x.dropna())[1]
    p_y = adfuller(y.dropna())[1]
    
    if p_x > 0.05:
        x = x.diff().dropna()  # diferenciação para estacionarizar
    if p_y > 0.05:
        y = y.diff().dropna()

    # Cross-correlation function
    lags = range(-max_lag, max_lag + 1)
    corrs = []
    for lag in lags:
        if lag < 0:
            r, _ = stats.pearsonr(x[:lag], y[-lag:])
        elif lag > 0:
            r, _ = stats.pearsonr(x[lag:], y[:-lag])
        else:
            r, _ = stats.pearsonr(x, y)
        corrs.append({'lag': lag, 'r': r})
    
    return pd.DataFrame(corrs)

# Uso: descobrir se temperatura afeta GMDD com lag de N dias
ccf_result = cross_lag_correlation(df['temperatura'], df['gmdd'], max_lag=30)
best_lag = ccf_result.loc[ccf_result['r'].abs().idxmax()]
print(f"Maior correlação no lag {best_lag['lag']} dias: r={best_lag['r']:.3f}")

# Correlação móvel com janela de 30 dias
rolling_corr = df['temperatura'].rolling(window=30).corr(df['gmdd'])

# Visualizar evolução da correlação no tempo
fig, axes = plt.subplots(2, 1, figsize=(14, 8), sharex=True)

df['temperatura'].plot(ax=axes[0], color='#f59e0b', label='Temperatura')
df['gmdd'].plot(ax=axes[0], color='#6ee7b7', label='GMDD', secondary_y=True)
axes[0].set_title('Séries Originais')

rolling_corr.plot(ax=axes[1], color='#60a5fa')
axes[1].axhline(0, color='white', linestyle='--', alpha=0.4)
axes[1].fill_between(rolling_corr.index, rolling_corr, 0,
                      where=rolling_corr > 0, alpha=0.3, color='#ef4444')
axes[1].fill_between(rolling_corr.index, rolling_corr, 0,
                      where=rolling_corr < 0, alpha=0.3, color='#3b82f6')
axes[1].set_title('Rolling Correlation (janela 30 dias)')
plt.tight_layout()