Fundamentos prácticos

1

Aplica Platzidoro en este curso y asegura el éxito de tu aprendizaje

2

Los fundamentos de machine learning que aprenderás

3

Introducción a Numpy

4

Introducción y manipulación de datos con Pandas

5

Introducción a ScikitLearn

6

Comandos básicos de las librerías usadas en el curso (Numpy, Pandas y ScikitLearn)

Regresión Lineal y Logística

7

¿Qué es la predicción de datos?

8

Sobreajuste y subajuste en los datos

9

Regresión lineal simple y regresión lineal múltiple

10

Regresión lineal simple con Scikit-Learn: división de los datos

11

Regresión lineal simple con Scikit-Learn: creación del modelo

12

Regresión logística con Scikit-Learn: definición y división de datos

13

Regresión logística con Scikit-Learn: evaluación del modelo

14

Matriz de confusión

15

PlatziDoro Cápsula 1

Árboles de decisión

16

¿Qué es un árbol de decisión y cómo se divide?

17

Comprendiendo nuestro data set para la creación de un árbol de decisión

18

Creando un clasificador con Scikit-Learn

19

Entrenamiento del modelo de clasificación

20

Visualización del árbol de decisión

K-Means

21

¿Qué es K-Means?

22

Cargando el data set de Iris

23

Construcción y evaluación del modelo con K-Means

24

Graficación del modelo

25

PlatziDoro Cápsula 2

Aprendizaje profundo

26

Introducción al aprendizaje profundo

27

Conceptos básicos de Tensor Flow

28

Red neuronal convolucional

29

Conociendo el set de datos para la creación de la red neuronal

30

Crea y entrena tu primera red neuronal convolucional con Tensor Flow

31

Evaluación de la red convolucional

32

PlatziDoro Cápsula 3

Despedida

33

Recomendaciones para analizar correctamente tu problema

34

Siguientes pasos para continuar aprendendiendo de Machine Learning

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Regresión lineal simple con Scikit-Learn: división de los datos

10/34
Recursos

Aportes 35

Preguntas 16

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Estimadísimos, para subir el CSV de salarios a su entorno de collab, en una celda aparte (o bien en la que por convención, estamos dejando para el tema de los módulos) escriban el siguente código

from google.colab import files

import io
from google.colab import files
uploaded = files.upload()

Esto les abrirá una interfaz para que puedan subir archivos, eso si, tienen que correr la celda dos veces, luego elijen el CSV y lo suben, luego la linea de código se modifica un poco, quedando de la siguiente forma para meterla en un dataframe

dataset = pd.read_csv(io.BytesIO(uploaded['salarios.csv']))

Con eso ya estaría :DD
Espero les sirva de ayuda

Tambien podemos obtener los valores de las columnas especificando su nombre

X = dataset['Aexperiencia'].values
y = dataset['Salario'].values


Es valido sustituir

x  = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 1].values

por las lineas

x = dataset["Aexperiencia"].values.reshape(30,1)
y = dataset["Salarios"].values.reshape(30,1)

Que es un poco mas intuitivo

Recordemos que en python, el segundo elemento del corchete es excluyente, es decir que el

 dataset.iloc[:, :-1].values

Significa todos los elementos excepto el elemento -1 (el ultimo).

Procedimiento de Regresión Linear Simple con Scikit-Learn:

  • Importar las librerías y modelos necesarios:
    • pandas: import pandas as pd → para manejo de datos
    • matplotlib: import matplotlib.pyplot as plt → permite insertar gráficos estadísticos
    • train_test_split: from sklearn import train_test_split → este módulo permite separar nuestros dato en datos de entrenamiento y prueba
    • LinearRegression: from sklearn import LinearRegression → El modelo en sí
  • Importar los datos (en este caso desde un archivo csv):
dataset = pd.read_csv(<nombre_archivo>)
  • Asignar los datos a sus respectivas variables:
x = dataset.iloc[<slice>]
y = dataset.iloc[<slice>] #iloc sólo admite slice notation para la selección de parte de los datos
  • Separar los datos en datos de prueba y datos de test:
X_train, X_test, Y_train, Y_test = train_test_split(x,y,test_size=0.2, random_state=0)
# test_size → porcentaje de los datos de prueba a tomar
# random_state = 0 → tipo de selección de datos (a un mismo valor devuelve la misma selección)

Caul es la diferencia entre poner

x = dataset.iloc[:, :-1].values```
y


x = dataset.iloc[:, :1].values```

??

Tengo esta duda, ya que hago la prueba y da el mismo resultado.

GRacias 😊

El parámetro random_state controla la combinación aleatoria aplicada a los datos antes de aplicar la división. El valor indica el número de veces que los valores se combinarán entre sí.

