Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Código main y probando nuestro código

9/10
Recursos

Aportes 42

Preguntas 17

Ordenar por:

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

Una forma de usar format en python es anteponiendo f antes de las comillas y queda un poco más legible de primeras. Sería así

 print(f'b0 = {b[0]}, b1 = {b[1]}')

una forma alternativa de hacerlo utilizando las herramientas de numpy:

import numpy as np
import matplotlib.pyplot as plt

x = np.array([1,2,3,4,5])
y = np.array([2,3,5,6,5])

#creamos una matriz al reescribir la ecuacion y=b0+b1x , como y = Ap donde A = [[x] , p = [[b1], [b0]]:

A = np.vstack([x, np.ones(len(x))]).T

#aplicamos el metodo de minimos cuadrados de numpy:

b1, b0 = np.linalg.lstsq(A, y, rcond=None)[0]

_ = plt.plot(x, y, 'o', label='Original data', markersize=10)
_ = plt.plot(x, b1*x + b0, 'r', label='Fitted line')
_ = plt.legend()
print("Los valores b0 = {}, b1 ={}".format(b0, b1))
plt.show()

Cuando los profes escriben tan pegadito del borde inferior esto se tapa con el player, sobre todo si uno esta pausando el video varias veces para ir haciendo los códigos.

Les comparto otra forma de imprimir los valores que me gusta más que el .format

print(f'b_0 = {b[0]} \nb_1 = {b[1]}')

Esta genial usar la plataforma de Kaggle para practicar pandas, se las recomiendo. Ejercicios guiados y propuestos muy interesantes

kaggle_pandas

Yo queria saber el siguiente valor de mi gráfica así que hice la siguiente función

def prediccion(x, y, x_pred):
  m_x, m_y = np.mean(x), np.mean(y)

  Sumatoria_xy = np.sum((x-m_x)*(y-m_y))
  Sumatoria_xx = np.sum(x*(x-m_x))

  b_1 = Sumatoria_xy / Sumatoria_xx
  b_0 = m_y - b_1*m_x
  y_pred = b_0 + b_1*x_pred
  return y_pred

donde escribí el mismo dataset

x = np.array([1,2,3,4,5])
y = np.array([2,3,5,6,5])

ya solo llame la función con el valor que queria predecir

prediccion(x, y, 6)

y me resulto 6.9.
y así puedes intentar predecir cualquier otro punto.

Yo hice una función muy sencilla para calcular el valor de Y según un valor de entrada X la cual coloqué encima, en una celda aparte, del código de main. El código de la función es

# Función para predecir un valor de Y según un valor de X
def predecir(x, b):
  return b[0] + b[1]*x

Tiene como parámetros el nuevo valor de X y los valores calculados de b0 y b1. Y se implementa de la siguiente manera:

print(predecir(7, b))

y lo coloqué dentro de la función main y encima de la función para hacer la gráfica.

¿Por qué da el mismo resultado con estas mismas expresiones?

np.sum( (x - m_x)**2)  = np.sum(x*(x-m_x)) # Elevar al cuadrado

Bastante impresionante la clase 😃

Código completo para calcular la ecuación de regresión Lineal y graficar:

función para el cálculo de los coeficientes:

import numpy as np
import matplotlib.pyplot as plt
def estimate_b0_b1(x,y):
    n = np.size(x)
    # Obtenemos promedios de x e y
    m_x, m_y = np.mean(x), np.mean(y)

    # calcular sumatorias de x e y
    suma_x_y = np.sum((x - m_x)*(y-m_y))
    pot_x = np.sum((x-m_x)**2)

    # definicion de valores b0 y b1
    b1 = suma_x_y / pot_x
    b0 = m_y - b1*m_x
    return np.array([b0,b1])

función para graficar:

def plot_regression(x,y,b):
    plt.scatter(x,y, color="green", marker="o", s=30)

    y_pred = b[0] + b[1]*x
    plt.plot(x,y_pred, color="b")

    #etiquetado
    plt.xlabel('x - absisas')
    plt.ylabel('y - ordenadas')

    #dibujar grafica
    plt.show()

main:

