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

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

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

11/34
Recursos

Aportes 68

Preguntas 15

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Hola,
Comparto mi desarrollo del ejercicio,

import pandas as pd
import numpy as np
import random
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression 
from sklearn import preprocessing

# defino los paises en list paises
paises = ['CO','BR','PE','MX']

# llevo cada elemento de paises a que sea convertido a un numero
le1 = preprocessing.LabelEncoder()
paises_encoded = le1.fit_transform(paises)

# de forma aleatoria creo 30 elementos para dataset
paises_dataset = [random.choice(paises_encoded) for i in range(len(dataset))]

# paises codificados y en lista pasados al dataset
dataset['pais'] = paises_dataset

Luego aplicando la regresión lineal

# Dividiendo las columnas en x y y
x = dataset.drop('Salario', axis=1)
y = dataset.iloc[:,1].values

# dividimos nuestro dataset
X_train, X_test, Y_train, Y_test = train_test_split(x, y, test_size = 0.2, random_state = 0)

# Invocamos el modelo y creamos el modelo con .fit
regressor = LinearRegression()
regressor.fit(X_train, Y_train)

# Evaluamos performance
print(regressor.score(X_test, Y_test))

La performance obtenida fue de 0.8058310383374175

Obteniendo los plots

# ploteamos datos de entrenamiento para ver si realmente el 
# modelo lo hizo bien, se entreno como se debe
fig = plt.figure()
viz_train = fig.add_subplot(111, projection='3d')
viz_train.scatter(X_train['Aexperiencia'],X_train['pais'], Y_train, color = 'blue')
viz_train.plot_trisurf(X_train['Aexperiencia'],X_train['pais'], regressor.predict(X_train),color = 'black', alpha = 0.5)
viz_train.set_title('Salario Experiencia y pais')
viz_train.set_xlabel('Experiencia')
viz_train.set_ylabel('Pais')
viz_train.set_zlabel('Salario')
viz_train.set_yticks(range(len(paises_encoded)))
viz_train.set_yticklabels(le1.inverse_transform(paises_encoded))
viz_train.azim=-10
fig.show

Y los resultados para test

# probamos con datos de test
fig = plt.figure()
viz_train = fig.add_subplot(111, projection='3d')
viz_train.scatter(X_test['Aexperiencia'],X_test['pais'], Y_test, color = 'red')
viz_train.plot_trisurf(X_train['Aexperiencia'], X_train['pais'], regressor.predict(X_train),color = 'black', alpha = 0.5)
viz_train.set_title('Salario Experiencia y pais')
viz_train.set_xlabel('Experiencia')
viz_train.set_ylabel('Pais')
viz_train.set_zlabel('Salario')
viz_train.set_yticks(range(len(paises_encoded)))
viz_train.set_yticklabels(le1.inverse_transform(paises_encoded))
viz_train.azim=-10
fig.show

Esas gráficas en realidad no me convencen mucho pues me parece que no es claro la proximidad de los puntos al plano de referencia del modelo. En general parece verse bien aunque eso también se puede confirmar con el score.

Yo viendo las respuestas de todos al reto de la clase:

Les comparto mi manera de resolver el reto.

dataset = pd.read_csv('salarios.csv')
paises = ['VZ','MX','CO','BR','AR','US']
new_column = [paises[np.random.randint(0,len(paises))] for i in range(30) ]
dataset['Pais'] = new_column
dataset['NormPaises'] = pd.factorize(dataset['Pais'])[0]
x = dataset[['Aexperiencia','NormPaises']]
y = dataset['Salario']
X_train, X_test, y_train, y_test = train_test_split(x,y, test_size = 0.6, random_state=0)
regressor.fit(X_train,y_train)
regressor.score(X_test,y_test)

Score obtenido = 0.9380908362446448

Para graficar.

fig = plt.figure(dpi = 150)
ax = fig.add_subplot(111, projection='3d')
ax.scatter(X_train['Aexperiencia'],X_train['NormPaises'],y_train,c='b',marker='s')
ax.scatter(X_train['Aexperiencia'],X_train['NormPaises'],regressor.predict(X_train),c='r',marker='o')
ax.set_xlabel('$Años de experiencia$')
ax.set_ylabel('$Pais Normalizado$')
ax.set_zlabel('$Salario$')

Y este fue mi resultado, se puede notar como los puntos(valores predichos por el modelo) se acercan mucho a los cuadrados(valores del set de entrenamiento).

Cabe resaltar que el reto no está bien planteado. A no ser que más adelante en otro capítulo, expliques el porqué no se puede realizar el reto como lo planteas. Una variable categórica que represente países, no puede representarse de manera ordinal sin una lógica detrás que sustente esto.

Comparto mi solución al reto:

# Modificar dataset agregando columan de país y hacer regresión múltiple
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import random
from sklearn.model_selection import train_test_split #para dividir los datos
from sklearn.linear_model import LinearRegression
from mpl_toolkits.mplot3d import Axes3D

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

#Agregar columna países
paises = ['CO', 'MX', 'PE', 'BR', 'US'] 
dataset['Pais'] = [paises[np.random.randint(0,len(paises))] for i in range(len(dataset)) ]
dataset['IDPais'] = pd.factorize(dataset['Pais'])[0]
print('Dataset inicial\n\n', dataset.head())

#Asigno valores para x,y
x = dataset[['Aexperiencia','IDPais']]
y = dataset['Salario']
X_train, X_test, Y_train, Y_test = train_test_split(x,y, test_size = 0.3, random_state=0)
regressor.fit(X_train, Y_train)
ajuste = regressor.score(X_test,Y_test)
print('\nEl porcentaje de ajuste es: ', ajuste*100, '%\n')

