No tienes acceso a esta clase

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

Regresión Logística: Fórmula y Aplicación en Python

4/17
Recursos

¿Cómo funciona la fórmula de la regresión logística?

La regresión logística es un algoritmo crucial para la clasificación de datos, permitiéndonos predecir la probabilidad de un evento binario, como "sí" o "no", "verdadero" o "falso", "positivo" o "negativo". Para lograrlo, utilizamos la función sigmoide. Esta función, representada por la fórmula ( P = \frac{1}{1 + e^{-\zeta}} ), convierte cualquier valor en una probabilidad comprendida entre 0 y 1. Pero, ¿cómo se lleva a cabo este proceso y cuál es la base matemática detrás de esta operación?

¿Qué es la función sigmoide?

La función sigmoide es una función matemática que transforma cualquier valor real en un valor comprendido entre 0 y 1, adquiriendo una forma de "S" al graficarse. Esta función es particularmente útil en regresión logística, pues nos permite trabajar con probabilidades:

import numpy as np
import matplotlib.pyplot as plt

# Definir una función sigmoide
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

# Crear un rango de datos entre -10 y 10
z = np.linspace(-10, 10, 100)

# Calcular la función sigmoide
sigmoid_values = sigmoid(z)

# Graficar la función
plt.plot(z, sigmoid_values)
plt.title('Función Sigmoide')
plt.xlabel('z')
plt.ylabel('Sigmoid(z)')
plt.grid(True)
plt.show()

Al aplicar la función sigmoide, cualquier dato recibido, sin importar su magnitud, se transformará en un valor entre 0 y 1, ideal para representar probabilidades y hacer predicciones.

¿Cómo los "odds" y los "log odds" contribuyen a la regresión logística?

Un concepto fundamental en regresión logística es el de los "odds", que expresan la probabilidad del éxito de un evento sobre la probabilidad de su fracaso. Por ejemplo, si tenemos una probabilidad de éxito de 80%, los "odds" serían:

[ \text{odds} = \frac{0.80}{1 - 0.80} = 4 ]

Los "log odds" se emplean para manejar mejor los infinitos, ya que al aplicar el logaritmo natural a los "odds", toda la información se centra alrededor del cero, permitiendo a los algoritmos procesar estos valores de forma más efectiva:

[ \text{log odds} = \ln(\text{odds}) ]

¿Cuál es la relación entre la regresión lineal y la regresión logística?

La regresión logística se basa en las mismas premisas que la regresión lineal, aunque con un objetivo diferente: predecir una probabilidad en lugar de un valor continuo. Utilizamos una fórmula similar a la de la regresión lineal:

[ \beta_0 + \beta_1 \cdot x ]

Aquí, (\beta_0) representa el intercepto y (\beta_1) la pendiente. En regresión logística, este modelo lineal se introduce en la función sigmoide para obtener probabilidades.

Para ilustrar cómo estas piezas se integran, veamos cómo se transforma la fórmula de la regresión lineal en una fórmula de regresión logística:

[ P = \frac{e^{\beta_0 + \beta_1 \cdot x}}{1 + e^{\beta_0 + \beta_1 \cdot x}} ]

¿Por qué es útil la regresión logística?

La regresión logística permite abordar problemas de clasificación binaria de manera eficiente y precisa. Al convertir valores continuos en probabilidades, facilita la toma de decisiones basada en datos. Esta capacidad de asignar una probabilidad a cada caso nos permite clasificar con certeza eventos como un diagnóstico médico, la aprobación de un crédito, o el resultado de un partido deportivo.

A medida que amplíes tus conocimientos en machine learning, descubrirás que la regresión logística es solo la punta del iceberg. Existen numerosos algoritmos y métodos para abordar problemas de clasificación y predicción. Sin embargo, entender las bases de la regresión logística te brindará una ventaja significativa en el mundo del análisis de datos. ¡Sigue explorando y construyendo habilidades valiosas en este campo!

