1.1.6 Aplicação Permutacional Test

Teste de permutação¶

Para realizar um teste de permutação junto e um teste t no cenário em que você possui duas colunas de métricas ks.scores1 e ks.scores2, podemos seguir os seguintes passos:

1. Teste T Pareado: É um teste paramétrico que assume que os dados seguem uma distribuição normal (para grandes amostras, isso é menos crítico devido ao Teorema Central do Limite). Ele é mais eficiente com amostras grandes e pode ser mais fácil de interpretar em muitos casos. Como já discutido, o teste t pareado é apropriado para amostras emparelhadas e verifica se a diferença média é significativamente diferente de zero.

2. Teste de Permutação: É um teste não-paramétrico que não faz suposições sobre a distribuição dos dados. Ele avalia a diferença entre as médias das amostras ao permutar os dados entre as duas amostras para gerar uma distribuição nula.É especialmente útil quando você tem uma amostra pequena ou quando não pode assumir a normalidade dos dados.

Implementação do Teste T Pareado¶

Antes de implementarmos o teste de permutação, vamos relembrar como implementar o teste t pareado:

Notebook -Teste T Calculo

Implementação do Teste de Permutação¶

O teste de permutação é um método de resampling que permite testar a hipótese nula de que duas amostras não apresentam diferenças estatísticas significativas. Isso é feito através da permutação repetida dos dados, calculando a diferença nas médias a cada permutação, para criar uma distribuição nula.

Passo a Passo para o Teste de Permutação¶

1. Formulação das Hipóteses:

H0 (Hipótese Nula): As duas amostras vêm da mesma distribuição (Não há diferença significativa entre as médias).
H1 (Hipótese Alternativa): As duas amostras vêm de distribuições diferentes (Há diferença significativa entre as médias).

2. Passos do Teste de Permutação:

Calcule a diferença observada entre as médias das duas amostras.
Combine as amostras em um único conjunto de dados.
Embaralhe (permute) aleatoriamente os dados e separe-os novamente em dois grupos.
Calcule a diferença entre as médias dos grupos permutados.
Repita o processo de permutação várias vezes (por exemplo, 10.000 vezes) para construir a distribuição nula.
Compare a diferença observada com a distribuição nula para determinar o valor p.

Teste de Permutação: Código 1:¶

In [1]:

Copied!





import numpy as np
import pandas as pd

# Dados fornecidos: ks.scores
data = {
    "ks.scores1": [0.583983, 0.576596, 0.556730, 0.595138, 0.584564],
    "ks.scores2": [0.490242, 0.551584, 0.514383, 0.535587, 0.546064]
}

# Criar o DataFrame
df = pd.DataFrame(data)

# Número de permutações
num_permutations = 10000

# Calcular a diferença observada entre as médias
observed_diff = np.mean(df['ks.scores1']) - np.mean(df['ks.scores2'])

# Combinar as duas amostras
combined = np.hstack((df['ks.scores1'], df['ks.scores2']))

# Inicializar contador para permutações onde a diferença é maior ou igual à diferença observada
count = 0

# Permutação
for _ in range(num_permutations):
    # Embaralhar os dados
    np.random.shuffle(combined)
    # Separar novamente em dois grupos
    permuted1 = combined[:len(df['ks.scores1'])]
    permuted2 = combined[len(df['ks.scores1']):]
    # Calcular a diferença de médias nas amostras permutadas
    permuted_diff = np.mean(permuted1) - np.mean(permuted2)
    # Verificar se a diferença permutada é maior ou igual à diferença observada
    if abs(permuted_diff) >= abs(observed_diff):
        count += 1

# Calcular o valor p
p_value_permutation = count / num_permutations

# Exibir resultados
print("Diferença observada:", observed_diff)
print("Valor p do teste de permutação:", p_value_permutation)

# Avaliação do resultado
if p_value_permutation < 0.05:
    print("Rejeitamos a hipótese nula: Há diferença significativa entre as médias.")