#Grafico de los resultados de entrenamiento
fig = plt.figure(dpi=150)
viz_train = fig.add_subplot(111, projection='3d')
viz_train.scatter(X_train['Aexperiencia'], X_train['IDPais'], Y_train, color = 'blue', label = 'Train')
viz_train.scatter(X_test['Aexperiencia'], X_test['IDPais'], regressor.predict(X_test), color = 'red', label = 'Test')
viz_train.plot_trisurf(X_train['Aexperiencia'],X_train['IDPais'], regressor.predict(X_train),color = 'black', alpha = 0.5)
viz_train.set_title('Salario, Experiencia y País')
viz_train.set_xlabel('Experiencia (años)')
viz_train.set_ylabel('País')
viz_train.set_zlabel('Salario (USD)')
viz_train.set_yticks(range(len(paises)))
viz_train.set_yticklabels(paises)
plt.legend(loc="upper left") 
fig.show

Con el resultado:

Complementando el excelente código que compartió el compañero danielfzc grafiqué los datos en un gráfico 3D interactivo por medio de la biblioteca Plotly. Les dejo el código:

import plotly.express as px
# Gráfica de los datos de entrenamiento.
fig = px.scatter_3d(x=X_train['Aexperiencia'].values, y=X_train['pais'].values, z=Y_train,
                 color = X_train['Aexperiencia'],
                 width = 600, height = 600,
                 labels = {'x': 'Experiencia', 'y': 'Pais', 'z': 'Salario'},
                 title='Relación Salario-Experiencia-Pais')
fig.show()
# Gráfica de los datos de prueba.
fig = px.scatter_3d(x=X_test['Aexperiencia'].values, y=X_test['pais'].values, z=Y_test,
                 color = X_test['Aexperiencia'],
                 width = 600, height = 600,
                 labels = {'x': 'Experiencia', 'y': 'Pais', 'z': 'Salario'},
                 title="Relación Salario-Experiencia-Pais",)
fig.show()

Aqui mi solución, me corrigen por favor!!!


"""# **Entrenamiento con regresion lineal multiple**"""
#Se crea la tercera columna correspondiente al pais
lst = np.random.randint(1,5,size=(30))

#Se cargan los datos y se añade la columna creada anteriormente
data_mlr = pd.read_csv('salarios.csv')
data_mlr.insert(2,'Pais',lst)

#En X se almacenan los datos de Aexperiencia y Pais
X = data_mlr[['Aexperiencia','Pais']].values

# Y contiene los valores de los salarios
Y = data_mlr['Salario'].values

#Se separan los conjuntos de prueba y entrenamiento
x_train,x_test,y_train,y_test = train_test_split(X,Y,test_size=0.2,random_state = 1)

#Se entrena 
reg = LinearRegression()
reg.fit(x_train,y_train)

print(reg.score(x_test,y_test))

#Se hace la prediccion
pred = reg.predict(x_test)

data_pred = pd.DataFrame({'Actual':y_test.flatten(),
                          'Predicted':pred.flatten()})

data_pred


#Grafica de barras que muestra los valores _test y las predicciones
data_pred.plot(kind='bar',figsize=(10,8))
plt.grid(which='major', linestyle='-', linewidth='0.5', color='green')
plt.grid(which='minor', linestyle=':', linewidth='1', color='black')
plt.show()

Respuesta:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

dataset =  pd.read_csv('salarios.csv')
paises = ['AR', 'BO', 'BR','CH', 'PE', 'PY', 'CO', 'MX','US', 'CA']
dataset['id_pais'] = np.random.randint(10, size=30) + 1

x = dataset[['Aexperiencia', 'id_pais']].values
y = dataset['Salario'].values

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

regressor = LinearRegression()
regressor.fit(X_train, Y_train)

fig = plt.figure(figsize=(20,20))
viz_train = fig.add_subplot(projection='3d') 
viz_train.scatter(X_train[:, 0], X_train[:, 1], Y_train, color='blue', s=50, label='Entrenamiento')
viz_train.scatter(X_test[:, 0], X_test[:, 1], regressor.predict(X_test), color='red', s=50, label='Test')
viz_train.plot_trisurf(X_train[:, 0], X_train[:, 1], regressor.predict(X_train), color='yellow', alpha=0.5)
viz_train.set_title('Experiencia Pais Salario', fontsize=20, y=1.05)
viz_train.set_xlabel('Experiencia', fontsize=20, labelpad=10)
viz_train.set_ylabel('Pais', fontsize=20, labelpad=20)
viz_train.set_yticks([1,2,3,4,5,6,7,8,9,10])
viz_train.set_yticklabels(paises, fontsize=20) 
viz_train.set_zlabel('Salario', fontsize=20, labelpad=20)
plt.legend(fontsize=20)
fig.show()
regressor.score(X_test, Y_test)

0.7840834009894776 --> 78 % cada vez que valide

u.u
Varias cosillas:

Cargando la data y generando 1 columna para 3 países (1,2,3). Luego, reordenar las columnas.

dataset1 = pd.read_csv("salarios.csv")
dataset1['Pais']= np.random.randint(1,4, size= 30)
dataset1= dataset1[['Aexperiencia','Pais','Salario']]

Separar datos para el entrenamiento y entrenarlos:

x = dataset1.iloc[:, :-1].values
y = dataset1.iloc[:, 2].values
X_train, X_test, Y_train, Y_test =  train_test_split(x,y,test_size = 0.2, random_state = 0)
regressor= LinearRegression()
regressor.fit(X_train,Y_train)

Aqui el score obtenido para 3 paises aleatorios.

regressor.score(X_test,Y_test)

0.78553895163817

Luego para mostrar los datos del entrenamiento en una grafica tridimensional:

fig = plt.figure(dpi=150)
viz_train = fig.add_subplot(111, projection='3d')
viz_train.scatter(X_train[:,0], X_train[:,1], Y_train, color = 'blue', label = 'Train')
viz_train.scatter(X_test[:,0], X_test[:,1], regressor.predict(X_test), color = 'red', label = 'Test')
viz_train.plot_trisurf(X_train[:,0],X_train[:,1], regressor.predict(X_train),color = 'black', alpha = 0.5)
viz_train.set_title('Salario, Experiencia y País')
viz_train.set_xlabel('Experiencia (años)')
viz_train.set_ylabel('País')
viz_train.set_zlabel('Salario (USD)')
viz_train.set_yticks(range(1,4))
plt.legend(loc="upper left") 
fig.show