Aportes 25

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Los “odds” (en español, “cuotas” o “probabilidades”) son una forma de expresar la probabilidad de que ocurra un evento. En particular, los “odds” representan la relación entre la probabilidad de que ocurra un evento y la probabilidad de que no ocurra.

Por ejemplo, si la probabilidad de que un equipo de fútbol gane un partido es del 60%, entonces la probabilidad de que pierda es del 40%. En términos de “odds”, la probabilidad de ganar se puede expresar como 3 a 2, lo que significa que por cada 2 veces que pierde el equipo, gana 3 veces. De manera similar, la probabilidad de perder se puede expresar como 2 a 3, lo que significa que por cada 3 veces que gana el equipo, pierde 2 veces.

Los “odds” se utilizan comúnmente en las apuestas y en los juegos de azar, donde se usan para determinar las ganancias potenciales de una apuesta. En la estadística, los “odds” se utilizan en la regresión logística para modelar la relación entre las variables independientes y la variable dependiente binaria.

Justo esta descomposición le hizo falta al curso de Regresión Lineal.

Entender el “Por que”, más allá del “como”.


Me duele el cerebro, pero voy entendiendo de a poco. 🦾

x es la variable independiente.

x = np.arange(-10, 10, 0.5)
# y = 1/(1+np.exp(-x))


from scipy.special import expit

y = expit(x)

fig1=px.line(x=x, y=y)
fig1.update_xaxes(showgrid=True, gridwidth=1, gridcolor='red', range=[int(x.min()), int(x.max())])
fig1.update_yaxes(showgrid=True, gridwidth=1, gridcolor='red',
        scaleanchor="y",
        scaleratio=1,
    )
fig1.show()
<import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-10, 10, 100)
y = 1 / (1 + np.exp(-x))
plt.plot(x, y)  # Use plt.plot to create the plot
plt.show()
> 
### Odds Imagina que estás apostando en un juego. Los "odds" o probabilidades a favor de un evento representan la relación entre la probabilidad de que el evento suceda y la probabilidad de que no suceda. Por ejemplo, si en un juego la probabilidad de ganar es de 1 a 4, significa que por cada 1 vez que ganes, se espera perder 4 veces. Si lo expresamos como probabilidad, donde la probabilidad de ganar es *P* y la de perder es 1−P, los "odds" se calculan como P/1-P​. ### Log Odds Los "log odds" o logaritmo de los odds es simplemente tomar el logaritmo natural de los odds. Esta transformación es útil porque convierte una escala que va de 0 a infinito (odds) en una que va de menos infinito a infinito, lo que facilita el manejo matemático, especialmente en la regresión. ### Relación entre Regresión Logística y Lineal La regresión lineal y la regresión logística son similares en el sentido de que ambas intentan encontrar una relación entre una o más variables independientes (X) y una variable dependiente (Y). La diferencia clave radica en cómo tratan la variable dependiente. * **Regresión Lineal:** Se usa cuando la variable dependiente es continua. La relación se modela directamente como una combinación lineal de las variables independientes. Es decir, intenta predecir el valor exacto de *Y* basado en *X*. * **Regresión Logística:** Se usa cuando la variable dependiente es categórica (por ejemplo, sí/no, 0/1). En lugar de modelar esta variable directamente, la regresión logística modela los "log odds" de la probabilidad de que la variable dependiente sea 1 (o "sí"). Esto se hace para asegurarse de que la salida del modelo esté entre 0 y 1 y se pueda interpretar como una probabilidad. Matemáticamente, transforma la combinación lineal de las variables independientes usando la función logística (o sigmoide), lo que garantiza que el resultado sea una probabilidad. En resumen, mientras que la regresión lineal puede predecir cualquier valor dentro de un rango continuo, la regresión logística se utiliza para predecir la probabilidad de que ocurra un evento específico, convirtiendo una entrada lineal en una probabilidad usando los "log odds".

Aquí que pasa cuando pones un signo mal!

Graficar la función sigmoide

import random
from math import exp


import matplotlib.pyplot as plt


def sigmoid(x):
    return ( 1 ) / ( 1 + exp( -x ) )


