CoCalc -- Grupo10

GitHub Repository: robertopucp/1eco35_2022_2
Path: blob/main/Trabajo_grupal/WG4/Grupo10_spyder.py
²⁷¹⁴ views
1
# -*- coding: utf-8 -*-
2
"""
3
Created on Sat Sep 24 10:04:08 2022
4

5
@author: User
6
"""
7
import numpy as np
8
import pandas as pd
9
from pandas import DataFrame, Series
10
import statistics
11
import inspect
12
import pyreadr  # Load R dataset
13
import os # for usernanme y set direcotrio
14
os.chdir(f"C:/Users/user/Documentos/Git_Hub/1ECO35_2022_2/Lab4") 
15
cps2012_env = pyreadr.read_r("../data/cps2012.Rdata") 
16
from sklearn import linear_model
17
print(dir(linear_model))
18

19

20
class OLS(object):
21
    
22
    def __init__(self, X,Y, robust_sd = False):
23
        
24
        self.X = X
25
        self.Y = Dataset.iloc[:,1]
26
        self.W = Dataset.loc[:,'exp1':'exp4']
27
        robust_sd = False
28
        self.robust_sd = robust_sd
29
        
30
    if robust_sd==False:  
31
        def Algebralineal(self):
32
            
33
            self.n = self.X.shape[0]
34
            k = self.X.shape[1]
35
            X2 = np.column_stack((np.ones(self.n ), self.W.to_numpy() ))
36
            Y1 = self.Y.to_numpy().reshape(self.n  ,1)
37
            self.X2 = X2
38
            self.Y1 = Y1
39
            self.nk = self.n - k
40
        
41
        def Coefreg(self):
42
            
43
            self.Algebralineal()
44
            
45
            self.beta = np.linalg.inv(self.X2.T @ self.X2) @ ((self.X2.T) @ self.Y1 )
46
             
47
            
48
        def R2yMSE(self):
49
            
50
            self.Algebralineal()  # run function 
51
            self.Coefreg()
52
            
53
            y_est =  self.X2 @ self.beta
54
            self.y_est = y_est
55
            error = self.Y1 - y_est
56
            self.SCR = np.sum(np.square(error))
57
            SCT = np.sum(np.square(self.Y1 - np.mean(self.Y1))) 
58
    
59
            R2 = 1 - self.SCR/SCT
60
            rmse = (self.SCR/self.n)**0.5
61
    
62
            return R2      
63
     
64
        def estandar(self):
65
            
66
            self.Algebralineal()
67
            self.Coefreg()
68
            self.R2yMSE()
69
            
70
            scr = self.SCR
71
            sigma =  scr / self.nk
72
            Var = sigma*np.linalg.inv(self.X2.T @ self.X2)
73
            self.var = Var
74
            sd = np.sqrt( np.diag(Var) )
75
            t_est = np.absolute(self.beta/sd)
76
            pvalue = (1 - t.cdf(t_est, df=self.nk) ) * 2
77
            lower_bound = self.beta-1.96*sd
78
            upper_bound = self.beta+1.96*sd
79
        
80
        
81
        def robusta(self):
82
            
83
            self.Algebralineal()
84
            self.Coefreg()
85
            self.R2yMSE()
86
            self.estandar()
87
            
88
            error = self.Y1 - self.y_est
89
            matrix_robust = np.diag(np.square(error))
90
            Var = np.linalg.inv(self.X2.T @ self.X2) @ self.X2.T @ matrix_robust @ self.X2 @ np.linalg.inv(self.X2.T @ self.X2)
91
            sd = np.sqrt( np.diag(Var) )
92
            lower_bound = self.beta-1.96*sd
93
            upper_bound = self.beta+1.96*sd
94
        
95
        def Table(self, **Kargs):
96
            
97
            self.Algebralineal()
98
            self.Coefreg()
99
            self.R2yMSE()
100
            self.estandar()
101
         
102
            scr = self.SCR
103
            sigma =  scr / self.nk
104
            Var = sigma*np.linalg.inv(self.X2.T @ self.X2)
105
            sd = np.sqrt( np.diag(Var) )
106
            lower_bound = self.beta-1.96*sd
107
            upper_bound = self.beta+1.96*sd
108
            
109
            if (Kargs['Output'] == "DataFrame"):
110
    
111
                   df = pd.DataFrame( {"OLS": self.beta.flatten() , "standar_error" : sd.flatten()} )
112
                    
113
                    
114
            elif (Kargs['Output'] == "Diccionario"):
115
        
116
                df ={"OLS": self.beta.flatten() , "standar_error" : sd.flatten() ,
117
                                        "variance" : self.var.flatten() , "lower_bound" : lower_bound.flatten() , "upper_bound" : upper_bound.flatten() }
118
        
119
        
120
            return df    
121

122
Dataset = cps2012.iloc[ : ,  np.where( variance_cols != 0   )[0] ]
123

124
Reg1 = OLS(X,Y)
125
Reg1.Algebralineal()
126
Reg1.Coefreg()
127
Reg1.R2yMSE()
128
Reg1.beta
129
Reg1.estandar()
130
Reg1.robusta()
131
Reg1.Table(Output = "DataFrame")
132
Reg1.Table(Output = "Diccionario")['OLS'] 
133
Reg1.Table(Output = "Diccionario")['standar_error'] 
134
Reg1.Table(Output = "Diccionario")['variance'] 
135
Reg1.Table(Output = "Diccionario")['lower_bound'] 
136
Reg1.Table(Output = "Diccionario")['upper_bound'] 
137
         
138

139

140
Product

Resources

Company