A mi me ayudó esto a entender el iloc:

Multiple row and column selections using iloc and DataFrame
data.iloc[0:5] # first five rows of dataframe
data.iloc[:, 0:2] # first two columns of data frame with all rows
data.iloc[[0,3,6,24], [0,5,6]] # 1st, 4th, 7th, 25th row + 1st 6th 7th columns.
data.iloc[0:5, 5:8] # first 5 rows and 5th, 6th, 7th columns of data frame (county -> phone1).

Single selections using iloc and DataFrame
Rows:
data.iloc[0] # first row of data frame (Aleshia Tomkiewicz) - Note a Series data type output.
data.iloc[1] # second row of data frame (Evan Zigomalas)
data.iloc[-1] # last row of data frame (Mi Richan)
Columns:
data.iloc[:,0] # first column of data frame (first_name)
data.iloc[:,1] # second column of data frame (last_name)
data.iloc[:,-1] # last column of data frame (id)

En este link: https://www.shanelynn.ie/select-pandas-dataframe-rows-and-columns-using-iloc-loc-and-ix/

con la sentencia [:,:-1]estamos seleccionando todas las columnas menos la ultima que es la variable dependiente, para este caso como solo tenemos dos columnas por eso es un poco confuso, pero lo podriamos escribir tambien:
x = dataset.iloc[0:,:1].values
y = dataset.iloc[0:,1:].value

y funciona igual, solo que es mejor usar la que tiene la profe para ser mas generales en el caso de que tengamos mas variables predictoras x

Una variante al establecer x , y es hacer

x = df.iloc[:,0]
y = df.iloc[:, 1]

Super recomendado la publicación Learning Model Building in Scikit-learn: A Python Machine Learning Library de GeeksForGeeks.

Recordemos lo que nos decía el profesor David Aroesti: cuando tengamos duda o algo no quede completamente claro, es muy válido usar un print statement para ver lo que está pasando internamente en la máquina.

Les dejo los print statements que hice de los ejercicios que hicimos en esta sesión para verlo más claro:

#Datos que van a servir para hacer las predicciones
x=dataset.iloc[:, :-1]
print(x)
y=dataset.iloc[:, 1]
print('\n')
print(y)

Salida:

Como verán, lo que hizo aquí la profesora fue asignarle a la variable “x” la porción de la tabla que corresponde a la variable independiente (es decir, los años de experiencia),
Y asignarle a la variable “y” los datos dependientes (es decir, los salarios de los programadores)

En cuanto a la división de datos:

X_train, X_test, Y_train, Y_test=train_test_split(x, y, test_size=0.2, random_state=0) 

Lo que ocurre internamente en la máquina es:

X_train
X_test

Salida:

Aquí, la profesora asignó, de la variable independiente x (los años de experiencia de los programadores), un 80% de los datos disponibles en la tabla original (verán que de 30 datos totales, solo tomó 24) para entrenamiento (X_train).

Por consiguiente, asignó 20% de los datos disponibles a las pruebas que más adelante realizaremos (X_test)

¡Espero que les haya sido de utilidad tanto como me fue a mí!😅

debo de admitir que para poder subir el archivo salarios me costo tarde un día muy muy frustrarte para que me corriera pero imagino que es como dice el dicho se aprende mas de las derrotas que de las victorias. Ya habiendo subido el archivo veo como manejar los datos.

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.2, random_state = 0)

pero quede con la duda de si el resultado de la creación de datos random pertenece a al 20% o es parte del 80%

Recomendado: 3 formas de cargar tus archivos CVS a Colab

https://towardsdatascience.com/3-ways-to-load-csv-files-into-colab-7c14fcbdcb92

The train_test_split function takes several arguments which are explained below:

  1. X, y: These are the feature matrix and response vector which need to be splitted.
  2. test_size: It is the ratio of test data to the given data. For example, setting test_size = 0.4 for 150 rows of X produces test data of 150 x 0.4 = 60 rows.
  3. random_state: If you use random_state = some_number, then you can guarantee that your split will be always the same. This is useful if you want reproducible results, for example in testing for consistency in the documentation (so that everybody can see the same numbers).

Duda:

¿Para series de tiempo se puede utilizar el mismo método para dividir los datos? Me refiero a test_split aleatorio.

Mi duda proviene de que al ser series temporales estas dependen del tiempo y por ende al dividir de forma aleatoria provocaríamos una ruptura temporal.

Gracias.

Al usar :-1 y (0 ó dataset[‘Aexperiencia’]) las dimensiones de X_train y X_test cambia.

*Index: :-1*

X_train (24, 1)
----------
X_test (6, 1)
----------
Y_train (24,)
----------
Y_test (6,)

*Index: 0 o 'Aexperiencia'*