Detalles:

  • Pueden separa la gráfica en 2 según se sientan cómodos.
  • En la separación de datos pueden obviar los “.values()” y seleccionar las columnas…

psdta: que algún dios de turno los bendiga.

¡Hola!

Aquí mi solución

from random import choice
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib import cm
from matplotlib.ticker import LinearLocator
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression 

#Lectura de los datos

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

#Adición de nuevo feature en el dataset (0 Colombia , 1 Brasil, 2 EEUU, 3 Alemania )

paises = [choice(np.arange(0,4)) for i in range(30)]  
data.insert(1,'País', paises)

# Extracción de columnas o features

x_1 = data.iloc[:,0]
x_2 = data.iloc[:,1]
y = data. iloc[:,2]

# Split del dataset

X_1_train, X_1_test, X_2_train, X_2_test, Y_train, Y_test = train_test_split(x_1, x_2 , y, test_size = 0.2, random_state = 0)

# Entrenamiento del modelo

regressor = LinearRegression()
X = {'Aexperiencia' : X_1_train, 'País' : X_2_train}
Test = {'Aexperiencia' : X_1_test, 'País' : X_2_test}
X_train = pd.DataFrame(X)
X_test = pd.DataFrame(Test)
regressor.fit(X_train, Y_train)
regressor

# Vizualización de datos de ENTRENAMIENTO vs Plano generado por el modelo 

fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
ax.scatter3D(X_1_train, X_2_train, Y_train, color = 'black')
ax.plot_trisurf(X_1_train, X_2_train, regressor.predict(X_train), color = 'red')
regressor.score(X_test, Y_test)

# Vizualización de datos de TESTEO vs Plano generado por el modelo (Sólo es cambiar el scatter del conjunto de entrenamiento por el de testeo en el anterior bloque y correrlo por aparte)

fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
ax.scatter3D(X_1_test, X_2_test, Y_test, color = 'green')
ax.plot_trisurf(X_1_train, X_2_train, regressor.predict(X_train), color = 'red')
regressor.score(X_test, Y_test)

#Evaluación del modelo en el Conjunto de testeo

regressor.score(X_test, Y_test)

Los resultados que obtuve fueron:

1)El modelo en contraste con los datos de entrenamiento:

2)El modelo en contraste con los datos de testeo:

Y el score del modelo de 0.795 es decir del 79% de efectividad.

!Saludos! 😃

Procedimiento de la Regresión Lineal (Segunda Parte)

  • Asignamos nuestro módulo a una variable:
regressor = LinearRegression() # Este paso es necesario para que el entrenamiento se guarde en esta variable, además es más fácil cambiar de modelo en caso sea necesario
  • Entrenamos nuestro algoritmo (todos los modelos se entrenan así)
regressor.fit(X_train,Y_train) # LinearRegression().fit(X_train,Y_train) funciona pero no se guardan los resultados
  • Ya tenemos entrenado nuestro algoritmo, así podemos extraer los datos del entrenamiento:
    • predictor.coef_ → devuelve el coeficiente (a) de la recta de regresión (ax+b=0)
    • predictor.intercept_ → devuelve el punto de corte con el eje y (b) de la recta de regresión (ax+b=0)
    • predictor.predict(<val>) → devuelve la predicción del dato de entrada val

Bonus: Graficado de Resultados

  • Usaremos la librería matplotlib.pyplot para realizar nuestros gráficos, recordemos que ya la importamos:
import matplotlib.pyplot as plt
  • Podemos darle un alias a la librería (no lo considero necesario):
viz_train = plt #Yo trabajaré solo con plt
  • Para visualizar una nube de puntos usamos el método scatter:
plt.scatter(X_train, Y_train, color='blue')
plt.scatter(X_test, Y_test, color='red')
  • Para visualizar una línea que una los puntos usamos el método plot:
plt.plot(X_train, regressor.predict(X_train), color = 'black') #regressor.predict(X_train) devuelve los valores de predicción para los valores de X_train, graficamos así la línea de regresión
  • Ahora para visualizar el gráfico usamos el método show:
plt.show()

Creo que hacer este ejercicio es un poco raro, porque agregar datos al azar seria como meterle basura o ruido a nuestro sistema, y nos enseñaron que si le metes basura a la maquina, saca basura jajaja, se podria poner una variable como la edad, pero necesitamos datos veridicos para que todo funcione como debe

Después de hacer tu modelo y validarlo, puedes implementarlo con el siguiente código para “predecir” usando tu algoritmo de regresión lineal:

variable = regressor.predict([[valor_nuevo_a_predecir]])
print(variable)

Regresión lineal simple (X=País, Y=Salario)

Bueno, al utilizar datos aleatorios este fue mi resultado:
Se cumple totalmente GIGO 😄 (Garbage In, Garbage Out).

El código

Dependencias:

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

Cargar datos:

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

Datos aleatorios de países con numpy:

paises = ['VZ', 'MX', 'CL', 'CO', 'PE', 'AR', 'UR']
columna = [np.random.randint(0, len(paises)) for _ in range(30)]
data['Pais'] = columna
data.head(5)

Separamos las variables y usamos reshape para que las dimensiones sean las correctas:

x = data.iloc[:, 2].values.reshape(-1, 1) # pais
y = data.iloc[:, 1].values.reshape(-1, 1) # salario

Generamos las variables de entrenamiento y prueba:

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

Creamos el modelo:

regressor = LinearRegression()
regressor.fit(X_train, Y_train)

Visualizamos el algoritmo con datos de entrenamiento:

viz_train = plt
viz_train.scatter(X_train, Y_train, color='red')
viz_train.plot(X_train, regressor.predict(X_train), color='black')

viz_train.title('Salario según País')
viz_train.xlabel('Pais')
viz_train.ylabel('Salario')

Visualizamos algoritmo con datos de prueba:

viz_train = plt
viz_train.scatter(X_test, Y_test, color='red')
viz_train.plot(X_train, regressor.predict(X_train), color='black')

