Saltar al contenido principal
LibreTexts Español

4.6: Cuando las cosas salen mal

  • Page ID
    149797
  • \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

    \( \newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\)

    ( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\)

    \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

    \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\)

    \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

    \( \newcommand{\Span}{\mathrm{span}}\)

    \( \newcommand{\id}{\mathrm{id}}\)

    \( \newcommand{\Span}{\mathrm{span}}\)

    \( \newcommand{\kernel}{\mathrm{null}\,}\)

    \( \newcommand{\range}{\mathrm{range}\,}\)

    \( \newcommand{\RealPart}{\mathrm{Re}}\)

    \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

    \( \newcommand{\Argument}{\mathrm{Arg}}\)

    \( \newcommand{\norm}[1]{\| #1 \|}\)

    \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

    \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\AA}{\unicode[.8,0]{x212B}}\)

    \( \newcommand{\vectorA}[1]{\vec{#1}}      % arrow\)

    \( \newcommand{\vectorAt}[1]{\vec{\text{#1}}}      % arrow\)

    \( \newcommand{\vectorB}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vectorC}[1]{\textbf{#1}} \)

    \( \newcommand{\vectorD}[1]{\overrightarrow{#1}} \)

    \( \newcommand{\vectorDt}[1]{\overrightarrow{\text{#1}}} \)

    \( \newcommand{\vectE}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash{\mathbf {#1}}}} \)

    \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

    A veces cuando tratamos de desarrollar un modelo usando el proceso de eliminación hacia atrás, obtenemos resultados que no parecen tener ningún sentido. Por ejemplo, intentemos desarrollar un modelo de regresión multifactorial para los datos de Int1992 utilizando este proceso. Como antes, comenzamos por incluir todos los predictores potenciales de la Tabla 4.1 en el modelo. Cuando intentamos eso para Int1992, sin embargo, obtenemos el siguiente resultado:

    > int92.lm<-lm(nperf ~ clock + threads + cores + transistors + dieSize + voltage + featureSize + 
    channel + FO4delay + L1icache + sqrt(L1icache) + L1dcache + sqrt(L1dcache) + L2cache + sqrt(L2cache))
    > summary(int92.lm)
    
    Call:
    lm(formula = nperf ~ clock + threads + cores + transistors +
        dieSize + voltage + featureSize + channel + FO4delay +
        L1icache + sqrt(L1icache) + L1dcache + sqrt(L1dcache) +
        L2cache + sqrt(L2cache))
        
    Residuals:
      14      15      16       17       18      19
    0.4096  1.3957  -2.3612  0.1498  -1.5513   1.9575
    Coefficients: (14 not defined because of singularities)
                        Estimate        Std. Error         t value        Pr(>|t|)
    (Intercept)         -25.93278        6.56141            -3.952          0.0168 *
    clock                 0.35422        0.02184            16.215        8.46e-05 ***
    threads                    NA             NA                NA              NA
    cores                      NA             NA                NA              NA
    transistors                NA             NA                NA              NA
    dieSize                    NA             NA                NA              NA
    voltage                    NA             NA                NA              NA
    featureSize                NA             NA                NA              NA
    channel                    NA             NA                NA              NA
    FO4delay                   NA             NA                NA              NA
    L1icache                   NA             NA                NA              NA
    sqrt(L1icache)             NA             NA                NA              NA
    L1dcache                   NA             NA                NA              NA
    sqrt(L1dcache)             NA             NA                NA              NA
    L2cache                    NA             NA                NA              NA
    sqrt(L2cache)              NA             NA                NA              NA
    ---
    Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
    Residual standard error: 1.868 on 4 degrees (72 observations deleted due to missingness)
    Multiple R-squared: 0.985, Adjusted R-squared: 0.9813 F-statistic: 262.9 on 1 and 4 DF, p-value: 8.463e-05
    

    Screen Shot 2020-01-11 at 12.27.09 AM.png

    Observe que cada predictor menos reloj tiene NA para cada entrada. Además, vemos una línea que dice que catorce coeficientes “no fueron definidos por singularidades”. Esta afirmación significa que R no pudo calcular un valor para esos coeficientes debido a algunas anomalías en los datos. (Más técnicamente, no pudo invertir la matriz utilizada en el proceso de minimización de mínimos cuadrados).

    El primer paso para resolver este problema es notar que se eliminaron 72 observaciones por “faltas”, dejando sólo cuatro grados de libertad. Utilizamos la función nrow (int92.dat) para determinar que hay 78 filas totales en este marco de datos. Estas 78 observaciones separadas suman los dos predictores utilizados en el modelo, más cuatro grados de libertad, más 72 filas eliminadas. Sin embargo, cuando intentamos desarrollar el modelo usando lm (), algunos de nuestros datos permanecieron sin usar.

    Para determinar por qué se excluyeron estas filas, debemos hacer un poco de comprobación de cordura para ver qué anomalías de datos pueden estar causando el problema. La tabla de funciones () proporciona una manera rápida de resumir un vector de datos, para ver si algo parece obviamente fuera de lugar. Ejecutando esta función en la columna del reloj, obtenemos lo siguiente:

    > table(clock)
    clock
    48  50  60  64  66  70  75  77  80  85  90  96  99 100 101 110
        118 120 125 133 150 166 175 180 190 200 225 231 233 250 266
        275 291 300 333 350
    1   3   4   1   5   1   4   1   2   1   2   1   2  10   1   1
    1   3   4   4   3   2   2   1   1   4   1   1   2  2    2   1    1   1   1   1
    
    

    La línea superior muestra los valores únicos que aparecen en la columna. La lista de números directamente debajo de esa línea es el recuento de cuántas veces ese valor en particular apareció en la columna. Por ejemplo, 48 aparecieron una vez, mientras que 50 aparecieron tres veces y 60 aparecieron cuatro veces. Vemos un rango razonable de valores con valores mínimo (48) y máximo (350) que no son inesperados. Algunos de los valores ocurren solo una vez; el valor más frecuente ocurre diez veces, lo que de nuevo no parece irrazonable. En definitiva, no vemos nada obviamente malo con estos resultados. Concluimos que el problema probablemente es con una columna de datos diferente.

    La ejecución de la función table () en la siguiente columna en los hilos del marco de datos produce esta salida:

    > table(threads)
    threads
     1
    78
    

    ¡Ajá! Ahora estamos llegando a alguna parte. Este resultado muestra que todas las 78 entradas de esta columna contienen el mismo valor: 1. Un factor de entrada en el que todos los elementos tienen el mismo valor no tiene poder predictivo en un modelo de regresión. Si cada fila tiene el mismo valor, no tenemos forma de distinguir una fila de otra. Así, concluimos que los hilos no son un predictor útil para nuestro modelo y lo eliminamos como predictor potencial a medida que continuamos desarrollando nuestro modelo de regresión Int1992.

    Seguimos ejecutando table () en la columna etiquetada núcleos. Esta operación muestra que esta columna también consta de un solo valor, 1. El uso de la función update () para eliminar estos dos predictores del modelo da lo siguiente:

    > int92.lm <update(int92.lm, .~. threads cores) 
    > summary(int92.lm)
    Call:
    lm(formula = nperf ~ clock + transistors + dieSize + voltage +
        featureSize + channel + FO4delay + L1icache + sqrt(L1icache) +
        L1dcache + sqrt(L1dcache) + L2cache + sqrt(L2cache))
    
    Residuals:
         14      15      16      17      18      19
       0.4096  1.3957 -2.3612  0.1498  -1.5513  1.9575
    
    Coefficients: (12 not defined because of singularities)
                        Estimate        Std. Error        t value        Pr(>|t|)
    (Intercept)        -25.93278        6.56141            -3.952        0.0168 *
    clock                0.35422        0.02184            16.215      8.46e-05 ***
    transistors               NA             NA                NA            NA
    dieSize                   NA             NA                NA            NA
    voltage                   NA             NA                NA            NA
    featureSize               NA             NA                NA            NA
    channel                   NA             NA                NA            NA
    FO4delay                  NA             NA                NA            NA
    L1icache                  NA             NA                NA            NA
    sqrt(L1icache)            NA             NA                NA            NA
    L1dcache                  NA             NA                NA            NA
    sqrt(L1dcache)            NA             NA                NA            NA
    L2cache                   NA             NA                NA            NA
    sqrt(L2cache)             NA             NA                NA            NA
    ---
    Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
    
    Residual standard error: 1.868 on 4 degrees of freedom (72 observations deleted due to missingness)
    Multiple R-squared: 0.985, Adjusted R-squared: 0.9813 F-statistic: 262.9 on 1 and 4 DF, p-value: 8.463e-05
    
    

    Desafortunadamente, la eliminación de estos dos predictores de la consideración no ha resuelto el problema. Observe que todavía tenemos sólo cuatro grados de libertad, porque de nuevo se eliminaron 72 observaciones. Este pequeño número de grados de libertad indica que debe haber al menos una columna más con datos insuficientes.

    Al ejecutar table () en las columnas restantes, encontramos que la columna etiquetada L2cache tiene solo tres valores únicos, y que estos aparecen en un total de solo diez filas:

    > table(L2cache)
    L2cache
    96 256 512 
     6   2   2
    

    Aunque estos valores de datos específicos no parecen fuera de lugar, tener solo tres valores únicos puede hacer imposible que lm () calme los coeficientes del modelo. La caída de L2cache y sqrt (L2cache) como predictores potenciales finalmente produce el tipo de resultado que esperamos:

    > int92.lm <update(int92.lm, .~. L2cache sqrt(L2cache)) 
    > summary(int92.lm)
    
    Call:
    lm(formula = nperf ~ clock + transistors + dieSize + voltage +
        featureSize + channel + FO4delay + L1icache + sqrt(L1icache) +
        L1dcache + sqrt(L1dcache))
    
    Residuals:
        Min      1Q      Median      3Q         Max
    -7.3233   -1.1756    0.2151    1.0157      8.0634
    
    Coefficients:
                        Estimate        Std. Error        t value        Pr(>|t|)
    (Intercept)        -58.51730        17.70879           -3.304         0.00278 **
    clock                0.23444         0.01792           13.084        6.03e-13 ***
    transistors         -0.32032         1.13593           -0.282         0.78018
    dieSize              0.25550         0.04800            5.323        1.44e-05 ***
    voltage              1.66368         1.61147            1.032         0.31139
    featureSize        377.84287        69.85249            5.409        1.15e-05 ***
    channel           -493.84797        88.12198           -5.604        6.88e-06 ***
    FO4delay             0.14082         0.08581            1.641         0.11283
    L1icache             4.21569         1.74565            2.415         0.02307 *
    sqrt(L1icache)     -12.33773         7.76656           -1.589         0.12425
    L1dcache            -5.53450         2.10354           -2.631         0.01412 *
    sqrt(L1dcache)      23.89764         7.98986            2.991         0.00602 **
    ---
    Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
    Residual standard error: 3.68 on 26 degrees of freedom (40 observations deleted due to missingness)
    Multiple R-squared: 0.985, Adjusted R-squared: 0.9786 F-statistic: 155 on 11 and 26 DF, p-value: < 2.2e-16
    

    Ahora podemos proceder con el proceso normal de eliminación hacia atrás. Comenzamos eliminando el predictor que tiene el mayor valor p por encima de nuestro umbral preseleccionado, que son los transistores en este caso. La eliminación de este predictor da lo siguiente:

    > int92.lm <update(int92.lm, .~. -transistors) 
    > summary(int92.lm) 
    
    Call:
    lm(formula = nperf ~ clock + dieSize + voltage + featureSize +
        channel + FO4delay + L1icache + sqrt(L1icache) + L1dcache +
        sqrt(L1dcache))
    
    Residuals:
         Min       1Q       Median        3Q        Max
      -13.2935  -3.6068     -0.3808     2.4535    19.9617
    
    Coefficients:
                        Estimate         Std. Error         t value         Pr(>|t|)
    (Intercept)        -16.73899           24.50101            -0.683            0.499726
    clock                0.19330            0.02091            9.243        2.77e-10 ***
    dieSize            0.11457            0.02728            4.201          0.000219 ***
    voltage            0.40317            2.85990            0.141            0.888834
    featureSize        11.08190            104.66780          0.106            0.916385
    channel            -37.23928            104.22834        -0.357            0.723379
    FO4delay            -0.13803            0.14809           -0.932        0.358763
    L1icache            7.84707            3.33619            2.352        0.025425 *
    sqrt(L1icache)       -16.28582        15.38525            -1.059        0.298261
    L1dcache            -14.31871         2.94480            -4.862        3.44e-05 ***
    sqrt(L1dcache)       48.26276        9.41996            5.123            1.64e-05 ***
    ---
    Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
    Residual standard error: 7.528 on 30 degrees of freedom (37 observations deleted due to missingness)
    Multiple R-squared: 0.9288, Adjusted R-squared: 0.9051 F-statistic: 39.13 on 10 and 30 DF, p-value: 1.802e-14
    
    
    

    Después de eliminar este predictor, sin embargo, vemos algo inesperado. Los valores p para voltaje y FeatureSize aumentaron drásticamente. Además, el valor R cuadrado ajustado cayó sustancialmente, de 0.9786 a 0.9051. Estos cambios inesperadamente grandes nos hacen sospechar que los transistores pueden ser realmente un predictor útil en el modelo aunque en esta etapa del proceso de eliminación hacia atrás tenga un alto valor p. Entonces, decidimos volver a poner los transistores en el modelo y en su lugar caer voltaje, que tiene el siguiente valor p más alto. Estos cambios producen el siguiente resultado:

    > int92.lm <update(int92.lm, .~. +transistors -voltage) 
    > summary(int92.lm)
    
    Call:
    lm(formula = nperf ~ clock + dieSize + featureSize + channel +
    FO4delay + L1icache + sqrt(L1icache) + L1dcache +
    sqrt(L1dcache) +
    transistors)
    
    Residuals:
          Min         1Q        Median        3Q        Max
     -10.0828    -1.3106        0.1447    1.5501     8.7589
    
    Coefficients:
                        Estimate        Std. Error        t value        Pr(>|t|)
    (Intercept)        -50.28514          15.27839         -3.291        0.002700 **
    clock                0.21854           0.01718         12.722        3.71e-13 ***
    dieSize              0.20348           0.04401          4.623        7.77e-05 ***
    featureSize        409.68604          67.00007          6.115        1.34e-06 ***
    channel           -490.99083          86.23288         -5.694        4.18e-06 ***
    FO4delay             0.12986           0.09159          1.418        0.167264
    L1icache             1.48070           1.21941          1.214        0.234784
    sqrt(L1icache)      -5.15568           7.06192         -0.730        0.471413
    L1dcache            -0.45668           0.10589         -4.313        0.000181 ***
    sqrt(L1dcache)       4.77962           2.45951          1.943        0.062092 .
    transistors          1.54264           0.88345          1.746        0.091750 . 
    ---
    Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
    
    Residual standard error: 3.96 on 28 degrees of freedom (39 observations deleted due to missingness)
    Multiple R-squared: 0.9813, Adjusted R-squared: 0.9746 F-statistic: 146.9 on 10 and 28 DF, p-value: < 2.2e-16
    
    

    El valor R cuadrado ajustado ahora es 0.9746, que está mucho más cerca del valor R cuadrado ajustado que teníamos antes de dejar caer los transistores. Continuando con el proceso de eliminación hacia atrás, primero bajamos sqrt (L1iCache) con un valor p de 0.471413, luego FO4Delay con un valor p de 0.180836, y finalmente sqrt (L1dCache) con un valor p de 0.071730.

    Después de completar este proceso de eliminación hacia atrás, encontramos que los siguientes predictores pertenecen al modelo final para Int1992:

    transistores de reloj DieSize FeatureSize

    canal L1iCache L1DCache

    Como se muestra a continuación, todos estos predictores tienen valores p por debajo de nuestro umbral de 0.05. Adicionalmente, el R-cuadrado ajustado se ve bastante bien en 0.9722.

    > int92.lm <update(int92.lm, .~. -sqrt(L1dcache)) 
    > summary(int92.lm)
    
    Call:
    lm(formula = nperf ~ clock + dieSize + featureSize + channel +
    L1icache + L1dcache + transistors, data = int92.dat)
    
    Residuals:
         Min       1Q       Median       3Q       Max
    -10.1742  -1.5180       0.1324   1.9967   10.1737
    
    Coefficients:
                    Estimate        Std. Error        t value        Pr(>|t|)
    (Intercept)    -34.17260           5.47413         -6.243        6.16e-07 ***
    clock            0.18973           0.01265         15.004        9.21e-16 ***
    dieSize          0.11751           0.02034          5.778        2.31e-06 ***
    featureSize    305.79593          52.76134          5.796        2.20e-06 ***
    channel       -328.13544          53.04160         -6.186        7.23e-07 ***
    L1icache         0.78911           0.16045          4.918        2.72e-05 ***
    L1dcache        -0.23335           0.03222         -7.242        3.80e-08 ***
    transistors      3.13795           0.51450          6.099        9.26e-07 ***
    ---
    Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
    
    Residual standard error: 4.141 on 31 degrees of freedom (39 observations deleted due to missingness)
    Multiple R-squared: 0.9773, Adjusted R-squared: 0.9722 F-statistic: 191 on 7 and 31 DF, p-value: < 2.2e-16
        
        
                
    

    Este ejemplo ilustra que no siempre se pueden mirar solo los valores p para determinar qué predictores potenciales eliminar en cada paso del proceso de eliminación hacia atrás. También hay que tener cuidado de mirar el panorama más amplio, como los cambios en el valor R cuadrado ajustado y grandes cambios en los valores p de otros predictores, después de cada cambio al modelo.


    This page titled 4.6: Cuando las cosas salen mal is shared under a CC BY-NC 4.0 license and was authored, remixed, and/or curated by David Lilja (University of Minnesota Libraries Publishing) via source content that was edited to the style and standards of the LibreTexts platform; a detailed edit history is available upon request.