X_train (24,)
----------
X2_test (6,)
----------
Y_train (24,)
----------
Y_test (6,)

Me pregunto, ¿Cómo afectará esto el desarrollo del ejercicio?.

A mi sale error de los salarios que tengo lo subí y nada alguien me lo envía

Muy sencillo pero muy potente

El método iloc se utiliza en los DataFrames para seleccionar los elementos en base a su ubicación. Su sintaxis es:

data.iloc[filas, columnas]

donde “filas” y “columnas” son la posición de las filas y columnas que se desean seleccionar en el orden que aparecen en el objeto. Para seleccionar las filas sería:

df.iloc[0] # Primera fila
df.iloc[1] # Segunda fila
df.iloc[-1] # Última fila

Por otro lado, para seleccionar una columna se tiene que utilizar : como primer parámetro

df.iloc[:, 0] # Primera columna
df.iloc[:, 1] # Segunda columna
df.iloc[:, -1] # Última columna

También se puede desear seleccionar un conjunto de filas o columnas en lugar de una sola

df.iloc[0:5] # Primeras cinco filas
df.iloc[:, 0:5] # Primeras cinco columnas

Lo que se hace en la clase es en “y” seleccionar la columna 1, que es la segunda ya que las columnas empiezan a contar en 0. Es decir la columna correspondiente a los salarios.

y = dataset.iloc[:, 1]

Para “x” lo que se hace es seleccionar todas las columnas excepto la última, pero como solo hay dos columnas solo selecciona la primera que sería la que corresponde a los años de experiencia.

x = dataset.iloc[:, :-1]

PARA ENTENDER LA CELDA DE ILOC


print("\n -- Selecting a single row with .iloc with an integer -- \n")
x_iloc = dataset.iloc[0]
print(x_iloc)
 
print("\n -- Selecting multiple rows with .iloc with a list of integers -- \n")
print(dataset.iloc[[0, 2]])
 
print("\n -- Selecting multiple rows with .iloc with slice notation -- \n")
x_iloc_slicing = dataset.iloc[:6:1]
print(x_iloc_slicing, type(x_iloc_slicing))

print("\n -- Selecting multiple rows with .iloc and return an ndarray -- \n")
#First position of the list is for the rows and the second one is for the columns, if you want an ndarray instead of a df ad the method values.
x_combination = dataset.iloc[:-1, :-1].values
print(x_combination)
print(type(x_combination))

Para importar el dataset:

dataset=pd.read_csv('salarios.csv')

la documentación de iloc

dataframe.iloc[:,start_col:end_col]

Por si alguien está usando vsc para el curso, de esta manera puedes usar el archivo desde tu directorio.

dataset=pd.read_csv(r’DIRECION DE DONDE TENGAS GUARDADO EL ARCHIVO\salarios.csv’)

En esta ruta viene muy bien explicado iLoc, que sirve para recuperar elementos de un datafreme en pandas
https://www.analyticslane.com/2019/06/21/seleccionar-filas-y-columnas-en-pandas-con-iloc-y-loc/

ya no está el archivo en la carpeta

No puedo colocar el archivo salarios, me dice que no existe

es decir que scikit learn nos ahorra hallar la ecuación de la recta y el learning rate?

#dividimos la información en 80% para entrenar y 20% para hacer test.
X_train, X_test, Y_train, Y_test = train_test_split(x,y, test_size = 0.2, random_state = 0)```

Tengo la misma duda, porque no seria lo mismo poner

x = dataset.iloc[:,:-1].values

que esto:

x = dataset.iloc[:,0].values

Porque aqui no usa simplemente dataset.iloc[:,0].values????

La profesora tuvo un error en el minuto 4:42, ya que esta gurdando la misma columna de los años 2 veces, esto lo puede corregir de 2 maneras:
.
i) De esta manera, se guardan ambas columnas en sus respectivas variables, pero los datos quedan “aplanados”, es decir, los datos se guardan en un simple array.

# Guardamos columnas
# anios de experiencia
x = datasetSalarios.iloc[:,0].values
# salarios
y = datasetSalarios.iloc[:,1].values

ii) De esta manera tambien se guardan ambas columnas en sus respectivas variables y los datos no se “aplanan”.

# Guardamos columnas
# anios de experiencia
x = datasetSalarios.iloc[:,:-1].values
# salarios
y = datasetSalarios.iloc[:,-1:].values

Ambas maneras pueden ser útiles dependiendo que lo que busquemos, así que se los comparto 😄

Tengo dificultades en entender los valores del X_test, X_train, Y_test, Y_train. Alguien podria ayudarme?

Sería bueno que en vez de usar colab, usaras algún entorno como Linux, Mac o Windows, ya que a la hora de instalar paquetes y demás, uno encuentra algunos problemas por solucionar.