else:
    print("Não rejeitamos a hipótese nula: Não há diferença significativa entre as médias.")
import numpy as np
import pandas as pd

# Dados fornecidos: ks.scores
data = {
    "ks.scores1": [0.583983, 0.576596, 0.556730, 0.595138, 0.584564],
    "ks.scores2": [0.490242, 0.551584, 0.514383, 0.535587, 0.546064]
}

# Criar o DataFrame
df = pd.DataFrame(data)

# Número de permutações
num_permutations = 10000

# Calcular a diferença observada entre as médias
observed_diff = np.mean(df['ks.scores1']) - np.mean(df['ks.scores2'])

# Combinar as duas amostras
combined = np.hstack((df['ks.scores1'], df['ks.scores2']))

# Inicializar contador para permutações onde a diferença é maior ou igual à diferença observada
count = 0

# Permutação
for _ in range(num_permutations):
    # Embaralhar os dados
    np.random.shuffle(combined)
    # Separar novamente em dois grupos
    permuted1 = combined[:len(df['ks.scores1'])]
    permuted2 = combined[len(df['ks.scores1']):]
    # Calcular a diferença de médias nas amostras permutadas
    permuted_diff = np.mean(permuted1) - np.mean(permuted2)
    # Verificar se a diferença permutada é maior ou igual à diferença observada
    if abs(permuted_diff) >= abs(observed_diff):
        count += 1

# Calcular o valor p
p_value_permutation = count / num_permutations

# Exibir resultados
print("Diferença observada:", observed_diff)
print("Valor p do teste de permutação:", p_value_permutation)

# Avaliação do resultado
if p_value_permutation < 0.05:
    print("Rejeitamos a hipótese nula: Há diferença significativa entre as médias.")
else:
    print("Não rejeitamos a hipótese nula: Não há diferença significativa entre as médias.")

Diferença observada: 0.05183019999999994
Valor p do teste de permutação: 0.0053
Rejeitamos a hipótese nula: Há diferença significativa entre as médias.

Explicação do Código do Teste de Permutação¶

Combinação e Permutação: Combina as duas amostras em um array e embaralha repetidamente para criar distribuições permutadas.
Contagem: Conta o número de permutações onde a diferença permutada é maior ou igual à diferença observada.
Cálculo do Valor p: O valor p é calculado dividindo o número de permutações em que a diferença permutada foi maior ou igual à diferença observada pelo total de permutações.

Resultado Esperado¶

Ao executar ambos os testes, você terá duas análises complementares sobre a diferença entre as médias das métricas:

1. Teste T Pareado: Verifica se a diferença média é significativa sob a suposição de normalidade.
2. Teste de Permutação: Oferece uma abordagem não-paramétrica para testar a mesma hipótese.

Considerações¶

O teste t assume que as diferenças entre as amostras seguem uma distribuição normal. Se essa suposição não for válida, o teste de permutação é uma boa alternativa. O teste de permutação é computacionalmente intensivo, mas não depende de suposições sobre a distribuição dos dados, tornando-o útil para casos em que a normalidade é questionável.

Teste de Permutação: Código 2 ()¶

In [3]:

Copied!





