GitHub Repository: robertopucp/1eco35_2022_2
Path: blob/main/Lab5/Jubypter_notebook_py.ipynb
²⁷¹⁰ views

Kernel: Python 3 (ipykernel)

Classes

En esta sección veremos una aplicación del tema en la estimación de una función de costos translogaritmica

\begin{aligned} lnCT &= \beta_{0}+\beta_{q}lnq+ \beta_{qq}(lnq)^2+\beta_{q1}lnqlnp_1+\beta_{q2}lnqlnp_2+ \beta_{q3}lnqlnp_{3} +\beta_{1}lnp_1+\beta_{2}lnp_2+ \beta_{3}lnp_3 \\ & + \beta_{11}(lnp_{1})^2+ \beta_{22}(lnp_{2})^2+ \beta_{33}(lnp_{3})^2 + \beta_{12}lnp_{1}lnp_{2}+ \beta_{13}lnp_{1}lnp_{3}+\beta_{23}lnp_{2}lnp_{3} \end{aligned}

q: total output
p1 (PL): wage rate
p2 (PF) : capital price index
p3 (PK): fuel price

In [1]:

import pandas as pd
import numpy as np
import scipy.stats as stats
from scipy.stats import t # t - student 
import os

In [2]:

user = os.getlogin()   # Username
os.chdir(f"C:/Users/{user}/Documents/GitHub/1ECO35_2022_2/Lab4")

In [3]:

greene = pd.read_csv(r"../data/christensen_greene_f4.csv")

In [4]:

greene

Out[4]:

In [5]:


ct = greene.COST.values # se convierte a un array 
q = greene.Q.values
p1 = greene.PL.values
p2 = greene.PF.values
p3 = greene.PK.values

In [6]:

ct = greene.COST.values 
ct

Out[6]:

array([2.130000e-01, 3.042700e+00, 9.405900e+00, 7.606000e-01,
       2.258700e+00, 1.342200e+00, 6.159000e-01, 4.887000e-01,
       1.147400e+00, 7.549200e+00, 2.053200e+00, 6.363000e-01,
       3.150400e+00, 1.031360e+01, 5.848800e+00, 4.505000e+00,
       5.597100e+00, 3.725500e+00, 6.006500e+00, 1.278300e+01,
       6.621400e+00, 9.642900e+00, 8.685200e+00, 8.637200e+00,
       1.124190e+01, 6.622100e+00, 1.096650e+01, 1.362700e+01,
       7.439500e+00, 9.784300e+00, 2.086710e+01, 1.970920e+01,
       1.404310e+01, 1.019020e+01, 1.617640e+01, 4.225140e+01,
       2.256120e+01, 3.301750e+01, 1.889630e+01, 1.326790e+01,
       2.154540e+01, 3.553030e+01, 2.980110e+01, 3.087730e+01,
       2.435650e+01, 1.748020e+01, 1.990080e+01, 2.878610e+01,
       2.708320e+01, 2.244210e+01, 3.020670e+01, 3.016780e+01,
       3.258400e+01, 4.738640e+01, 2.429030e+01, 3.129220e+01,
       3.198840e+01, 4.190160e+01, 5.811540e+01, 4.052810e+01,
       3.706660e+01, 2.516860e+01, 4.518270e+01, 5.517640e+01,
       4.117980e+01, 8.035930e+01, 6.848000e+01, 9.738590e+01,
       5.276340e+01, 3.884720e+01, 4.811250e+01, 7.907050e+01,
       1.118863e+02, 7.788490e+01, 8.710150e+01, 5.772670e+01,
       9.071680e+01, 1.832315e+02, 1.692354e+02, 7.625280e+01,
       1.342283e+02, 1.683777e+02, 1.253356e+02, 1.915625e+02,
       2.405137e+02, 1.304000e-01, 7.293000e-01, 1.770500e+00,
       2.236700e+00, 2.559300e+00, 2.035800e+00, 7.623600e+00,
       1.110910e+01, 9.467400e+00, 1.382620e+01, 1.728950e+01,
       1.617040e+01, 2.439750e+01, 2.724430e+01, 2.948700e+01,
       3.510910e+01, 2.548140e+01, 4.241170e+01, 7.203550e+01,
       1.469890e+02, 5.174150e+01, 2.155870e+01, 1.427100e+01,
       6.610320e+01, 1.132555e+02, 9.037180e+01, 2.404858e+02,
       2.772965e+02, 1.079776e+02, 2.697728e+02, 7.962070e+01,
       3.388140e+01, 1.495290e+01, 3.397330e+01, 7.870280e+01,
       1.943910e+01, 2.822479e+02, 2.829401e+02, 4.691852e+02,
       7.374088e+02, 2.088360e+01, 2.177920e+01, 2.284360e+01,
       3.163680e+01, 4.816780e+01, 5.928100e+00, 2.560940e+01,
       1.746300e+01, 1.364300e+00, 4.679880e+01, 5.020930e+01,
       4.089400e+01, 2.472340e+01, 3.022400e+01, 3.121610e+01,
       1.062729e+02, 5.536240e+01, 2.347870e+01, 2.226230e+01,
       3.047070e+01, 1.135910e+02, 8.809910e+01, 1.119243e+02,
       1.193736e+02, 1.232430e+01, 3.158000e-01, 1.052870e+01,
       2.219980e+01, 6.829300e+00, 3.760500e+00, 3.982200e+00,
       3.018800e+01, 6.785620e+01])