def main():
    #observaciones
    x = np.arange(1,6)
    y = np.array([2,3,5,6,5])
    #estimacion de b0 y b1
    b = estimate_b0_b1(x,y)

    print(f'Ecuación de Regresion Lineal: y = {b[1]} + {b[0]}x')

    plot_regression(x,y,b)

if __name__ == '__main__':
  main()

Mucho éxito a todos (:

Aquí el mío, le metí un poco de desmadre a los datos 😄

Le añadí mas datitos… **Que emoción!!! ** 😆😆😆

#Codigo MAIN
def main():
    #DATASET
    x = np.array([1,2,3,4,5])
    y = np.array([2,3,5,6,5])

    #Obtenemos b1 y b2
    b = estimate_b0_b1(x, y)
    print("Los valores b0 = {}, b1 ={}".format(b[0], b[1]))

    #Graficamos nuestra linea de regresion
    plot_regression(x, y, b)

if __name__== "__main__":
    main()

tengo errores aqui
if name==“main”:
main()

no se cual es, porfa su ayuda

le cambie un poco el código para ver como funcionaria con mas datos, pero no entiendo porque no me grafica la linea de la regresion, alguien me ayuda?

Hola, ¿si quisiera agregar un data set de una cantidad de datos relevante(abultada) cual sería la forma más eficaz?

Aqui les dejo mi version del codigo con pandas:

# Start writing code here...
# funcionalidad de sumas reaman y promedios
import pandas as pd
# funcionalidad para graficar
import matplotlib.pyplot as plt
def estimate_b0_b1(df):
    # obtener los promedios 
    m_x, m_y = df['x'].mean(), df['y'].mean()
    
    # calcular la sumatoria de XY y XX
    df['x-mx'] = df['x'] - m_x
    df['y-my'] = df['y'] - m_y
    df['xx'] = df['x']*df['x-mx']
    df['xy'] = df['y-my']*df['x-mx']

    # obtener b_0 y b_1
    b_1= df['xy'].sum() / df['xx'].sum()
    b_0= m_y - m_x*b_1

    return (b_0,b_1)
def plot_regression(x,y,b):
    # graficar los puntos
    plt.scatter(x,y,color="b",marker="o",s=30)

    y_pred = b[0]+b[1]*x
    # graficar la linea de regresion
    plt.plot(x,y_pred, color="k")

    # etiquetado
    plt.xlabel('x-Independiente')
    plt.ylabel('y-Dependiente')

    plt.show()
# codigo main
def main():
    # Dataset
    data = {'x':[1,2,3,4,5], 'y': [2,3,5,6,5]}
    df = pd.DataFrame(data);

    #obtenemos b0 y b1
    b = estimate_b0_b1(df)

    print("Los valores  b0={}, b1={}".format(b[0],b[1]))
    print(f"Los valores b0={b[0]}, b1={b[1]}")

    plot_regression(df['x'],df['y'],b)

if __name__ =="__main__":
  main()

Buena tarde amigos

anexo la grafica incluyendo el punto resaltado de las medias de x y y
![](

Espectacular curso y espectacular docente! Me encantó!

Aqui el proyecto final hecho en deepnote, para quien se anime a hecharle una ojeadita. here

oh oh its magic… que hermoso ver la graficaaa !!!

Realice la ejecución del código adscrito, y no me genera absolutamente nada.
Podrian decirme que error tengo, que no me aparece ningún error?

import numpy as np
import matplotlib.pyplot as plt

def estimate_b0_b1(x, y):

n= np.size(x)

#obtener los promedios de x y y
m_x, m_y = np.mean(x), np.mean(y)
#Calcular la sumatoria de xy y sumatoria de xx
Sumatoria_xy = np.sum((x-m_x)+(y-m_y))
Sumatoria_xx = np.sum(x*(x-m_x))

#coeficientes de regresion
b_1 = sumatoria_xy / sumatoria_xx
b_0 = m_y - b_1*m_x
return(b_0, b_1)

#Funcion de graficado
def plot_regression(x, y, b):
plt.scatter(x, y, color = “g”, marker = “o”,s=30)

y_pred = b[0] + b[1]*x

plt.plot(x, y_pred, color="b")

#etiquetado
plt.xlabel("x-Independiente")
plt.ylabel("y-Dependiente")

plt.show()

#Codigo Main
def main():
#Dataset
x = np.array([1,2,3,4,5])
y = np.array([2,3,5,6,5])
#Obtenemos b1 y b2
b= estimate_b0_b1(x, y)
print(“Los valores b0 = {} y b1 = {}”.format(b[0], b[1]))
#Graficamos nuestra linea de regresión
plot_regression(x, y, b)

if name== “main”:
main()

Cada vez más interesante la carrera de Data Science

Como dato interesante, existe el Coeficiente de correlación de Pearson (R-cuadrado), el cual me permite saber qué tanto se ajusta dicha regresión a mi conjunto de datos. Es de vital importancia hallarlo ya que este tipo de regresión podría no ajustarse correctamente a mi dataset.

que emoción mas grande sentí al ejecutar el código y que se graficara 😄 que buen curso.,

ejecute el código desde Jupyter Notebook y no me esta generando ninguna visualización, tampoco me sale ningún error ¿alguien sabe que puede pasar?

Tengo un error que he tratado y nada

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-70-4bd3a906f305> in <module>()
     16 
     17 # Obtenemos b1 y b2
---> 18 b = estimate_b0_b1(x, y)
     19 print("Los valores b0 = {}, b1 = {}".format(b[0], b[1]))
     20 

NameError: name 'x' is not define```

Cuando calcular la sumatior de XY y sumatorio de XX. esta haciendo una resta ‘X’ q es un vector, y ‘m_x’ que es un numero.

Esta comparacion la hace hyton automaticamente? entiendo q lo q hace es cada valor del vector lo resta con el promedio y luego suma todos los resultados de cada valor del vector. es eso correcto?

Es lo miso q hacer un loop?

    #Calcular la sumatoria de XY y mi sumatoria de XX
    sumatoria_xy = np.sum((x-m_x)*(y-m_y))
    sumatoria_xx = np.sum(x*(x-m_x))

alguien puede compartir su notbook

excelente, aunque me paso un error tonto que casi no encuentro,

Al importar numpy

import numpy as np

y cuando lo use coloque pn, 😃

Cuando algo falla por algún error nuestro aveces queremos volver a ejecutar todo.

Podemos hacerlo por el menu, dando Runtime/Restart and run all.

OJO:

no es lo mismo restar lista menos float de python que numpy array menos numpy float64.

chequen:

#Graficación sólo de los puntos en Python (Normal)
# Instalación matplotlib (linux) :  sudo apt-get install python3-matplotlib

import matplotlib.pyplot as plt    

def main():

    x = [1,2,3,4,5]  
    y = [2,3,5,6,5] 

    plt.scatter(x, y)
    plt.show()

if __name__ == '__main__':
    main()

esta genial cuando termina el código y hace lo mismo que hace en papel

Cómo hago para meter miles de valores en x e y? Por ejemplo quiero poner el precio del peso en x y el precio del peso en y. Sacado de una página/tabla o que sería mejor?


import numpy as np
import matplotlib.pyplot as plt

def estimate_b0_b1(x, y):
  n = np.size(x)
  m_x, m_y = np.mean(x), np.mean(y)

  # Calcular sumatoria de XY y sumatoria de XX
  sumatoria_xy = np.sum((x-m_x) * (y-m_y))
  sumatoria_xx = np.sum(x * (x-m_x))

  # Coeficientes de regresion

  b_1 = sumatoria_xy / sumatoria_xx
  b_0 = m_y - b_1 * m_x

  return (b_0, b_1)

# Funcion de graficado
def plot_regression(x, y, b):
  plt.scatter(x, y, color = 'red', marker = 'o', s = 30)

  y_pred = b[0] + b[1] * x

  plt.plot(x, y_pred, color = 'blue')

  # Etiquetado 
  plt.xlabel('x-Independiente')
  plt.ylabel('y-Dependiente')

  plt.show()

def main():
  x = np.array([1,2,3,4,5])
  y = np.array([2,3,5,6,5])

  b = estimate_b0_b1(x, y)

  print('Los valores b0 = {}, b1 = {}'.format(b[0], b[1]))

  plot_regression(x, y, b)

if __name__ == '__main__':
  main()

Todo bien, solo que no me salían los labels en el gráfico, luego recordé que estoy en Jupiter y con la doble comilla se solucionó 😄