from typing import Dict, List, Tuple
def permutation_test(
    array1: List[float],
    array2: List[float],
    anscreen: bool = True,
    alpha: float = 0.05
) -> Tuple[float, List[float], float, List[str]]:
    """
    Realiza um teste de permutação para comparar as médias de dois arrays.

    Args:
        array1 (List[float]): O primeiro array de dados.
        array2 (List[float]): O segundo array de dados.
        anscreen (bool): Se True, imprime os resultados na tela. Default é False.
        alpha (float): Nível de significância para o teste (p-valor). Default é 0.05.

    Returns:
        Tuple[float, List[float], float, List[str]]:
            - p_val (float): Valor p do teste de permutação.
            - mean_lst (List[float]): Lista das diferenças médias permutadas.
            - mean_diff (float): Diferença média observada entre os dois arrays.
            - text_lst (List[str]): Lista de mensagens interpretativas sobre o teste.
    """
    # Garantindo a entrada com numpy array
    array1 = np.array(array1)
    array2 = np.array(array2)
    
    # Cálculo das médias de cada vetor
    avg_array1 = array1.mean()
    avg_array2 = array2.mean()
    
    # Diferença entre as médias
    mean_diff = avg_array1 - avg_array2
    full_array = np.concatenate([array1, array2])
    mean_lst = []
    # Defina a semente aleatória para reprodutibilidade
    np.random.seed(42)
    for i in range(10000):
        # Com reposição: bootstrapping
        avg1 = np.random.choice(full_array, size=len(array1), replace=True).mean()
        avg2 = np.random.choice(full_array, size=len(array2), replace=True).mean()
        # reprece = True, Assume que qualquer valor pode vir de uma das duas listas, convergÊncia para Normal.
        mean_lst.append(avg1 - avg2)
    
    if mean_diff > 0:
        p_val = np.sum(np.array(mean_lst) > mean_diff) / len(mean_lst) 
    else:
        p_val = np.sum(np.array(mean_lst) < mean_diff) / len(mean_lst) 
    
    text_lst = ["\n Teste de Significancia ", 
                "**$H_0$:** Diferença entre as médias das métricas é zero. \n",
                f" Arrays sizes: {len(array1)}, {len(array2)} ",
                "* Difference between averages: %.4f - %.4f = %.4f" % (avg_array1, avg_array2, mean_diff),
                "* p_val = %.4f " %p_val]
    
    if p_val > alpha:
        text_lst.append(f'The model seems to produce similar results with CI-{1 - alpha} (fail to reject H0).\n')
    else:
        text_lst.append(f'The model seems to produce different results with CI-{1 - alpha} (reject H0).\n')
    
    if anscreen:
        for line in text_lst:
            print(line)   
    return p_val, mean_lst, mean_diff, text_lst

# Dados fornecidos: ks.scores
data = {
    "ks.scores1": [0.583983, 0.576596, 0.556730, 0.595138, 0.584564],
    "ks.scores2": [0.490242, 0.551584, 0.514383, 0.535587, 0.546064]
}
p_val, mean_lst, mean_diff, text_lst = permutation_test(array1 = data["ks.scores1"], array2 = data["ks.scores2"], alpha  = 0.05)
from typing import Dict, List, Tuple
def permutation_test(
    array1: List[float],
    array2: List[float],
    anscreen: bool = True,
    alpha: float = 0.05
) -> Tuple[float, List[float], float, List[str]]:
    """
    Realiza um teste de permutação para comparar as médias de dois arrays.

    Args:
        array1 (List[float]): O primeiro array de dados.
        array2 (List[float]): O segundo array de dados.
        anscreen (bool): Se True, imprime os resultados na tela. Default é False.
        alpha (float): Nível de significância para o teste (p-valor). Default é 0.05.

    Returns:
        Tuple[float, List[float], float, List[str]]:
            - p_val (float): Valor p do teste de permutação.
            - mean_lst (List[float]): Lista das diferenças médias permutadas.
            - mean_diff (float): Diferença média observada entre os dois arrays.
            - text_lst (List[str]): Lista de mensagens interpretativas sobre o teste.
    """
    # Garantindo a entrada com numpy array
    array1 = np.array(array1)
    array2 = np.array(array2)
    
    # Cálculo das médias de cada vetor
    avg_array1 = array1.mean()
    avg_array2 = array2.mean()
    
    # Diferença entre as médias
    mean_diff = avg_array1 - avg_array2
    full_array = np.concatenate([array1, array2])
    mean_lst = []
    # Defina a semente aleatória para reprodutibilidade
    np.random.seed(42)
    for i in range(10000):
        # Com reposição: bootstrapping
        avg1 = np.random.choice(full_array, size=len(array1), replace=True).mean()
        avg2 = np.random.choice(full_array, size=len(array2), replace=True).mean()
        # reprece = True, Assume que qualquer valor pode vir de uma das duas listas, convergÊncia para Normal.
        mean_lst.append(avg1 - avg2)
    
    if mean_diff > 0:
        p_val = np.sum(np.array(mean_lst) > mean_diff) / len(mean_lst) 
    else:
        p_val = np.sum(np.array(mean_lst) < mean_diff) / len(mean_lst) 
    
    text_lst = ["\n Teste de Significancia ", 
                "**$H_0$:** Diferença entre as médias das métricas é zero. \n",
                f" Arrays sizes: {len(array1)}, {len(array2)} ",
                "* Difference between averages: %.4f - %.4f = %.4f" % (avg_array1, avg_array2, mean_diff),
                "* p_val = %.4f " %p_val]
    
    if p_val > alpha:
        text_lst.append(f'The model seems to produce similar results with CI-{1 - alpha} (fail to reject H0).\n')
    else:
        text_lst.append(f'The model seems to produce different results with CI-{1 - alpha} (reject H0).\n')
    
    if anscreen:
        for line in text_lst:
            print(line)   
    return p_val, mean_lst, mean_diff, text_lst