In [7]:

# Generation of data

y = np.log(  ct  ) # lnCT

c = np.ones( len( y ) ) # Constant
xq = np.log( q ) # lnq
xqq = np.log( q )*np.log( q ) # lnq^2
xq1 = np.log( q )*np.log( p1 ) # lnq*lnp_1
xq2 = np.log( q )*np.log( p2 ) # lnq*lnp_2
xq3 = np.log( q )*np.log( p3 ) # lnq*ln_3
x1 = np.log( p1 ) # lnp_1
x2 = np.log( p2 ) # ln_p2
x3 = np.log( p3 ) # ln_p3
x11 = np.log( p1 )*np.log( p1 ) # 0.5ln2p_1
x22 = np.log( p2 )*np.log( p2 ) # 0.5ln2p_2
x33 = np.log( p3 )*np.log( p3 ) # 0.5ln2p_3
x12 = np.log( p1 )*np.log( p2 ) # lnp_1*lnp_2
x13 = np.log( p1 )*np.log( p3 ) # lnp_1*lnp_3
x23 = np.log( p2 )*np.log( p3 ) # lnp_2*lnp_3

columns = [  "ln_cost", "lnq", "(lnq)^2", "(lnq)(lnp1)", "(lnq)(lnp2)",
          "(lnq)(lnp3)", "lnp1", "lnp2", "lnp3", "(lnp1)^2",
          "(lnp2)^2", "(lnp3)^2", "(lnp1)(lnp2)", "(lnp1)(lnp3)", "(lnp2)(lnp3)" ]

data_val = np.asarray( [ y, xq,  xqq, xq1, xq2,
                xq3, x1,  x2,  x3,  x11, 
                x22, x33, x12, x13, x23 ] ).T # se coloca transpuesta para que cada varaible sea una columna 

# np.asarray permite crear una matriz a partir de vectores 

data = pd.DataFrame(  data_val , columns = columns  )

In [8]:

data

Out[8]:

Getting filtered data to regressions

In [9]:

# selecting columns
X = data.iloc[ : , 1: ]
y = data.ln_cost

Generate a new class named RegClass. The initial attributes of your class must be X, y, and intercept. X (covariables) must be a pd.DataFrame and y (endog) must be a pd.Series and intercept can be True or False, by default True. Also, you must specify the type of your class' parameters, and output and It must raise an error if the inputs do not meet the requirements. This class should have two methods: reg_OLS (You can add more if you think it is necessary). These methods should return the same output as the previously defined functions with the same name. The method reg_OLS does not need an extra parameter to be executed. After executing the method reg_OLS, any user should access the following attributes: beta_OLS and var_OLS. They should look like beta_OLS_output and var_OLS_output.