viz_train.title('Salario vs País')
viz_train.xlabel('Pais')
viz_train.ylabel('Salario')

Evaluamos nuestro algoritmo:

regressor.score(X_test, Y_test)

Y el resultado es 0.2439, un pésimo algoritmo jeje, pero es porque los inputs son basura, por ende, los outputs también.

Como los paises fueron elegidos al azar no existe una correlacion entre el pais y el salario, en fin… este fue mi resultado

regressor.score(X_test,Y_test)

-0.01444331827028833

Me parece importante antes de predecir con valores x,y, entender el factor de correlación que existe entre las dos variables ya que si el factor es bajo no podemos hacer una buena predicción, para conocer el factor de correlación entre nuestras columnas, podemos hacer lo siguiente:
crear un data frame con el data set de experiencia vs salarios:

df_experience_vs_salary = pd.DataFrame(dataset_salarios)
df_experience_vs_salary

y después usar el método corr()

correlation_matrix = df_experience_vs_salary.corr()
correlation_matrix

con esto obtenemos un coeficiente de correlación de 0.968738 el cuál es perfecto

Comparto mi reto:

import pandas as pd
import numpy as np
import random
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

data = pd.read_csv('salarios.csv')
paises = ['SV', 'MX', 'CO', 'USA', 'ES']

data['ID_Paises'] = np.random.randint(5, size = 30)
data.to_csv('salarios.csv', index=False)

x = data.iloc[:, [0, 2]].values
y = data.iloc[:, 1].values

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

regressor = LinearRegression()
regressor.fit(X_train, Y_train)

fig = plt.figure()
viz_train = fig.add_subplot(111, projection='3d')
viz_train.scatter(X_train[:, 0], X_train[:, 1], Y_train, color = 'red')
viz_train.plot_trisurf(X_train[:, 0],X_train[:, 1], regressor.predict(X_train),color = 'blue', alpha = 0.5)
viz_train.set_title('Salario Experiencia y pais')
viz_train.set_xlabel('Experiencia')
#viz_train.set_ylabel(paises)
viz_train.set_yticks(range(len(paises)))
viz_train.set_zlabel('Salario')
viz_train.azim=-10
fig.show()

Excelente! no pense que fuera tan sencillo y facil de entender

Para aprender más sobre “Graph Plotting” les recomiendo visitar este enlace, cuenta con ejemplos muy interesantes.

Soy el unico que no puede colocar la planilla de salarios? Me dice que no existe, no lo estoy haciendo bien jeje

Usar un modelo polinomial no me ayudaría a mejorar el error?

Este es el resultado del reto.
Train.

Test

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
paises = ['AR','CH','CO']
dataset = pd.read_csv('salarios.csv')
x = dataset[['Aexperiencia','Pais']]
y = dataset['Salario']
X_train, X_test, Y_train, Y_test = train_test_split(x,y,test_size=0.2, random_state=0)
regressor = LinearRegression()
regressor.fit(X_train, Y_train)

fig = plt.figure(dpi=150)
fig.set_figheight(7.6)
fig.set_figwidth(12.4)
viz_train = fig.add_subplot(111, projection='3d')

viz_train.scatter(X_train['Aexperiencia'], X_train['Pais'], Y_train,  color='blue',label='Train')
viz_train.scatter(X_test['Aexperiencia'], X_test['Pais'], regressor.predict(X_test),  color='black',label='Test')

viz_train.plot_trisurf(X_train['Aexperiencia'],X_train['Pais'], regressor.predict(X_train),color = 'black', alpha = 0.5)
viz_train.set_title('Salario y Experiencia por País')

viz_train.set_xlabel('Experiencia')
viz_train.set_ylabel('País')
viz_train.set_zlabel('Salario')
viz_train.set_yticks(range(len(paises)))
viz_train.set_yticklabels(paises)
plt.legend(loc="upper left")
fig.show![](![](url))

porque me sale el score de 1

paises = ['VZ','MX','CO','BR','AR','US', 'PE']
countries = [random.choice(paises) for i in range(0,30)]
dataset['countries'] = countries
regressor2 = LinearRegression()
regressor2.fit(X_train, Y_train)
regressor2.score(X_test, Y_test)

Resolucion ejercicio:

Defino un array llamado ‘paises’ en el cual agrego varios paises

paises = ['VZ','EC','CO','BR','AR','PE']

Luego mediante numpy determino una variable ‘new_column’ que va a ser una variable de la lista del 0 al 6, que es el largo del array ‘paises’ elegido al azar mediante el uso del metodo random de numpy:

new_column = [paises[np.random.randint(0,len(paises))] for i in range(30) ]

Agrego a midataset que he definido como ‘df’ una nueva columna cuyo nombre sera ‘paises’

df['Pais'] = new_column

Cada variable de la columna’pais’ le asigno un numero a modo de identificador

df['NormPaises'] = pd.factorize(df['Pais'])[0]

determino mis variables X y Y

x = df[['Aexperiencia','NormPaises']]
y = df['Salario'] 

Determino el split de datos para entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(x,y, test_size = 0.63, random_state=0)

hago en el entrenamiento con el metodo fit

regressor.fit(X_train,y_train)

mido el score de la prediccion de mi regresion lineal

regressor.score(X_test,y_test)

luego de mover la variable del tamaño de la muestra de entrenamiento el mayor score que obtuve fue 0.9107518434974747

Son buenos los aportes que han hecho mis companeros, pero quisiera dar la base para de ahi irla mejorando en 2D

Tuve que agregar reshape en una seccion

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import random
from sklearn.model_selection import train_test_split #para dividir los datos
from sklearn.linear_model import LinearRegression

dataset = pd.read_csv(‘Salarios.csv’)

#Asigno valores para x,y
x = dataset[‘Aexperiencia’]
y = dataset[‘Salario’]

#x = dataset.iloc[:, :-1].values # Primer campo (de dos)
#y = dataset.iloc[:, 1].values # Ultimo campo