def main():
    x = []
    y = []

    for _ in range(200):
        num = random.randint(-10, 10)
        x.append(num)
        y.append(sigmoid(num))

    plt.plot(x, y, 'bo')


if __name__ == "__main__":
    main()
```js y= 1/(1+np.exp(-np.log(0.8/0.2))) print(y) log =-np.log(0.8/0.2) print(log) exp = -np.exp(log) print(exp) print(1/(1.25)) print(1/(1-exp)) ```
Me encantó el reto. Me sirvió para terminar de entender la función sigmoide y me viene genial porque justo estoy estudiando el número "e": ```python import numpy as np import matplotlib.pyplot as plt def sigmoide_form(min_val, max_val, num_data): x = np.linspace(min_val, max_val, num_data) sigmoide = 1 / (1 + np.exp(-x)) return x, sigmoide num_data = np.random.randint(50, 101) x, sigmoide = sigmoide_form(-10, 10, num_data) plt.figure(figsize=(10, 6)) plt.axhline(y=0, color='black', linestyle='--') plt.axhline(y=1, color='black', linestyle='--') plt.axvline(x=0, color='black', linestyle='--') plt.plot(x, sigmoide, color='orange') plt.title(f'Sigmoid Curve ({num_data} points)') plt.xlabel('X Values') plt.ylabel('Sigmoid Values') plt.grid(True) plt.show() ``` ![](https://static.platzi.com/media/user_upload/image-ceef569b-0cfe-4d1c-a0e5-05ff0a1a8a64.jpg)

Es interesante como se emplea la forma para regresion logistica. Los prfes en mi universidad lo explicaban de una forma tediosa y nada entendible. Ahora si me queda claro como se debe aplicar.

```python import numpy as np import pandas as pd import matplotlib.pyplot as plt x = np.arange(-10, 11, 1) def sigmoid(x): return 1 / (1 + np.exp(-x)) y = sigmoid(x) plt.plot(x, y, label='Sigmoid Function') plt.title('Gráfica de la Función Logística') plt.xlabel('x') plt.ylabel('y') plt.legend() plt.grid(True) plt.show() ```![]() ![]()
Esta clase es excelente!
```python import numpy as np import matplotlib.pyplot as plt x = np.arange(-10, 10, 0.5) y = 1 / (1 + np.exp(-x)) plt.plot(x, y) plt.show() ```![](https://static.platzi.com/media/user_upload/image-599c4e95-1e32-4919-8619-566c7f332beb.jpg)
Nota: Cuando dice "la probabilidad de que el evento sea exitoso es de 4", se refiere al 0.4 (40%). Eso quiere decir que la probabilidad de que el evento sea un fracaso es de 0.6 (60%).
`<`import numpy as npimport matplotlib.pyplot as plt x = np.linspace(-10, 10, 100)y = 1 / (1 + np.exp(-x))plt.plot(x, y)  # Use plt.plot to create the plotplt.show() `>`
def sigmoid(x):
    return 1/(1+np.exp(-x))

num_samples = 100
x = np.linspace(-5, 5, num_samples)
y = sigmoid(x)

# plot
plt.plot(x, y)

Esta clase ha estado muy interesante 📝

¡Qué buena explicación! Solo quiero aportar que mientras el odd ratio sea mayor a 1 es mejor y si es menor a 1 es peor

Crear la función:

import numpy as np

def sigmoid(z):
    return 1.0 / (1.0 + np.exp(-z))

Gráfica de la función:

import matplotlib.pyplot as plt
import seaborn as sns

# Generar valores de x
x = np.linspace(-10, 10, num=1000)

# Calcular los valores de la función sigmoide en x
y = sigmoid(x)

# Graficar la función sigmoide utilizando Seaborn
sns.set_style("whitegrid")
sns.lineplot(x=x, y=y)
plt.title("Función sigmoide")
plt.xlabel("x")
plt.ylabel("y")
plt.show()
x = np.random.randn(30)
y = 1/(1+np.exp(-x))
plt.plot(x, y, 'o');