\widehat{\boldsymbol{\varepsilon}} = \mathbf{Y} - \mathbf{X} \widehat{\boldsymbol{\beta}}_{OLS}

\widehat{\sigma}^2_{OLS} = \dfrac{\widehat{\boldsymbol{\varepsilon}}^\top \widehat{\boldsymbol{\varepsilon}}}{N - (k)}

\begin{aligned} \mathbb{V}{\rm ar} (\widehat{\boldsymbol{\beta}}^{(OLS)}) = \sigma^2 \left( \mathbf{X}^\top \mathbf{X}\right)^{-1} \end{aligned}

\begin{aligned} lnCT &= \beta_{0}+\beta_{q}lnq+ \beta_{qq}(lnq)^2+\beta_{q1}lnqlnp_1+\beta_{q2}lnqlnp_2+ \beta_{q3}lnqlnp_{3} +\beta_{1}lnp_1+\beta_{2}lnp_2+ \beta_{3}lnp_3 \\ & + \beta_{11}(lnp_{1})^2+ \beta_{22}(lnp_{2})^2+ \beta_{33}(lnp_{3})^2 + \beta_{12}lnp_{1}lnp_{2}+ \beta_{13}lnp_{1}lnp_{3}+\beta_{23}lnp_{2}lnp_{3} \end{aligned}

In [10]:

class RegClass( object ):
    
    def __init__( self, X : pd.DataFrame , y : pd.Series , intercept = True  ):
    
        if not isinstance( X, pd.DataFrame ):
            raise TypeError( "X must be a pd.DataFrame." )

        if not isinstance( y , pd.Series ):
            raise TypeError( "y must be a pd.Series." )
            
        # asignando atributos de la clase
        
        
        self.X = X
        self.y = y
        self.intercept = intercept
    
        if self.intercept:

            self.X[ 'Intercept' ] = 1
            # colcondo la columna Intercept en la primera columna 
            cols = self.X.columns.tolist() # nombre de varaible a lista 
            new_cols_orders = [cols[ -1 ]] + cols[ 0:-1 ] # juntano listas
            