#ENTRENA
#=======
#entrenamiento 70% de los datos train
#validacion 30% de los datos test
#random_state para definir desde que datos seran de prueba
X_train, X_test, Y_train, Y_test = train_test_split(x,y, test_size = 0.3, random_state=0)

#Reshape
#=============================
X_train = X_train.values.reshape(-1,1)
X_test = X_test.values.reshape(-1,1)

#CREAR MODELO con lo entrenado
#=============================
regressor = LinearRegression()
regressor.fit(X_train, Y_train)

ajuste = regressor.score(X_test,Y_test)
#print(ajuste)

#Grafico
viz=plt
viz.scatter(X_train, Y_train, color=‘blue’)
viz.plot(X_train, regressor.predict(X_train), color=‘black’)
viz.show()

Reto

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression 

countries=["MX", "BO", "CO", "AL", "AR"]
random_countries= np.random.choice(countries, len(dataset), True)
dataset["Paises"]= [0 if i=="MX" else 1 if i=="BO" else 2 if i=="CO" else 3 if i=="AL" else 4 for i in random_countries]

x= dataset[["Paises"]].values.reshape(-1,1)
y= dataset["Salario"].values.reshape(-1,1)

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

regress= LinearRegression()
regress.fit(x_train, y_train)
regress.score(x_test, y_test)

# Output -0.06010774068310254


plt.scatter(x_train, y_train, color="blue")
plt.plot(x_train,regress.predict(x_train), color="black")
plt.title("Salario vs Experiencia")
plt.xlabel("Experiencia")
plt.ylabel("Salario")
plt.show()

Resultado
data2[‘Pais’]= np.random.randint(3, size=30) + 1
x = data2[‘Salario’].values
print(x)
y=data2[‘Pais’].values
print(y)
x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.2, random_state =0)
x_train= x_train.reshape(-1, 1)
regressor2 = LinearRegression()
regressor2.fit(x_train, y_train)

