data_visualization/data_prep.py at master · guyrux/data_visualization · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
# -*- coding: utf-8 -*-
"""
Created on Sun Jun 16 22:36:39 2019

@author: Gustavo Suto
"""
class data_prep:


    def breveDescricao(df):
        """
        Função breveDescricao

        Objetivo: Exclui atributos que estejam com colunas com todos os valores
        'NaN'. Imprime na tela a quantidade de atributos/campos e a quantidade
        de registros.

        Argumentos: um DataFrame.
        """

        df.dropna(axis=1, how="all", inplace=True)

        print("O data set possui: \n- {} atributos/campos; e \n- {} registros.\n".
          format(df.shape[1], df.shape[0]))
        df.info()


    def serieNulos(df, corte = 50):
        """
         responsável: Suto
         data: 04/05/19

        objetivo: essa função retorna uma tupla com:
                 (1) contendo uma pd.series com os atributos com maior
                 proporção de nulos; e
                 (2) uma string indicando quantos atributos estão com uma
                 proporção de nulos acima do corte dado.
                 argumentos: são necessários 2 argumentos:
                 (1) dataframe df - base que se deseja verificar quantos nulos
                 têm; e
                 (2) float corte - número entre 0 e 100 para indicar o valor
                 mínimo da proporção de nulos.

        Argumentos: Um DataFrame e um corte em porcentagem (valor padrão é 50%).

        """
        serie = (df.isnull().sum().sort_values(ascending=False)/len(df))*100
        return (serie[serie > corte], ("-> {} atributos/features/campos possuem mais de {}% de valores nulos.".
                format(len(serie[serie > corte]),corte)))

    def cardinalidade(df):
        """
        responsável: suto
        data: 27/10/19
        objetivo:   essa função retorna um dataframe com os atributos não
                    numéricos e sua respectiva cardinalidade em ordem crescente.
        Argumentos: somente 01 (um) argumento, o DataFrame que se deseja
                    analisar.
        """
        import pandas as pd

        df_temporario = df.select_dtypes(exclude=["float64"])

        matriz_cardialidade = []

        for i, coluna in df_temporario.items():
            matriz_cardialidade.append([i, len(df_temporario[i].unique()), df_temporario[i].unique()])

        matriz_cardialidade = pd.DataFrame(matriz_cardialidade, columns=["Atributo", "Cardinalidade", "Valores"])
        matriz_cardialidade.sort_values(by="Cardinalidade", inplace=True, ascending=True)

        return matriz_cardialidade

    def cardinalidadeComDescricao(df):
        """
        responsável: suto
        data: 27/10/19
        objetivo: essa função retorna dois dataframes.
            (1) O primeiro com a descrição dos atributos numéricos (int ou
            float); e
            (2) O segundo com os atributos não numéricos e sua respectiva
            cardinalidade em ordem crescente.
        argumentos: somente 01 (um) argumento, o DataFrame que se deseja
                    analisar.
        """
        import pandas as pd

        df_temporario = df.select_dtypes(exclude=["int64", "float64"])

        matriz_cardialidade = []

        for i, coluna in df_temporario.items():
            matriz_cardialidade.append([i, len(df_temporario[i].unique())])

        matriz_cardialidade = pd.DataFrame(matriz_cardialidade, columns=["Atributo", "Cardinalidade"])
        matriz_cardialidade.sort_values(by="Cardinalidade", inplace=True, ascending=True)

        return matriz_cardialidade.T, df.describe()


    def r2_ajustado(x, y, y_pred):
        """
        responsável: Suto
        data: 23/11/19

        r2_ajustado retorna o R² Ajustado e recebe como argumento as séries com
        o valor alvo teste e o predito.
        """
        n = x.shape[0]
        k = x.shape[1]
        return (1-((n-1)/(n-(k+1)))*(1-r2_score(y, y_pred)))