#             new_cols_orders = [cols[ -1 ]].extend(cols[ 0:-1 ]) # append lista a una lista 
            
            # [cols[ -1 ]] la jala la ultima fila , cols[ 0:-1 ]  primera fila hasta la penultima fila 
            
            self.X = self.X.loc[ : , new_cols_orders ] # usamos .loc que filtra por nombre de filas o columnas 
    
        else:
            pass
            # No se ejecuta nada, la base de datos no se altera
    
        # creando nuevos atributos 
        
        self.X_np = self.X.values  # Dataframe a multi array
        self.y_np = y.values.reshape( -1 , 1 ) # de objeto serie a array columna 
        self.columns = self.X.columns.tolist() # nombre de la base de datos como objeto lista
    
    
    # reshape( - 1, 1 ), primer -1 hace que sea un array fila, el otro 1 define la cantidad de columnas. En esta caso solo 1
    # reshape( 10, 2 ) se puede usar reshape( -1, 2 )
    
    
    def reg_beta_OLS( self ):
        # X, y en Matrix, y vector columna respectivamente 
        
        X_np = self.X_np
        y_np = self.y_np

        # beta_ols
        beta_ols = np.linalg.inv( X_np.T @ X_np ) @ ( X_np.T @ y_np )

        # columnas de X
        index_names = self.columns
        # Output
        beta_OLS_output = pd.DataFrame( beta_ols , index = index_names , columns = [ 'Coef.' ] )
        
        # Dataframe de coeffientes como atributo 
        
        self.beta_OLS = beta_OLS_output
        
        return beta_OLS_output
    
    def reg_var_OLS( self ):
    
        # Se corre la función reg_beta_OLS que estima el vector de coeficientes
        
        self.reg_beta_OLS()
        
        X_np = self.X_np
        y_np = self.y_np
        
        
        # beta_ols
        beta_OLS = self.beta_OLS.values.reshape( - 1, 1 ) # Dataframe a vector columna 

        # errors
        e = y_np - ( X_np @ beta_OLS )

        # error variance
        N = X.shape[ 0 ]
        total_parameters = X.shape[ 1 ]
        error_var = ( (e.T @ e)[ 0 ] )/( N - total_parameters )

        # Varianza
        var_OLS =  error_var * np.linalg.inv( X_np.T @ X_np )

        # columns names 
        index_names = self.columns
        # output
        var_OLS_output = pd.DataFrame( var_OLS , index = index_names , columns = index_names )
        ## variance output como nuevo atributo del objeto
        self.var_OLS = var_OLS_output

        
    def reg_OLS( self ):
        
        # Se corren las funciones
        self.reg_beta_OLS()
        self.reg_var_OLS()
        X = self.X_np
        
        # var y beta
        beta_OLS = self.beta_OLS.values.reshape( -1, 1 )
        var_OLS = self.var_OLS.values
        
        # standard errors
        beta_se = np.sqrt( np.diag( var_OLS ) )

        # Se calcula el test statistic para cada coeficiente
        t_stat = beta_OLS.ravel() / beta_se.ravel()
        
        
        # .ravel() te multiarray a simple array
        
        # p-value:
        N = X.shape[ 0 ]
        k = beta_OLS.size
        self.nk = N-k
        pvalue = (1 - t.cdf(t_stat, df= N - k) ) * 2

        # Confidence interval
        
        up_bd = beta_OLS.ravel() + 1.96*beta_se
        lw_bd = beta_OLS.ravel() - 1.96*beta_se

        table_data ={  'Coef.'    : beta_OLS.ravel() ,  # .ravel() :: .flatten()
                       "Std.Err." : beta_se.ravel(),
                       "t"        : t_stat.ravel(),
                       "P>|t|"    : pvalue.ravel(), 
                       "[0.025"   : lw_bd.ravel(),
                       "0.975]"   : up_bd.ravel()
                    }
        
        # defining index names
        index_names = self.columns
        
        # defining a pandas dataframe 
        reg_OLS = pd.DataFrame( table_data , index = index_names )

        return reg_OLS

In [11]:

A = RegClass( X, y )

# Atributo de las variables 

A.X

Out[11]:

In [12]:

A.y

Out[12]:

   -1.546463
    1.112745
    2.241337
   -0.273648
    0.814789
         ...   
  1.921222
  1.324552
  1.381834
  3.407444
  4.217391
Name: ln_cost, Length: 158, dtype: float64

In [13]:

A.reg_beta_OLS()  # Resultado del método reg OLS

Out[13]:

In [14]:

A.beta_OLS # El mismo resultado pero como atributo

Out[14]:

In [16]:

A.reg_var_OLS()

In [17]:

A.reg_OLS()

Out[17]:

In [18]:

# Regresión sin intercepto
X = data.iloc[ : , 1: ]
y = data.ln_cost


Reg_nitc = RegClass( X, y , intercept = False)
Reg_nitc.X

Out[18]:

In [19]:

Reg_nitc.reg_OLS()

Out[19]:

In [20]:

Reg_nitc.nk

Out[20]:

144

In [21]:

# Añadiendo nuevos atributos 

Reg_nitc.nk = 100

In [22]:

# Añadiendo nuevas funciones a la clase RegClass

def new_funtion(x): 
    return x**2

Reg_nitc.nk1 = new_funtion

In [23]:

Reg_nitc.nk1(25)

Out[23]:

625

In [24]:

from sklearn import linear_model

In [25]:

print(dir(linear_model))

# permite conocer los atributos y métodos de lasliberias en Python

Out[25]:

['ARDRegression', 'BayesianRidge', 'ElasticNet', 'ElasticNetCV', 'GammaRegressor', 'Hinge', 'Huber', 'HuberRegressor', 'Lars', 'LarsCV', 'Lasso', 'LassoCV', 'LassoLars', 'LassoLarsCV', 'LassoLarsIC', 'LinearRegression', 'Log', 'LogisticRegression', 'LogisticRegressionCV', 'ModifiedHuber', 'MultiTaskElasticNet', 'MultiTaskElasticNetCV', 'MultiTaskLasso', 'MultiTaskLassoCV', 'OrthogonalMatchingPursuit', 'OrthogonalMatchingPursuitCV', 'PassiveAggressiveClassifier', 'PassiveAggressiveRegressor', 'Perceptron', 'PoissonRegressor', 'QuantileRegressor', 'RANSACRegressor', 'Ridge', 'RidgeCV', 'RidgeClassifier', 'RidgeClassifierCV', 'SGDClassifier', 'SGDOneClassSVM', 'SGDRegressor', 'SquaredLoss', 'TheilSenRegressor', 'TweedieRegressor', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '_base', '_bayes', '_cd_fast', '_coordinate_descent', '_glm', '_huber', '_least_angle', '_logistic', '_omp', '_passive_aggressive', '_perceptron', '_quantile', '_ransac', '_ridge', '_sag', '_sag_fast', '_sgd_fast', '_stochastic_gradient', '_theil_sen', 'enet_path', 'lars_path', 'lars_path_gram', 'lasso_path', 'orthogonal_mp', 'orthogonal_mp_gram', 'ridge_regression']

2.1. Inheritance

La Inheritance es la capacidad de una clase para derivar o heredar las propiedades de otra clase. Los beneficios de la herencia son:

Representa bien las relaciones del mundo real.
Proporciona reutilización de un código. No tenemos que escribir el mismo código una y otra vez. Además, nos permite agregar más características a una clase sin modificarla.
Es de naturaleza transitiva, lo que significa que si la clase B hereda de otra clase A, entonces todas las subclases de B heredarán automáticamente de la clase A.
Te ayudará a comprender cómo funciona Sklearn Class (libreria de modelos estadísticos).

El modelo base se llama clase Base o Super o Padre.

Diferentes formas de Inheritance:

Herencia única: cuando una clase secundaria hereda solo de una clase principal, se denomina herencia única.
Herencia múltiple: cuando una clase secundaria hereda de varias clases principales, se denomina herencia múltiple. A diferencia de Java y como C++, Python admite la herencia múltiple. Especificamos todas las clases principales como una lista separada por comas entre paréntesis.

2.2 Single Inheritance

In single inheritance, la clase derivada usa las características o miembros de la clase base única

In [ ]:

class RegClass( object ):
    
    def __init__( self, X : pd.DataFrame , y : pd.Series ):
    
        if not isinstance( X, pd.DataFrame ):
            raise TypeError( "X must be a pd.DataFrame." )

        if not isinstance( y , pd.Series ):
            raise TypeError( "y must be a pd.Series." )
            
        # asignando atributos de la clase
        
        
        self.X = X
        self.y = y
    
        # creando nuevos atributos 
        
        self.X_np = self.X.values  # Dataframe a multi array
        self.y_np = y.values.reshape( -1 , 1 ) # de objeto serie a array columna 
        self.columns = self.X.columns.tolist() # nombre de la base de datos como objeto lista
    
    
    # reshape( - 1, 1 ), primer -1 hace que sea un array fila, el otro 1 define la cantidad de columnas. En esta caso solo 1
    # reshape( 10, 2 ) se puede usar reshape( -1, 2 )
    
    
    def reg_beta_OLS( self, M ):
        # X, y en Matrix, y vector columna respectivamente 
        
        M = self.X_np
        y_np = self.y_np

        # beta_ols
        beta_ols = np.linalg.inv( M.T @ M ) @ ( M.T @ y_np )
        
        return beta_ols

In [ ]:

  
    