viz_train=plt
viz_train.scatter(x_train,y_train,color=‘blue’)
viz_train.plot(x_train,regressor2.predict(x_train),color=‘black’)
viz_train.title(‘Salario vs Pais’)
viz_train.xlabel(‘Pais’)
viz_train.ylabel(‘Salario’)
viz_train.show()
(https://static.platzi.com/media/user_upload/descargar-6009d8b3-6ef7-4985-a2af-8d04a15503f3.jpg)
x_test= x_test.reshape(-1, 1)
regressor2.score(x_test, y_test)
-0.3920555341663956
No hay relacion entre salario y Pais![descargar.png]

Respecto a la representación de países como números, a esto se le conoce como encoding, y en general se usa el One Hot Encoding
https://machinelearningmastery.com/why-one-hot-encode-data-in-machine-learning/

Muy bueno el reto, sin embargo pienso que falta más explicación para enfrentarse mejor al reto. Con lo compartido por los demás pude guiarme y entender. Gracias.

Y como se puede obtener el resultado de la regresión, es decir cuanto ganará una persona cuando tenga 11 años de experiencia?

Las gráficas del modelo que entrené

Training

Testing

P. D. Este curso está buenísimo.

Obtuve este resultado

import matplotlib.pyplot as plt
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

def main():
    dataset = pd.read_csv('./dataset/salarios_proof.csv')
    x = dataset.iloc[:,1].values
    x = x.reshape(-1,1)
    y = dataset.iloc[:,:-1].values


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

    regressor= LinearRegression()
    regressor.fit(X_train, Y_train)

    viz_train = plt
    viz_train.scatter(X_train, Y_train, color = 'blue')
    viz_train.plot(X_train, regressor.predict(X_train), color = 'black')
    viz_train.title('SALARIO VS PAIS')
    viz_train.xlabel('Pais')
    viz_train.ylabel('Salario')
    plt.show()

    print((regressor.score(X_test, Y_test))*100, '%')
    # 1= ECUADOR
    # 2 = PERU
    # 3= EEUU

if __name__ == '__main__':
    main()

.fit es la clave para entrenar

  • toma datos
  • divide
  • entrena con .fit

entrena con .fit suena a comercial , jajaja, está para una playera 😎

Para resolver el reto es necesario usar regresión lineal múltiple???

Si bien es cierto que podemos buscar mejorar el desempeño de nuestro modelo, tampoco sería correcto querer llevarlo a 100% pues estaríamos sobre ajustando el modelo (overfitting), tal como lo vimos en lecciones anteriores.

<viz_train = plt
viz_train.scatter(X_train,Y_train, color = 'blue')
viz_train.plot(X_train, regressor.predict(X_train), color = 'black')
viz_train.title ('Salario vx Experiencia')
viz_train.xlabel ('Experiencia')
viz_train.ylabel ('Salario')
viz_train.show()> 

Comparto mi solución

import pandas as pd
import matplotlib.pyplot as plt
# Importamos nuestro modelo para poder entranar
from sklearn.model_selection import train_test_split
# Importamos el modelo de regresión lineal
from sklearn.linear_model import LinearRegression
from sklearn import linear_model
import random 

# Traemos los datos del CSV anterior
dataset_plus_country = pd.read_csv("../Fundamentos_Practicos_de_Machine_Learning/Archivos/salarios.csv")

# Agreguemos la lista de países
countries = ['Mexico','Colombia','Venezuela','Argentina']

# Como la regresión solo trabaja con valores continuos asignemosle valores a cada país
# Para realizar eso necesitamos el modulo PreProcessing
from sklearn import preprocessing

# La instrucción LabelEncoder() etiqueta los datos con valores entre 0 y n-1; en este caso entre 0 y 3
country_encoder = preprocessing.LabelEncoder()

# .fit transform() coloca el codificador de etiquetas y las devuelve ya codificadas
country_continous = country_encoder.fit_transform(countries) 

# Le agregamos aleatoriamente un país a cada persona de la lista
random_countries_list = [ random.choice(country_continous) for i in range(len(dataset_plus_country)) ]

# Lo agregamos al dataset
dataset_plus_country['Pais'] = random_countries_list

# Elegimos la variable X
x = dataset_plus_country[ ['Aexperiencia','Pais'] ]
# En Y guardamos los valores de los salarios
y = dataset_plus_country.iloc[:, 1].values

# Vamos a dividir los datos de entrenamiento y los datos de prueba
X_train, X_test, Y_train, Y_test = train_test_split(x, y, test_size = 0.2, random_state = 0)

regression = LinearRegression()
regression.fit(X_train, Y_train)
regression.score(X_test, Y_test)

Graficamos:

import plotly.express as px
import plotly.graph_objects as go
fig = px.scatter_3d(title = 'País y Años de experiencia vs Salario')

fig.add_trace(go.Scatter3d(name= ("Datos de entrenamiento"), x= X_train['Aexperiencia'].values, y= X_train['Pais'].values
                           , z=Y_train, mode='markers', marker=dict(size=5)) )

fig.add_trace(go.Scatter3d(name= ("Predicciones"), x= X_test['Aexperiencia'].values, y= X_test['Pais'].values, z=Y_test,
                           mode='markers',marker=dict(size=6)) )


fig.show()

Para los que saben inglés (y pueden entender a alguien con acento de India), aquí les comparto un video donde explican MUY BIEN la regresión lineal multivariable con Python:
https://www.youtube.com/watch?v=5rvnlZWzox8

El archivo que esta en los enlaces esta mal al final para hacer las pruebas

viz_train = plt viz_train.scatter(X_test, Y_test, color = 'red') viz_train.plot(X_train, regressor.predict(X_train), color='black') viz_train.title('Salario VS Experiencia (Prueba)') viz_train.xlabel('Experiencia') viz_train.ylabel('Salario') viz_test.show()

cordial saludo. tengo un problema con el archivo salarios no me sirve me da error alguin me pueen ayudar

De esta manera obtuve mucha más dispersión en los datos con un score de -0.76; cabe decir que generé enteros aleatorios de 0 a 6 para declarar diferentes lenguajes de programación

#Paises

# 1 = COL
# 2 = MEX
# 3 = CAD
# 4 = USA
# 5 = GER
# 6 = AUS

#Lenguajes

# 1 = Python
# 2 = JAVA
# 3 = Javascript
# 4 = Ruby
# 5 = PHP
# 6 = C#

data = {'Experiencia': dataset.Aexperiencia, 
        'Salario': dataset.Salario, 
        'Pais': np.random.randint(6, size=30),
        'lenguaje': np.random.randint(6, size=30)}

df = pd.DataFrame(data)
df

a = df.iloc[:,3: :1].values
b = df.iloc[:, 1].values

X_train, X_test, Y_train, Y_test = train_test_split(a, b, test_size=0.2, random_state = 0)
regressor = LinearRegression()
regressor.fit(X_train, Y_train)

regressor.score(X_test, Y_test)

viz_train=plt
viz_train.scatter(X_train, Y_train, color='Blue')
viz_train.plot(X_train, regressor.predict(X_train), color = 'black')
viz_train.title('Salario vs Experiencia')
viz_train.xlabel('Experiencia')
viz_train.ylabel('Salario')
viz_train.show

viz_train=plt
viz_train.scatter(X_test, Y_test, color='red')
viz_train.plot(X_test, regressor.predict(X_test), color = 'black')
viz_train.title('Salario vs Experiencia')
viz_train.xlabel('Experiencia')
viz_train.ylabel('Salario')
viz_train.show

Con este cambio obtuve menos dispersión, por lo que intuyo que es según lo generado, una variable más representativa; sin embargo pues la generación de números fue aleatoria y es normal que no se ajusten a una tendencia lineal; por cierto tuve problemas para definir las variables (x,y) con la función iloc[]

#Paises

# 1 = COL
# 2 = MEX
# 3 = CAD
# 4 = USA
# 5 = GER
# 6 = AUS

#Lenguajes

# 1 = Python
# 2 = JAVA
# 3 = Javascript
# 4 = Ruby
# 5 = PHP
# 6 = C#

data = {'Experiencia': dataset.Aexperiencia, 
        'Salario': dataset.Salario, 
        'Pais': np.random.randint(6, size=30),
        'lenguaje': np.random.randint(6, size=30)}

df = pd.DataFrame(data)
df

a = df.iloc[:,3: :1].values
b = df.iloc[:, 1].values

X_train, X_test, Y_train, Y_test = train_test_split(a, b, test_size=0.2, random_state = 0)
regressor = LinearRegression()
regressor.fit(X_train, Y_train)

regressor.score(X_test, Y_test)

viz_train=plt
viz_train.scatter(X_train, Y_train, color='Blue')
viz_train.plot(X_train, regressor.predict(X_train), color = 'black')
viz_train.title('Salario vs Experiencia')
viz_train.xlabel('Experiencia')
viz_train.ylabel('Salario')
viz_train.show

viz_train=plt
viz_train.scatter(X_test, Y_test, color='red')
viz_train.plot(X_test, regressor.predict(X_test), color = 'black')
viz_train.title('Salario vs Experiencia')
viz_train.xlabel('Experiencia')
viz_train.ylabel('Salario')
viz_train.show

- Con el set de datos disponible debemos saber quién será la variable x y la y.
- Se divide el dataset en cada variable:
x = dataset.iloc[:,:-1].values
y = dataset.iloc[:,1].values
- Para aplicar muestras a nuestro modelo y que el aprenda hay que decidir que porcentajes serán para entrenamiento y para test:
#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)

El siguiente ´codigo: regressor.fit(X_train, Y_train), obtiene la ecuación de la recta de la regresión lineal, verdad?

Ingrese una columna con el ranking de stackOverflow, con valores sin relación con los datos de salarios.

#reto
originalData = pd.read_csv('salarios.csv')
dataset = originalData
d = np.arange(0,300,10)
d = d[::-1]
columnNew = {'stackOverflow rank' : d}
columnDataframe = pd.DataFrame(columnNew)
dataset.insert(2,'stackOverflow rank',s)
print(columnDataframe.head())
print(dataset.head())```
# Adding country column
# Col = 0, Mex = 1, Chi = 2, Arg = 3
df['Country'] = np.random.randint(0, 4, df.shape[0])
df.head()

col = df[df['Country'] == 0]
col.head()

x = col.iloc[:, :-2].values
y = col.iloc[:, 1].values
x_train, x_test, y_train, y_test = train_test_split(x,y, test_size= 0.2, random_state=0)
regr.fit(x_train, y_train)


plotter = plt
plotter.scatter(x_train, y_train, color='green')
plotter.plot(x_train, regr.predict(x_train), color='black')
plotter.title('Salary vs Exp (COL)')
plotter.xlabel('Exp')
plotter.ylabel('Salary')

# plot our test data

plotter = plt
plotter.scatter(x_test, y_test, color='green')
plotter.plot(x_train, regr.predict(x_train), color='black')
plotter.title('Salary vs Exp')
plotter.xlabel('Exp')
plotter.ylabel('Salary')

# Accuracy of our model
regr.score(x_test, y_test)

Mi reto

import pandas as pd1
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
dataset = pd1.read_csv(’/content/salarios_pais1.csv’)
dataset.head(10)
dataset.shape
Reg_lin = LinearRegression()
Reg_lin.fit(X_train, Y_train)

viz_train = plt
viz_train.scatter(X_train, Y_train, color = ‘green’)
viz_train.plot(X_train, Reg_lin.predict(X_train), color = ‘black’)
viz_train.title(‘Salario VS Pais (Entrenamiento)’)
viz_train.xlabel(‘Pais’)
viz_train.ylabel(‘Salario’)
viz_train.show()

Reto:

data = {'Experiencia': salariosDataset.Aexperiencia, 
        'Pais': np.random.randint(6, size=30),
        'lenguaje': np.random.randint(6, size=30),
        'Salario': salariosDataset.Salario}

df = pd.DataFrame(data)
df

a = df.iloc[ :,0:3 ].values
a2 = df.iloc[ :,0:3 ]
b = df.iloc[:, 3].values

print(a2)

X_train2, X_test2, Y_train2, Y_test2 = train_test_split(a, b, test_size=0.2, random_state = 0)
print(X_train2)
regressor2 = LinearRegression()
regressor2.fit(X_train2, Y_train2)

print('Prediction:')
print( regressor2.predict( [[10,   4,   0 ]] ) )

print('Score:')
print(regressor2.score(X_test2, Y_test2))

El problema es que a pesar de uqe hace la predicción, no sé como hacer la gráfica con 3 variables independientes y una dependiente

Tendría que hacer 3 gráficas por separado por cada variable??

Dato curioso, cuando hacemos la regresion con los datos en orden, nos da un score de 78%, pero cuando haces la regresion con datos distribuidos aleatoriamente da un 87%, un crecimiento del 9% solo con aleatorizar la distribucion de los datos

En el minuto 5:12 (segundo plot) pienso que hubo un error porque estaria comparando datos de test con datos de entrenamiento, lo que se debe cambiar es:

viz_train.plot(X_test, regressor.predict(X_test), …)

Asi esta bien porque estamos comparando los labels de test con los labels predichos por el modelo.

alguien me ayuda en como hacer una regresion lineal multiple sin usar libreria?..agradeceria mucho ese dato, donde puedo ver el codigo o algo para hacer ese tipo de regresion sin usar libreria

matplotlib.pyplot.scatter()
Scatter plots are used to observe relationship between variables and uses dots to represent the relationship between them. The scatter() method in the matplotlib library is used to draw a scatter plot. Scatter plots are widely used to represent relation among variables and how change in one affects the other.
Syntax
The syntax for scatter() method is given below:

matplotlib.pyplot.scatter(x_axis_data, y_axis_data, s=None, c=None, marker=None, cmap=None, vmin=None, vmax=None, alpha=None, linewidths=None, edgecolors=None)

The scatter() method takes in the following parameters:

  1. x_axis_data- An array containing x-axis data
  2. y_axis_data- An array containing y-axis data
  3. s- marker size (can be scalar or array of size equal to size of x or y)
  4. c- color of sequence of colors for markers
  5. marker- marker style
  6. cmap- cmap name
  7. linewidths- width of marker border
  8. edgecolor- marker border color
  9. alpha- blending value, between 0 (transparent) and 1 (opaque)
  10. Except x_axis_data and y_axis_data all other parameters are optional and their default value is None. Below are the scatter plot examples with various parameters.

Fuente: https://www.geeksforgeeks.org/matplotlib-pyplot-scatter-in-python/

Intente añadir pais pero me dice que no tienen el mismo tamaño ademas pense si debo asignarle un valor o ID numerico a cada pais para que pueda funcionar?

dataset_1 = pd.read_csv('/content/salarios2.csv')
x = dataset_1.iloc[:, :-1].values
y = dataset_1.iloc[:, 1].values
X_train, X_test, Y_train, Y_test = train_test_split(x,y,test_size =0.3, random_state = 0)
regressor = LinearRegression()
regressor.fit(X_train, Y_train)
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)
viz_train = plt
viz_train.scatter(X_train, Y_train, Color = 'blue')
viz_train.plot(X_train, regressor.predict(X_train), Color = 'black')
viz_train.title('Salario Vs Pais')
viz_train.xlabel('Pais')
viz_train.ylabel('Salario')
viz_train.show()

El problema de muchos de los ejercicios que realizan los compañeros, es que ponen al pais no como una variable real, sino como un dato mas a la grafica, ya que no estan entrenando a la IA con esa variable y cuando sacan los datos de entrenamiento y test, tampoco lo tienen en cuenta, tipo hacen el .fit() solo con “x” e “y”, sin contar Z que deberian de ser los paises. y la funcion que usamos para hacer la division de datos no funciona para 3D, seria genial que nos dieran esas herramientas jajaja

Para el caso de la regresión lineal simple, por curiosidad busqué los coeficientes de la recta con regression.coef_ y regression.intercept_ y quise probar la función a ver si reproducia los datos del dataset.
Estos fueron los resultados:

Lo que quiere decir que existe un porcentaje de error entre el valor predicho por el modelo y el valor real del 8.24%

paises = ['Mex','Arg','Ven','USA','Bra','Col']
dataset['Pais'] = [np.random.randint(0, len(paises)) for i in range(len(dataset))] 
dataset.head()

Mi solución al reto:


import pandas as pd 
import numpy as np 
import random as rd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

def _countrys():
    country = { 1:'COL',
                2:'MEX',
                3:'ARG',
                4:'RUS'}
    contry = np.array([[rd.choice([1,2,3,4]) for i in range(30)]])
    return contry

def model_salary_vs_countrys():
    dataset = pd.read_csv('./salarios_dataset.csv') # load dataser
    feature = np.reshape(_countrys(), (30,1)) # converting list 1D to 2D
    target = dataset['Salario'].values           # split target variable
    x_train, x_test, y_train, y_test = train_test_split(feature, target, test_size=0.2, random_state=0) # split testing set and training set
    regressor = LinearRegression()
    regressor.fit(x_train, y_train)
    gaph(x_train, y_train, 'r', 'y', x_train, regressor)
    print(regressor.score(x_test, y_test)) # output : 0.786243  this is model accuracy 

def gaph(x, y, c1, c2, x_train, regressor):
    plt.scatter(x, y, color=c1)
    plt.plot(x_train, regressor.predict(x_train), color=c2)
    # .predict -> show prediccition information
    plt.title("Salary vs Experience")
    plt.xlabel("Feature: Experience")
    plt.ylabel("Target: Salary ")
    plt.show()


Hola a todos,
Comparto mi solución al reto, si me pueden corregir sería genial, gracias.

<h3>Creación de países</h3>
rand_30 = np.random.randint(0,100,size=30)
country = list()
for r in rand_30: 
  if 30 <= r < 70:
    country.append(1)
  elif r >= 70:
    country.append(2)
  else:
    country.append(0)
country_df = pd.DataFrame(data=country, columns=['Pais'])
dataset = dataset.join(country_df)
<h3>Entrenamiento</h3>
x = dataset.iloc[:, [0, 2]].values
y = dataset.iloc[:, 1].values
X_train, X_test, Y_train, Y_test = train_test_split(x, y, test_size = 0.2, random_state = 0)
regressor = LinearRegression()
regressor.fit(X_train, Y_train)
regressor.score(X_test, Y_test)
<h3>Graficación de entrenamiento</h3>
from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure()
viz_train = fig.add_subplot(111, projection='3d')
viz_train.scatter3D(X_train[:, 0], X_train[:, 1], Y_train, cmap='Greens');
viz_train.plot_trisurf(X_train[:, 0], X_train[:, 1], regressor.predict(X_train), color='red', alpha=0.4);
viz_train.azim=50
viz_train.elev=0
fig.show()
<h3>Graficación de test</h3>
fig = plt.figure()
viz_train = fig.add_subplot(111, projection='3d')
viz_train.scatter3D(X_test[:, 0], X_test[:, 1], Y_test, cmap='Greens');
viz_train.plot_trisurf(X_train[:, 0], X_train[:, 1], regressor.predict(X_train), color='red', alpha=0.4);
viz_train.azim=50
viz_train.elev=0

Al final obtuve un score de 0.8017150 porque los valores de los paises se asignan aleatoriamente

#Dict de paises
PAISES = {
    'CO':0,
    'MX':1,
    'PE':2,
    'AR':3
}

#Valores para cada pais
pa = []
for i in range(len(dataset)):
  j = np.random.randint(0,len(PAISES))
  pa.append(j)

#Nuevo Dataset
data2 = { 'Salario': dataset.Salario, 
        'Aexperiencia': dataset.Aexperiencia, 
        'Pais': pa}
df2 = pd.DataFrame(data2)
df2

x2 = df2[['Aexperiencia',	'Pais']]
y2 = df2[['Salario']]
X2_train, X2_test, y2_train, y2_test = train_test_split(x2, y2, test_size = 0.2, random_state = 0)

regressor2 = LinearRegression()
regressor2.fit(X2_train,y2_train)
regressor2.score(X2_test, y2_test)

Comparto el reto para este modulo:
import pandas as pd
import matplotlib.pyplot as plt from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
dataset = pd.read_csv(’/salarios_pais.csv’)
x = dataset.iloc[:, :-2].values
y = dataset.iloc[:, 2].values
X_train, X_test, Y_train, Y_test = train_test_split(x, y, test_size = 0.2, random_state = 0)
regresion = LinearRegression()
regresion.fit(X_train, Y_train)
viz_train = plt
viz_train.scatter(X_train, Y_train, color=‘green’)
viz_train.plot(X_train, regresion.predict(X_train), color = ‘black’)
viz_train.xlabel (‘Pais’)
viz_train.ylabel (‘Salario’)
viz_train = plt
viz_train.scatter(X_train, Y_train, color = ‘green’)
viz_train.plot(X_train, regresion.predict(X_train), color = ‘black’)
viz_train.title(‘Pais vs Salario’)
viz_train.xlabel(‘Pais’)
viz_train.ylabel(‘salario’)
viz_train.show ()

<h1>dataset [‘pais’]=[ 3,4,1,0,…] de esta manera pudiera meterlos manualmente los 30 renglones</h1> <h1>Pero mejor agregar la libreria numpy para tener números al azar</h1> <h1>np.random.randint(0,4) Me regresa un numero entero entre 0 y 4</h1>

dataset[‘pais’]= [np.random.randint(0,4) for i in range(len(dataset))]

#todos las renglones , de la columna 2 (Salario)
y=dataset.iloc[:,1].values
#todos los renglones , La columna Aexperiencia col = 0 y Pais col = 2
x=dataset.iloc[:,[0,2]].values

#Realizo el entrenamiento
X_train, X_test, Y_train, Y_test = train_test_split(x,y,test_size= 0.2, random_state =0)

regressor = LinearRegression()
regressor.fit(X_train,Y_train)

Yo usé estados en lugar de país, simplemente porque me pareció con más sentido!