# Dados fornecidos: ks.scores
data = {
    "ks.scores1": [0.583983, 0.576596, 0.556730, 0.595138, 0.584564],
    "ks.scores2": [0.490242, 0.551584, 0.514383, 0.535587, 0.546064]
}
p_val, mean_lst, mean_diff, text_lst = permutation_test(array1 = data["ks.scores1"], array2 = data["ks.scores2"], alpha  = 0.05)

 Teste de Significancia 
**$H_0$:** Diferença entre as médias das métricas é zero. 

 Arrays sizes: 5, 5 
* Difference between averages: 0.5794 - 0.5276 = 0.0518
* p_val = 0.0049 
The model seems to produce different results with CI-0.95 (reject H0).

Comparando os códigos de Permutação¶

O código 1 e a função permutation_test compartilham a mesma lógica básica para realizar um teste de permutação, mas existem algumas diferenças sutis na implementação e no tipo de análise.

Código Fornecido¶

1. Processo de Permutação:

Combina as duas amostras.
Embaralha aleatoriamente os dados combinados.
Separa os dados embaralhados novamente em duas amostras.
Calcula a diferença entre as médias das amostras permutadas e compara com a diferença observada.

2. Valor p:

O valor p é calculado como a proporção das diferenças permutadas que são maiores ou iguais à diferença observada.

3. Teste de Hipóteses:

Se o valor p for menor que 0.05, rejeita a hipótese nula, indicando que há uma diferença significativa entre as médias.

Função permutation_test¶

1. Processo de Permutação:

Em vez de combinar e embaralhar os dados, utiliza a técnica de bootstrapping (amostragem com reposição) para gerar as diferenças de médias. Calcula a diferença entre as médias de amostras bootstrapped e compara com a diferença observada.

2. Valor p:

O valor p é calculado comparando a diferença média observada com as diferenças médias obtidas nas amostras bootstrapped.

3. Teste de Hipóteses:

A função oferece uma descrição mais detalhada do teste, incluindo mensagens interpretativas.
Permite definir um nível de significância (alpha) e imprime resultados na tela se o argumento anscreen for True.

Principais Diferenças¶

Combinação de Dados: O código 1 combina as amostras e embaralha, enquanto a função permutation_test utiliza bootstrapping.
Tipo de Permutação: O código 1 usa permutação direta, enquanto a função permutation_test usa amostragem com reposição.
Saída: A função permutation_test retorna um conjunto mais detalhado de informações e permite a impressão dos resultados.

Ambos os métodos têm o mesmo objetivo: comparar as médias de duas amostras para determinar se há uma diferença significativa. A escolha entre eles pode depender da preferência ou do contexto específico do problema.