class reg_intercepto_OLS(RegClass):
    
        def __init__( self,  X : pd.DataFrame , y : pd.Series , intercept = True ):
    
            self.inter = intercept
    
    
            RegClass.__init__(self, X, y) 
            RegClass2.__init__(self,W)
            RegClass2.__init__(self, Z) 

            # Se corre la función reg_beta_OLS que estima el vector de coeficientes

            if self.inter:

                self.X[ 'Intercept' ] = 1
                cols = self.X.columns.tolist()
                new_cols_orders = [cols[ -1 ]] + cols[ 0:-1 ]
                self.X = self.X.loc[ : , new_cols_orders ] 

            else:
                pass

        
        def OLS_intercepto(self):
            
            X_int = self.X
            
            beta_int =  self.reg_beta_OLS(X_int)
            index_names = self.columns
            beta_OLS_int_output = pd.DataFrame( beta_int , index = index_names , columns = [ 'Coef. with intercept' ] )
        
            return beta_OLS_int_output

In [ ]:

A = reg_intercepto_OLS( X, y , intercept = True)

In [ ]:

A.OLS_intercepto()

In [ ]:

A.inter

In [ ]:

Out = reg_intercepto_Var_OLS(X,y, intercept = True)

In [ ]:

Out.OLS_residual()

Multiple inheritance es aquella en la que la clase derivada adquiere dos o más clases base. En la herencia múltiple, la clase derivada puede usar las características conjuntas de las clases base heredadas. Sklearn usa herencia múltiple.

2.4 Private Variables and methods

Las variables privadas nos permiten especificar variables que no queremos que los usuarios o socios del proyecto cambien.

Las variables de instancia "privadas" son variables a las que no se puede acceder excepto desde dentro de un objeto. Sin embargo, no existe la existencia de variables “Privadas”. En python, la mayoría de los códigos y codificadores de Python siguen una convención, es decir, un nombre con el prefijo de un guión bajo, por ej. __diploma debe tratarse como una parte no pública de la API o cualquier código de Python, ya sea una función, un método o un miembro de datos.

In [115]:

class RegClass:
    
    __slots__ = [ '__X', 'y', 'intercept','X_np','y_np','columns','beta_OLS']  # colocar todos los atributos
    
    def __init__( self, X : pd.DataFrame , y : pd.Series , intercept = True  ):
    
        if not isinstance( X, pd.DataFrame ):
            raise TypeError( "X must be a pd.DataFrame." )

        if not isinstance( y , pd.Series ):
            raise TypeError( "y must be a pd.Series." )
            
        # asignando atributos de la clase
        
        
        self.__X = X  # privatización del atributo 
        self.y = y
        self.intercept = intercept
    
        if self.intercept:

            self.__X[ 'Intercept' ] = 1
            # colcondo la columna Intercept en la primera columna 
            cols = self.__X.columns.tolist()
            new_cols_orders = [cols[ -1 ]] + cols[ 0:-1 ] # juntano listas
