Fernando Rondón Puma - Regresión Lineal - Vehiculos

18/11/22, 19:26 Fernando Rondón Puma - Regresión lineal - Vehiculos.
ipynb - Colaboratory
Te damos la bienvenida la segunda parte de este ejercicio

de regresión.
Este ejercicio continuará donde terminó el anterior, para esto es
necesario
El primer paso es conseguir un dataset o conjunto de datos, para esto podemos recurri al sitio
Kaggle.com, el cual entre otras cosas ofrece datasets abiertos.
En este caso usaremos el dataset kc_house_data (https://www.kaggle.com/shivachandel/kc-

house-data) ,el cual contiene datos de distintas casas en Washington, EEUU.
Puedes descargar el conjunto de datos desde este enlace:

https://drive.google.com/file/d/1sIwmhhn50utRZY556ENMAa13sIxWSzHj/view?usp=sharing
Una vez lo tengas descargado es importante que sepas donde lo dejaste guardado.
Esta segunda parte del ejercicio contiene todo lo de la primera, una vez llegues a una celda que
dice "Comienza la segunda parte" es donde está todo lo nuevo.
1 !jupyter nbconvert --to html "Fernando Rondón Puma - Regresión lineal - Vehiculos.ipynb
[NbConvertApp] WARNING | pattern 'Fernando Rondón Puma Lab 1.ipynb' matched no fi

This application is used to convert notebook files (*.ipynb)
to various other formats.
WARNING: THE COMMANDLINE INTERFACE MAY CHANGE IN FUTURE RELEASES.
Options
=======
The options below are convenience aliases to configurable class-options,
as listed in the "Equivalent to" description-line of the aliases.
To see all configurable class-options for some <cmd>, use:
<cmd> --help-all
--debug
set log level to logging.DEBUG (maximize logging output)
Equivalent to: [--Application.log_level=10]
--show-config
Show the application's configuration (human-readable format)
Equivalent to: [--Application.show_config=True]
--show-config-json
Show the application's configuration (json format)
Equivalent to: [--Application.show_config_json=True]
--generate-config
generate default config file
Equivalent to: [--JupyterApp.generate_config=True]
-y
Answer yes to any questions instead of prompting.
Equivalent to: [--JupyterApp.answer_yes=True]
https://colab.research.google.com/drive/1itk6qi-8I4lquS7cxX-ifWERFc-CMG0H#scrollTo=wLMTDC1ZRZAC&printMode=true 1/17
18/11/22, 19:26 Fernando Rondón Puma - Regresión lineal - Vehiculos.ipynb - Colaboratory
--execute
Execute the notebook prior to export.
Equivalent to: [--ExecutePreprocessor.enabled=True]
--allow-errors
Continue notebook execution even if one of the cells throws an error and incl
Equivalent to: [--ExecutePreprocessor.allow_errors=True]
--stdin
read a single notebook file from stdin. Write the resulting notebook with def
Equivalent to: [--NbConvertApp.from_stdin=True]
--stdout
Write notebook output to stdout instead of files.
Equivalent to: [--NbConvertApp.writer_class=StdoutWriter]
--inplace
Run nbconvert in place, overwriting the existing notebook (only
relevant when converting to notebook format)
Equivalent to: [--NbConvertApp.use_output_suffix=False --NbConvertApp.export_

--clear-output
Clear output of current file and save in place,
overwriting the existing notebook.
Equivalent to: [--NbConvertApp.use_output_suffix=False --NbConvertApp.export_

--no-prompt
Exclude input and output prompts from converted document.
Equivalent to: [--TemplateExporter.exclude_input_prompt=True --TemplateExport

--no-input
Exclude input cells and output prompts from converted document.
This mode is ideal for generating code-free reports.
Equivalent to: [--TemplateExporter.exclude_output_prompt=True --TemplateExport

--log-level=<Enum>
¿Como ejecutar el código?
Toda celda de código en Google Colab tiene un botón de ejecutar arriba a la izquierda, cada vez
que lo clickees se ejecutará todo el cógido de la celda.
1
#<---- Boton para correr este bloque de codigo
3
import pandas as pd
4
# Este codigo permite importar la libreria pandas, la cual sera util para manejar los d
5
#"as pd" singifica que para usar funciones de pandas debemos escribir pd.nombre_de_func
6
7
from google.colab import files #estas dos lineas de codigo permiten subir el archivo vs
8
uploaded = files.upload()
10
11
import io # No preocuparse por esta linea, lo importante es que nos permite leer vsc qu
12
df = pd.read_csv(io.BytesIO(uploaded['car data.csv']))# esta linea se encagarga de cont
13
# |
14
# |
15
# | Deberia aparecer un boton de "Examinar..." para subir el archivo con el dataset una
16
# |
17
# ↓
Elegir archivos car data.csv

car data.csv(text/csv) - 17209 bytes, last modified: 24/10/2020 - 100% done
Saving car data.csv to car data (2).csv
Antes de hacer cualquier otra cosa es importante examinar y entender el dataset, por eso se
utilizaran algunas funciones de ejemplo. Como describe, head, shape y dtypes
1
df.describe() # la funcion describe nos muestra un buen resumen del dataset
Year Selling_Price Present_Price Kms_Driven Owner
count 301.000000 301.000000 301.000000 301.000000 301.000000
mean 2013.627907 4.661296 7.628472 36947.205980 0.043189
std 2.891554 5.082812 8.644115 38886.883882 0.247915
min 2003.000000 0.100000 0.320000 500.000000 0.000000
25% 2012.000000 0.900000 1.200000 15000.000000 0.000000
50% 2014.000000 3.600000 6.400000 32000.000000 0.000000
75% 2016.000000 6.000000 9.900000 48767.000000 0.000000
max 2018.000000 35.000000 92.600000 500000.000000 3.000000
1
df.head() # la funcion head nos muestra los primeros 5 elementos del dataset
Car_Name Year Selling_Price Present_Price Kms_Driven Fuel_Type Seller_Type
0 ritz 2014 3.35 5.59 27000 Petrol Dealer
1 sx4 2013 4.75 9.54 43000 Diesel Dealer
2 ciaz 2017 7.25 9.85 6900 Petrol Dealer
3 wagon r 2011 2.85 4.15 5200 Petrol Dealer
4 swift 2014 4.60 6.87 42450 Diesel Dealer
1
df.shape # la funcion shape nos da la forma del dataset en este formato (Cantidad de fi
2
3
#Las cantidad de filas representa la cantidad de casas del dataset
4
#La cantidad de columnas representa la cantidad de atributos o datos que tiene cada cas
(301, 9)
1
df.dtypes # la funcion dtypes nos muestra los tipos de variables del dataset, podemos v
Car_Name object
Year int64
Selling_Price float64
Present_Price float64
Kms_Driven int64
Fuel_Type object
Seller_Type object
Transmission object
Owner int64
dtype: object
1
correlations = df.corr()['Selling_Price']
3
# la funcion corr nos permite obtener las correlaciones entre las distintas variables
4
# En este caso selecionamos del dataframe la variable "Selling_Price" (precio de venta)
5
# obtendremos las relaciones entre esta variable y las demas
6
# Entre mas cercano a 1 sea el valor mayor es la correlacion y mejor es la variable par
7
8
print(correlations) # imprimimos los valores
10
#Present_Price (precio actual del vehiculo) deberia dar el valor de mayor correlacion c
11
Year 0.236141
Selling_Price 1.000000
Present_Price 0.878983
Kms_Driven 0.029187
Owner -0.088344
Name: Selling_Price, dtype: float64
Al igual que con el R2, entre más cercano a 1 sea el valor de correlación mejor.
Al usar la función shape la consola debería haber mostrado que el dataset contiene 301, lo cual
puede ser una cantidad incomoda para visualizar en gráficas como haremos más adelante. Por
este motivo en el siguiente bloque de codigo vamos a "achicar el dataset", dejando solo 15
casas para analizar. Más adelante usaremos todo el dataset y podremos comparar resultados.
1
df_min = df.sample(15, random_state=10) #creamos un nuevo dataset al cual copiamos 15 v
2
# random_state=10 es un valor que deberias mantener igual si quieres obtener las mismas
3
# si pongo otro valor como random state el conjunto de 15 datos seria diferente
5
from sklearn.linear_model import LinearRegression # Sklearn es la libreria de machine l
6
X = df_min['Present_Price'].values.reshape(-1,1) # Definimos como X los valores de la c
7
# ".values.reshape(-1,1)" es necesario para luego utilizar la funcion fit, es sencillam
8
9
y = df_min['Selling_Price'].values.reshape(-1,1) # Definimos como Y la columna que con
10
1
import matplotlib.pyplot as plt # Esta libreria tiene herramientas para graficar
4
# Ahora que tenemos un conjunto de datos mas pequeño deberia ser facil graficarlo
6
plt.scatter(X,y) # Genera una grafica de puntos
8
plt.title('Demostración de Regresión Lineal') # Agrego un titulo
9
plt.ylabel('Precio de venta del vehiculo') # defino un nombre del eje y
10
plt.xlabel('Precio actual del vehiculo') # defino un nombre del eje x
Text(0.5, 0, 'Precio actual del vehiculo')
1
reg = LinearRegression().fit(X,y)
2
# La funcion fit relaciona los valores de X e y, mientras que Linear Regression calcula
3
# la recta (y = mx + b) obtenida se guarda en la variable reg
Matematicamente, los valores obtenidos a través de la recta se representan matemáticamente

así: ŷ, para diferenciarlo de la y común, la cual en este caso contiene los valores de precios.
Como a ŷ se le suele decir "y con sombrero" (en inglés "hat" es "sombrero") llamaremos a la
variable que contiene los valores predecidos y_hat, lo cual seria como llamarla y_con_sombrero
1
y_hat = reg.predict(X) # Sustituimos en la recta (y = mx + b) nuestros valores iniciale
2
print(y_hat) # guardamos los resultados en y_hat
[[ 7.87551953]
[ 0.77227448]
[ 2.75470529]
[ 0.81136467]
[ 3.51975606]
[ 5.6082888 ]
[20.36204149]
[ 0.69967843]
[ 0.73876861]
[ 4.18987352]
[ 0.74435292]
[ 8.09889202]
[ 4.07818727]
[ 0.81136467]
[ 4.52493224]]
1
3
# Recreamos la misma grafica pero ahora se muestra la recta obtenida
5
plt.scatter(X,y)
6
plt.plot(X, y_hat, color='green')
8
plt.title('Demostración de Regresión Lineal') # Agrego un titulo
9
plt.ylabel('Precio de venta del vehiculo') # defino un nombre del eje y
10
plt.xlabel('Precio actual del vehiculo') # defino un nombre del eje x
1
3
# Recreamos la misma grafica pero ahora se muestra la recta obtenida
5
plt.scatter(X,y) # Grafica de dispersion, muestra los puntos iniciales
7
plt.scatter(X,y_hat, color='red')
9
# grafica de dispersion, muestra los puntos que se obtienen al sustituir nuestros valor
10

11
plt.plot(X, y_hat, color='green') # Dibuja la linea de regresion
12
13
14
plt.title('Demostración de Regresión Lineal') # asigna titulo a la grafica
15
plt.ylabel('Precio de venta del vehiculo') # asigna nombre al eje y de la grafica
16
plt.xlabel('Precio actual del vehiculo') # asigna nombre al eje x de la grafica
17
18
# No preocuparse demasiado por esta parte, al igual que las otras graficas no es necesa
19
# pero ayuda a visualizar que esta pasando
20
21
# Esto es un loop, el cual recorre todos los valores de los conjuntos X, y, y_hat
22
# a medida que los recorre va dibujando lineas punteadas para ilustrar el error de la r
23
for i in range(0, len(X)):
24
point1 = [X[i], y[i]]
25
point2 = [X[i], y_hat[i]]
26
27
x_values = [point1[0], point2[0]]
28
y_values = [point1[1], point2[1]]
29
30
plt.plot(x_values, y_values, color='red', linestyle='dashed')
31
32
En este momento en la variable y tenemos los valores de precios originales, mientras que en
y_hat tenemos los valores de precios obtenidos mediante la regresión lineal. Si comparamos la
diferencia entre estos valores podemos obtener el R2 de la recta.
1
from sklearn.metrics import r2_score
2
r2_score(y, y_hat)
3
# |
4
# |
5
# | Deberia aparecer el r2 una vez ejecutes este codigo
6
# |
7
# ↓
0.9843525074921549
Al momento de escribir este texto el R2 obtenido es de 0.9843525074921549, o sea, un gran

modelo. :)
Pero es momento de recordar que de los miles de datos del dataset utilizamos solo
15. ¿Qué sucede si los usamos todos?
1
# Defino nuevos valores de X e y pero con un 1 al final para no repetir nombres de vari
2
3
X1 = df['Present_Price'].values.reshape(-1,1)
4
y1 = df['Selling_Price']
6
# vuelvo a usar las herramientas de regresion
8
reg = LinearRegression().fit(X1,y1)
9
y_hat1 = reg.predict(X1)
10
11
# Y grafico nuevamente
12
plt.scatter(X1,y1)
13
plt.plot(X1, y_hat1, color='green')
14
plt.title('Demostración de Regresión Lineal')
15
plt.ylabel('Precio de venta del vehiculo')
16
plt.xlabel('Precio actual del vehiculo')
Ahora que tengo todos los datos la recta ya no parece tan representativa, ¿No?
Veamos su valor de R2
1
r2_score(y1, y_hat1)
2
# |
3
# |
4
# | Deberia aparecer el r2 una vez ejecutes este codigo
5
# |
6
# ↓
0.7726103146985799
El valor de R2 obtenido deberia ser de 0.7726103146985799, un valor mucho menor. ¿Por qué
sucede esto? La respuesta es bastante sencilla, con el primer conjunto de datos tuvimos
"suerte" de que los pocos valores caian cerca de la recta. Pero al utilizar todos los datos del
dataset se mostró que una recta que considera solo dos variables no es suficiente para
predecir de forma adecuada el precio de venta de los vehiculos, resulta que hay muchos otros
factores que afectan.
Comienza la segunda parte del ejercicio
En esta segunda parte del ejercicio vamo a separar los datos en un conjunto de entrenamiento
y otro de validación de forma de evaluar de forma correcta su presición, utilizaremos multiples
variables para hacer la regresion y recurriremos tambien a regresiones no lineales.
Volvemos a utilizar las variables de la primera parte

Anteriormente utilizamos la variable de sueperficien en pies cuadrados para intentar predecir el

precio mediante una regresion lineal. Ahora volveremos a utilizar estar variables pero para
realizar una regresión polinómica.
1
X = df['sqft_living'].values.reshape(-1,1) # Definimos como X los valores de la columna
2
# ".values.reshape(-1,1)" es necesario para luego utilizar la funcion fit, es sencillam
3
4
y = df['price'].values.reshape(-1,1) # Definimos como Y la columna que contiene los pr
5
Separación del dataset en conjuntos de entrenamiento y

validación
Primero vamos a separar nuestros datos en los conjuntos de entrenamiento y validación. De
esta forma podemos evaluar los resultados de nuestro modelo al enfrentarlo a datos que nunca
ha visto.
1
from sklearn.model_selection import train_test_split
3
#Sklearn tiene una libreria que nos permite separar facilmente el dataset
5
#Igualamos las variables a los resultados de la funcion train_test_split
6
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1
7
8
#con la funcion len podemos ver la cantidad de elementos en cada variable, asi podemos
9
print("Cantidad de valores en conjunto X: ", len(X))
10
print("Cantidad de valores de X en conjunto entrenamiento: ",len(X_train))
11
print("Cantidad de valores x en conjunto de validacion: ",len(X_test))
12
print("Cantidad de valores y en conjunto de entrenamiento: ",len(y_train))
13
print("Cantidad de valores y en conjunto de validacion: ",len(y_test))
14
15
Cantidad de valores en conjunto X: 21613
Cantidad de valores de X en conjunto entrenamiento: 17290
Cantidad de valores x en conjunto de validacion: 4323
Cantidad de valores y en conjunto de entrenamiento: 17290
Cantidad de valores y en conjunto de validacion: 4323
X_train, X_test, y_train, y_test deja definidas 4 variables. X contiene los valores de
"sqft_living" (superficie en pies cuadrados), mientras que y contiene los valores de "price"
(precio). La X_train contendrá los valores de "sqft_living" que se usaran para entrenar el modelo,
mientras que la variable X_test contendrá los valores de "sqft_living" que se utilizaran para
evaluar el modelo. Lo mismo sucede con y_train e y_test.
train_test_split es la variable que facilmente nos permite separar en los conjuntos de

entrenamiento y validación. Si quieres saber más de su funcionamiento te dejamos el siguiente
enlace
.
La función train_test_split está aceptando 4 argumentos, los cuales sirven para ajustar
parámetros.
train_test_split(X, y, test_size=0.2, random_state=1)
Lo primero que colocamos entre paréntesis son las variables X e y (separadas con comas,
como debe ser al ingresar argumentos en una función). Esto le indica a la funcion
train_test_split que estos son los datos que queremos separar.
Luego tenemos test_size=0.2 esto indica que queremos usar el 20% de los datos del dataset
para el conjunto de evaluación. Lo cual automáticamente deja un 80% de los datos para el
entrenamiento.
Finalmente tenemos random_state=1 . La función train_test_split automáticamente elige los

datos para cada conjunto de forma al azar (lo cual es bastante útil para evitar sesgos). Pero
puede ser incómodo a la hora de querer obtener los mismos resultados al correr la misma línea
de código varias veces o en distintas computadoras por distinta gente. Asignarle un número al
random_state nos asegura que siempre que usemos ese mismo número el dataset será
dividido de la misma forma, es decir, siempre serán los mismos datos los que estarán en el
conjunto de entrenamiento y siempre serán los mimos datos que estarán en el conjunto de
validación.
Regresión polinómica
Con los datos ya separados es momento de hacer la regresión polinómica. Esta funciona de
una manera muy similar a la regresión lineal, incluso se usa la misma funcion de
LinearRegression, solo que antes se aplica una transformacion polinomial a los datos. No te
preocupes si esto suena confuso ya que Python se encarga de toda esta matemática, por lo
que basta con entender los conceptos sencillos que ya vimos.
Lo único que es necesario entender es que para realizar una regresión lineal tenemos que
guardar nuestros datos en variables X e y para luego utilizar la función LinearRegression.
Mientras que para obtener una regresión polinomica tenemos que guardar nuestros datos en
variables X e y, luego utilizar la funcion poly.fit_transform() en nuestros datos y finalmente
utilizar la función LinearRegression.
Primero vamos a visualizar nuestros datos iniciales

[ ] ↳ 2 celdas ocultas
Momento de visualizar y evaluar nuestra regresion

Primera ronda de conclusiones

De acuerdo al codigo que tenemos deberías haber obtenido esta gráfica:
Y estos valores de R2
R2 en entrenamiento 0.48876078213887486
R2 en Validacion 0.5033019006466926
Lo cual podría llegar a ser decepcionante. Primero que nada se supone que la ventaja de la
regresion polinomial era obtener lineas curvas en lugar de una recta y en segundo lugar de
acuerdo al anterior artículo ya sabemos que un valor de R2 de 0,5 en validación no es muy útil.
Pero todo tiene una explicación, la razón por la cual obtuvimos una recta es sencilla.
poly = PolynomialFeatures(degree=1) # Definimos el grado de nuestro polinomio
En esa línea definimos que el valor del grado sea igual a 1, lo que hace imposible obtener algo
que no sea una recta. También es fácil ver como una recta no es una gran opción a la hora de
representar esa nube de puntos, explicando el bajo valor de R2.
¿Qué vamos a hacer entonces? Probar con grados mayores hasta encontrar el que nos de un
mejor valor de R2.
Para eso vamos a dejar en un solo bloque de código todo lo necesario para definir el grado,
realizar la regresión, graficar y obtener el R2. De forma de que sea sencillo copiar y pegar ese
bloque cambiando solo el valor del grado del polinomio.
Probando mayores grados
Probando con segundo grado

[ ] ↳ 1 celda oculta
Probando con tercer grado

Probando con cuarto grado

Probando con quinto grado

Evaluando cual fue el mejor grado

Los valores de R2 en validacion fueron los siguientes
1er grado: 0.5033019006466926
2do grado: 0.5347821529762214
3er grado: 0.5567301336665487
4to grado: 0.4916701115322405
5to grado: -0.3506081588896566
Mientras que los resultados en entrenamiento fueron los siguientes
1er grado: 0.48876078213887486
2do grado: 0.5293536454616734
3er grado: 0.5296718833368512
4to grado: 0.529853175688838
5to grado: 0.5307110101455799
Podemos ver que los valores de R2 en entrenamiento fueron mejorando levemente cada vez
que subiamos el grado del polinomio, mientras que los resultdos de R2 en validacion subieron
hasta el tercer grado para luego bajar a su peor resultado hasta el momento en el 4to grado y
para el 5to el resultado de R2 ya era negativo (o sea, inutilizable). Este fenómeno se conoce
como "overfitting" o sobreajuste. Básicamente al aumentar el grado del polinomio estamos
aumentando la complejidad del modelo, lo cual puede llegar a dar mejores resultados. Pero
luego de cierto punto de complejidad el modelo deja de "aprender" y pasa a "memorizar", por lo
que nos da cada vez mejores valores de entrenamiento pero al enfrentarlo a datos que no ha
visto antes los resultados obtenidos de R2 son desastrosos, porque haber "memorizado" ahora
no sirve para nada.
Podríamos decir entonces que lo mejor es utilizar el modelo polinomial de tercer grado, pero
aún así un valor de R2 de 0,55 no es nada demasiado útil. ¿Qué podemos hacer para seguir
mejorando? La respuesta está en utilizar más variables.
Utilizando más variables

Lo primero es examinar nuevamente los valores de correlacion, para esto recurrimos una vez
más a funcion corr
1
correlations = df.corr()['price'].sort_values() # una vez mas utilizamos la fucion corr
2
3
#la variable correlations tiene ahora guardadas todas las correlaciones de "price" con
4
5
plt.figure(figsize=(25,10)) #Definimos un buen tamaño para la gráfica
6
plt.xlabel('variables', fontsize=25) # le damos nombres a los ejes y asignamos un tamañ
7
plt.ylabel('correlacion con "Price"', fontsize=25)
8
plt.grid(True) # con esto nos aseguramos de que la gráfica esté cuadriculada
10
correlations = correlations.round(decimals=2) # con esto redondeamos el valor de las co
11
plt.rc('font', size=12) # ajustamos el tamaño de la fuente por defecto
12
# assign your bars to a variable so their attributes can be accessed
13
bars = plt.bar(correlations.index,correlations) #hacemos un diagrama de barras con las
14
#correlations.index tiene los nombres de las variables
15
16
# estas lineas de codigo hacen que cada barra tenga encima escrito el numero de correla
17
for bar in bars:
18
yval = bar.get_height()
19
plt.text(bar.get_x(), yval + .005, yval, fontsize=14)
20
21
plt.show
<function matplotlib.pyplot.show>
Podemos veer que hay una variable con una correlacion de 0.67, una diferencia bastante
mínima de la variable que utilizamos en el anterior ejercicio (0,7).
Vamos entonces a usar estas
dos variables a la vez para nuestra siguiente regresion. Veremos que usar dos variables es muy
similar a usar una sola. Literalmente cambia solo una línea de código.
Un detalle importante es que de ahora en adelante vamos a estar trabajando al menos con
datos tridimensionales (o de más dimensiones si seguimos utilizando más variables) por lo
cual se hace cada vez más difícil graficar como veníamos haciendo, por lo cual nos guiaremos
únicamente por los valores de R2.
Volvemos a definir X e y pero esta vez con una variable más

Utilizando 4 variables
De acuerdo a la gráfica que hicimos un par de celdas atrás, hay una variable que tiene un valor
de correlacion de 0,61, lo cual podría llegar a sernos útil. Vamos a entonces repetir el mismo
código pero agreando una variable más.
Volvemos a definir X e y pero esta vez con 4 variables en total

La nueva variable se llama "sqft_above" y hace referencia a la superficie en pies cuadrados del
segundo piso de cada casa.
Utilizando 5 variables
De acuerdo a la gráfica que hicimos un par de celdas atrás, hay una variable que tiene un valor
de correlacion de 0,61, lo cual podría llegar a sernos útil. Vamos a entonces repetir el mismo
código pero agreando una variable más.
Volvemos a definir X e y pero esta vez con 5 variables en total

La nueva variable se llama "sqft_living15" y hace referencia al tamaño del living de cada casa.
Conclusiones finales
A través de este ejercicio de dos partes recorrimos por encima el uso de las herramientas de
sklearn y varias modalidades de uso de la regresión. Vimos los riesgos del sobre ajuste, la
importancia de separar los datos en entrenamiento y validación, las ventajas de considerar
múltiples variables a la vez y los riesgos de tener en cuenta demasiadas variables y también la
mentalidad que debemos tener al momento de mejorar nuestro modelo.
0,648 no es para nada un mal valor para un primer ejercicio de Machine Learning y en futuros
ejercicios es posible que volvamos a este dataset para intentar obtener mejores resultados.
Solo que esa vez probablemente sería mejor utilizar un modelo que no sea de regresión.
Productos de pago de Colab

-
Cancelar contratos
check 0 s completado a las 19:24

Fernando Rondón Puma - Regresión Lineal - Vehiculos

Cargado por

Copyright:

Formatos disponibles

Fernando Rondón Puma - Regresión Lineal - Vehiculos

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Fernando Rondón Puma - Regresión Lineal - Vehiculos

Cargado por

Copyright:

Formatos disponibles

18/11/22, 19:26 Fernando Rondón Puma - Regresión lineal - Vehiculos.

Te damos la bienvenida la segunda parte de este ejercicio

En este caso usaremos el dataset kc_house_data (https://www.kaggle.com/shivachandel/kc-

Puedes descargar el conjunto de datos desde este enlace:

[NbConvertApp] WARNING | pattern 'Fernando Rondón Puma Lab 1.ipynb' matched no fi

to various other formats.

WARNING: THE COMMANDLINE INTERFACE MAY CHANGE IN FUTURE RELEASES.

The options below are convenience aliases to configurable class-options,

as listed in the "Equivalent to" description-line of the aliases.

To see all configurable class-options for some <cmd>, use:

set log level to logging.DEBUG (maximize logging output)

Equivalent to: [--Application.log_level=10]

Show the application's configuration (human-readable format)

Equivalent to: [--Application.show_config=True]

Show the application's configuration (json format)

Equivalent to: [--Application.show_config_json=True]

generate default config file

Equivalent to: [--JupyterApp.generate_config=True]

Answer yes to any questions instead of prompting.

Equivalent to: [--JupyterApp.answer_yes=True]

Execute the notebook prior to export.

Equivalent to: [--ExecutePreprocessor.enabled=True]

Write notebook output to stdout instead of files.

Equivalent to: [--NbConvertApp.writer_class=StdoutWriter]

Run nbconvert in place, overwriting the existing notebook (only

relevant when converting to notebook format)

Equivalent to: [--NbConvertApp.use_output_suffix=False --NbConvertApp.export_

Clear output of current file and save in place,

overwriting the existing notebook.

Equivalent to: [--NbConvertApp.use_output_suffix=False --NbConvertApp.export_

Exclude input and output prompts from converted document.

Equivalent to: [--TemplateExporter.exclude_input_prompt=True --TemplateExport

Exclude input cells and output prompts from converted document.

This mode is ideal for generating code-free reports.

Equivalent to: [--TemplateExporter.exclude_output_prompt=True --TemplateExport

¿Como ejecutar el código?

Elegir archivos car data.csv

Year Selling_Price Present_Price Kms_Driven Owner

count 301.000000 301.000000 301.000000 301.000000 301.000000

mean 2013.627907 4.661296 7.628472 36947.205980 0.043189

std 2.891554 5.082812 8.644115 38886.883882 0.247915

min 2003.000000 0.100000 0.320000 500.000000 0.000000

25% 2012.000000 0.900000 1.200000 15000.000000 0.000000

50% 2014.000000 3.600000 6.400000 32000.000000 0.000000

75% 2016.000000 6.000000 9.900000 48767.000000 0.000000

max 2018.000000 35.000000 92.600000 500000.000000 3.000000

Car_Name Year Selling_Price Present_Price Kms_Driven Fuel_Type Seller_Type

0 ritz 2014 3.35 5.59 27000 Petrol Dealer

1 sx4 2013 4.75 9.54 43000 Diesel Dealer

2 ciaz 2017 7.25 9.85 6900 Petrol Dealer

3 wagon r 2011 2.85 4.15 5200 Petrol Dealer

4 swift 2014 4.60 6.87 42450 Diesel Dealer

Name: Selling_Price, dtype: float64

Text(0.5, 0, 'Precio actual del vehiculo')

Matematicamente, los valores obtenidos a través de la recta se representan matemáticamente

Text(0.5, 0, 'Precio actual del vehiculo')

Al momento de escribir este texto el R2 obtenido es de 0.9843525074921549, o sea, un gran

Text(0.5, 0, 'Precio actual del vehiculo')

Comienza la segunda parte del ejercicio

Volvemos a utilizar las variables de la primera parte