#             new_cols_orders = [cols[ -1 ]].extend(cols[ 0:-1 ]) # append lista a una lista 
            
            # [cols[ -1 ]] la jala la ultima fila , cols[ 0:-1 ]  primera fila hasta la penultima fila 
            
            self.__X = self.__X.loc[ : , new_cols_orders ] # usamos .loc que filtra por nombre de filas o columnas 

        else:
            pass
            # No se ejecuta nada, la base de datos no se altera
    
        # creando nuevos atributos 
        
        self.X_np = self.__X.values  # Dataframe a multi array
        self.y_np = y.values.reshape( -1 , 1 ) # de objeto serie a array columna 
        self.columns = self.__X.columns.tolist() # nombre de la base de datos como objeto lista
    
    
    # reshape( - 1, 1 ), primer -1 hace que sea un array fila, el otro 1 define la cantidad de columnas. En esta caso solo 1
    # reshape( 10, 2 ) se puede usar reshape( -1, 2 )
    
    
    def reg_beta_OLS( self ): 
        # X, y en Matrix, y vector columna respectivamente 
        
        X_np = self.X_np
        y_np = self.y_np

        # beta_ols
        beta_ols = np.linalg.inv( X_np.T @ X_np ) @ ( X_np.T @ y_np )

        # columnas de X
        index_names = self.columns
        # Output
        beta_OLS_output = pd.DataFrame( beta_ols , index = index_names , columns = [ 'Coef.' ] )
        
        # Dataframe de coeffientes como atributo 
        
        self.beta_OLS = beta_OLS_output
        
        return beta_OLS_output
    
    def reg_var_OLS( self ):
    
        # Se corre la función reg_beta_OLS que estima el vector de coeficientes
        
        self.reg_beta_OLS()
        
        X_np = self.X_np
        y_np = self.y_np
        
        
        # beta_ols
        beta_OLS = self.beta_OLS.values.reshape( - 1, 1 ) # Dataframe a vector columna 

        # errors
        e = y_np - ( X_np @ beta_OLS )

        # error variance
        N = X.shape[ 0 ]
        total_parameters = X.shape[ 1 ]
        error_var = ( (e.T @ e)[ 0 ] )/( N - total_parameters )

        # Varianza
        var_OLS =  error_var * np.linalg.inv( X_np.T @ X_np )

        # columns names 
        index_names = self.columns
        # output
        var_OLS_output = pd.DataFrame( var_OLS , index = index_names , columns = index_names )
        ## variance output como nuevo atributo del objeto
        self.var_OLS = var_OLS_output

        
    def reg_OLS( self ):
        
        # Se corren las funciones
        self.reg_beta_OLS()
        self.reg_var_OLS()
        X = self.X_np
        
        # var y beta
        beta_OLS = self.beta_OLS.values.reshape( -1, 1 )
        var_OLS = self.var_OLS.values
        
        # standard errors
        beta_se = np.sqrt( np.diag( var_OLS ) )

        # Se calcula el test statistic para cada coeficiente
        t_stat = beta_OLS.ravel() / beta_se.ravel()
        
        
        # .ravel() te multiarray a simple array

        # p-value:
        N = X.shape[ 0 ]
        k = beta_OLS.size
        pvalue = (1 - t.cdf(t_stat, df= N - k) ) * 2

        # Confidence interval
        
        up_bd = beta_OLS.ravel() + 1.96*beta_se
        lw_bd = beta_OLS.ravel() - 1.96*beta_se

        table_data ={  'Coef.'    : beta_OLS.ravel() ,
                       "Std.Err." : beta_se.ravel(),
                       "t"        : t_stat.ravel(),
                       "P>|t|"    : pvalue.ravel(), 
                       "[0.025"   : lw_bd.ravel(),
                       "0.975]"   : up_bd.ravel()
                    }
        
        # defining index names
        index_names = self.columns
        
        # defining a pandas dataframe 
        reg_OLS = pd.DataFrame( table_data , index = index_names )

        return reg_OLS

In [116]:

A = RegClass( X, y )

In [117]:

A.reg_beta_OLS()

Out[117]:

In [118]:

def new_funtion(x): 
    return x**2

In [119]:

A.reg_var_OLS = new_funtion

Out[119]:

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Input In [119], in <cell line: 1>()
----> 1 A.reg_var_OLS = new_funtion
AttributeError: 'RegClass' object attribute 'reg_var_OLS' is read-only

In [120]:

A.__X

Out[120]:

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Input In [120], in <cell line: 1>()
----> 1 A.__X
AttributeError: 'RegClass' object has no attribute '__X'

In [121]:

A.__X = 8

Out[121]:

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Input In [121], in <cell line: 1>()
----> 1 A.__X = 8
AttributeError: 'RegClass' object has no attribute '__X'

In [123]:

dir(RegClass)

Out[123]:

['X_np',
 '_RegClass__X',
 '__class__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__slots__',
 '__str__',
 '__subclasshook__',
 'beta_OLS',
 'columns',
 'intercept',
 'reg_OLS',
 'reg_beta_OLS',
 'reg_var_OLS',
 'y',
 'y_np']

Classes

Getting filtered data to regressions

2.1. Inheritance

2.2 Single Inheritance

2.3 Multiple Inheritance

2.4 Private Variables and methods

Product

Resources

Company