REGRESIÓN LOGÍSTICA: PRESENCIA DE MORDIDA ABIERTA ANTERIOR EN NIÑOS DE 2 A 6 AÑOS DE EDAD.

 

DIPLOMADO EN EN INTELIGENCIA ARTIFICIAL

MODULO IV

          APRENDIZAJE AUTOMATICO CON PYTHON Y ASISTENTES INTELIGENTES

              Ortega Irusta Elsy Nilda

              Este es el chat GPT

              https://www.blogger.com/blog/post/edit/8286612100820228316/7140998716810653040

COMPONENTES DEL PENSAMIENTO COMPUTACIONAL

REGRESIÓN LOGÍSTICA PARA PREDECIR LA PRESENCIA DE MORDIDA ABIERTA ANTERIOR EN NIÑOS DE 2 A 6 AÑOS DE EDAD. 

Aplicando los componentes del pensamiento computacional al problema de regresión logística para predecir la presencia de mordida abierta anterior en niños de 2 a 6 años de edad. Aquí tienes una guía paso a paso:

PASO 1: DESCOMPOSICIÓN DEL PROBLEMA.

Identificación del Problema:

- Problema: Predecir la presencia de mordida abierta anterior en niños de 2 a 6 años.

- Datos de Entrada: Características de los niños (por ejemplo, edad, género, desarrollo dental).

- Datos de Salida: Presencia o ausencia de mordida abierta anterior.

PASO 2: ABSTRACCIÓN.

-Abstracción del Problema:

- Características Relevantes:

  - Edad del niño.

  - Género.

  - Desarrollo dental.

- Objetivo:

  - Crear un modelo que prediga si un niño tiene mordida abierta anterior.

PASO 3: ALGORITMO Y REPRESENTACIÓN DE DATOS

Selección de Algoritmo:

- Utilizaremos regresión logística, ya que es apropiada para problemas de clasificación binaria (presencia/ausencia).

Representación de Datos:

- Conjunto de datos con variables predictoras (edad, género, desarrollo dental) y variable objetivo (presencia de mordida abierta anterior).

PASO 4: DESARROLLO DEL ALGORITMO

Implementación de la Regresión Logística:

- Utilizaremos bibliotecas como scikit-learn en Python para implementar la regresión logística.

Esta es mi interacción con Google Colab

# Importar bibliotecas necesarias

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

# Cargar y preprocesar datos

# ...

# Dividir el conjunto de datos en entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Inicializar y entrenar el modelo

model = LogisticRegression()

model.fit(X_train, y_train)

# Hacer predicciones en el conjunto de prueba

predictions = model.predict(X_test)

# Evaluar el rendimiento del modelo

accuracy = accuracy_score(y_test, predictions)

conf_matrix = confusion_matrix(y_test, predictions)

report = classification_report(y_test, predictions)

# Imprimir resultados

print(f"Accuracy: {accuracy}")

print(f"Confusion Matrix:\n{conf_matrix}")

print(f"Classification Report:\n{report}")

PASO 5: EVALUACIÓN DEL MODELO

Interpretación de Coeficientes:

- Los coeficientes de la regresión logística indican la contribución de cada variable al resultado. Un coeficiente positivo significa que la variable está asociada positivamente con la presencia de mordida abierta, mientras que un coeficiente negativo indica una asociación negativa.

Evaluación del modelo:

- Se utilizan métricas como precisión (accuracy), matriz de confusión y reporte de clasificación para evaluar la eficacia del modelo.

 PASO 6: ITERACIÓN Y MEJORA

- Analizar los resultados y, si es necesario, ajustar el modelo o recopilar más datos para mejorar el rendimiento.

PASO 7: IMPLEMENTACIÓN

- Implementar el modelo en entornos de producción para su uso práctico en la detección temprana de mordida abierta anterior en niños.

Este proceso aplica los conceptos del pensamiento computacional para abordar un problema específico utilizando regresión logística como método de aprendizaje supervisado.

Ejemplo de implementación en Python

Ejemplo de implementación en Python utilizando la biblioteca scikit-learn para la regresión logística en el caso de estudio de mordida abierta anterior en niños de 2 a 6 años:

Esta es mi interacción con Google Colab

# Importar bibliotecas necesarias

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

import pandas as pd

# Supongamos que tienes un conjunto de datos en un DataFrame de pandas llamado 'data'

# Asegúrate de tener las columnas adecuadas, como 'edad', 'genero', 'desarrollo_dental' y 'mordida_abierta'

# Cargar y preprocesar datos (reemplaza esta sección con la carga real de tus datos)

data = pd.read_csv("tu_archivo_de_datos.csv")

X = data[['edad', 'genero', 'desarrollo_dental']]

y = data['mordida_abierta']

# Dividir el conjunto de datos en entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Inicializar y entrenar el modelo de regresión logística

model = LogisticRegression()

model.fit(X_train, y_train)

# Hacer predicciones en el conjunto de prueba

predictions = model.predict(X_test)

# Evaluar el rendimiento del modelo

accuracy = accuracy_score(y_test, predictions)

conf_matrix = confusion_matrix(y_test, predictions)

report = classification_report(y_test, predictions)

# Imprimir resultados

print(f"Accuracy: {accuracy}")

print(f"Confusion Matrix:\n{conf_matrix}")

print(f"Classification Report:\n{report}")

Asegúrate de reemplazar `"tu_archivo_de_datos.csv"` con la ruta correcta de tu conjunto de datos. Este código utiliza un modelo de regresión logística para predecir la presencia de mordida abierta y evalúa su rendimiento utilizando métricas como precisión, matriz de confusión y reporte de clasificación.

Ejemplos de Algoritmos: Regresión lineal

Ejemplo de implementación de un algoritmo de regresión lineal en Python utilizando la biblioteca scikit-learn. Asumiremos un problema de regresión donde intentamos predecir una variable continua basada en varias características. En este caso, podríamos predecir la longitud de los dientes de un niño según su edad y género.

Esta es mi interacción con Google Colab

# Importar bibliotecas necesarias

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

from sklearn.metrics import mean_squared_error, r2_score

import pandas as pd

import matplotlib.pyplot as plt

# Supongamos que tienes un conjunto de datos en un DataFrame de pandas llamado 'data'

# Asegúrate de tener las columnas adecuadas, como 'edad', 'genero' y 'longitud_dientes'

# Cargar y preprocesar datos (reemplaza esta sección con la carga real de tus datos)

data = pd.read_csv("tu_archivo_de_datos_regresion.csv")

X = data[['edad', 'genero']]

y = data['longitud_dientes']

# Dividir el conjunto de datos en entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Inicializar y entrenar el modelo de regresión lineal

model = LinearRegression()

model.fit(X_train, y_train)

# Hacer predicciones en el conjunto de prueba

predictions = model.predict(X_test)

# Evaluar el rendimiento del modelo

mse = mean_squared_error(y_test, predictions)

r2 = r2_score(y_test, predictions)

# Imprimir resultados

print(f"Mean Squared Error: {mse}")

print(f"R-squared: {r2}")

# Visualizar las predicciones

plt.scatter(X_test['edad'], y_test, color='black', label='Actual')

plt.scatter(X_test['edad'], predictions, color='blue', label='Predicción')

plt.xlabel('Edad')

plt.ylabel('Longitud de Dientes')

plt.legend()

plt.show()

Este código utiliza un modelo de regresión lineal para predecir la longitud de los dientes basándose en la edad y el género de los niños. La evaluación del modelo incluye el cálculo del error cuadrático medio (MSE) y el coeficiente de determinación (R-cuadrado). También se muestra un gráfico de dispersión para visualizar las predicciones en comparación con los valores reales.

Ejemplo de implementación de regresión lineal y regresión logística utilizando la biblioteca scikit-learn

Esta es mi interacción con Google Colab

Regresión Lineal:

# Importar bibliotecas necesarias

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

from sklearn.metrics import mean_squared_error

import pandas as pd

import matplotlib.pyplot as plt

# Supongamos que tienes un conjunto de datos en un DataFrame de pandas llamado 'data'

# Asegúrate de tener las columnas adecuadas, como 'X' (características) y 'y' (variable objetivo)

# Cargar y preprocesar datos (reemplaza esta sección con la carga real de tus datos)

data = pd.read_csv("tu_archivo_de_datos_regresion.csv")

X = data[['edad', 'genero']]  # Características

y = data['longitud_dientes']  # Variable objetivo

# Dividir el conjunto de datos en entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Inicializar y entrenar el modelo de regresión lineal

model = LinearRegression()

model.fit(X_train, y_train)

# Hacer predicciones en el conjunto de prueba

predictions = model.predict(X_test)

# Evaluar el rendimiento del modelo

mse = mean_squared_error(y_test, predictions)

# Imprimir resultados

print(f"Mean Squared Error: {mse}")

# Visualizar las predicciones

plt.scatter(X_test['edad'], y_test, color='black', label='Actual')

plt.scatter(X_test['edad'], predictions, color='blue', label='Predicción')

plt.xlabel('Edad')

plt.ylabel('Longitud de Dientes')

plt.legend()

plt.show()

Regresión Logística:

Esta es mi interacción con Google Colab

# Importar bibliotecas necesarias

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

import pandas as pd

# Supongamos que tienes un conjunto de datos en un DataFrame de pandas llamado 'data'

# Asegúrate de tener las columnas adecuadas, como 'X' (características) y 'y' (variable objetivo)

# Cargar y preprocesar datos (reemplaza esta sección con la carga real de tus datos)

data = pd.read_csv("tu_archivo_de_datos_logistica.csv")

X = data[['edad', 'genero', 'desarrollo_dental']]  # Características

y = data['mordida_abierta']  # Variable objetivo

# Dividir el conjunto de datos en entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Inicializar y entrenar el modelo de regresión logística

model = LogisticRegression()

model.fit(X_train, y_train)

# Hacer predicciones en el conjunto de prueba

predictions = model.predict(X_test)

# Evaluar el rendimiento del modelo

accuracy = accuracy_score(y_test, predictions)

conf_matrix = confusion_matrix(y_test, predictions)

report = classification_report(y_test, predictions)

# Imprimir resultados

print(f"Accuracy: {accuracy}")

print(f"Confusion Matrix:\n{conf_matrix}")

print(f"Classification Report:\n{report}")

Asegúrate de reemplazar las rutas de archivo y las columnas con los nombres adecuados según tu conjunto de datos. Estos ejemplos utilizan las funciones proporcionadas por scikit-learn para entrenar, predecir y evaluar modelos de regresión lineal y regresión logística.

Ejemplos ficticios para la regresión lineal y la regresión logística basados en la información que hemos discutido:

Ejemplo Ficticio: Regresión Lineal.

Esta es mi interacción con Google Colab

# Importar bibliotecas necesarias

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

from sklearn.metrics import mean_squared_error

import pandas as pd

import matplotlib.pyplot as plt

# Crear datos ficticios

data = pd.DataFrame({

    'edad': [3, 4, 2, 5, 6, 4, 3, 5],

    'genero': [1, 0, 1, 0, 1, 1, 0, 1],

    'longitud_dientes': [2.5, 3.0, 2.0, 3.5, 4.0, 3.2, 2.8, 4.2]

})

# Separar características (X) y variable objetivo (y)

X = data[['edad', 'genero']]

y = data['longitud_dientes']

# Dividir el conjunto de datos en entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Inicializar y entrenar el modelo de regresión lineal

model = LinearRegression()

model.fit(X_train, y_train)

# Hacer predicciones en el conjunto de prueba

predictions = model.predict(X_test)

# Evaluar el rendimiento del modelo

mse = mean_squared_error(y_test, predictions)

# Imprimir resultados

print(f"Mean Squared Error: {mse}")

# Visualizar las predicciones

plt.scatter(X_test['edad'], y_test, color='black', label='Actual')

plt.scatter(X_test['edad'], predictions, color='blue', label='Predicción')

plt.xlabel('Edad')

plt.ylabel('Longitud de Dientes')

plt.legend()

plt.show()

Ejemplo Ficticio: Regresión Logística.

Esta es mi interacción con Google Colab

# Importar bibliotecas necesarias

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

import pandas as pd

# Crear datos ficticios

data = pd.DataFrame({

    'edad': [3, 4, 2, 5, 6, 4, 3, 5],

    'genero': [1, 0, 1, 0, 1, 1, 0, 1],

    'desarrollo_dental': [0, 1, 0, 1, 1, 0, 1, 1],

    'mordida_abierta': [0, 1, 0, 1, 1, 0, 0, 1]

})

# Separar características (X) y variable objetivo (y)

X = data[['edad', 'genero', 'desarrollo_dental']]

y = data['mordida_abierta']

# Dividir el conjunto de datos en entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Inicializar y entrenar el modelo de regresión logística

model = LogisticRegression()

model.fit(X_train, y_train)

# Hacer predicciones en el conjunto de prueba

predictions = model.predict(X_test)

# Evaluar el rendimiento del modelo

accuracy = accuracy_score(y_test, predictions)

conf_matrix = confusion_matrix(y_test, predictions)

report = classification_report(y_test, predictions)

# Imprimir resultados

print(f"Accuracy: {accuracy}")

print(f"Confusion Matrix:\n{conf_matrix}")

print(f"Classification Report:\n{report}")

Ejemplo ficticio de implementación de un árbol de decisiones utilizando la biblioteca scikit-learn en base a la información proporcionada:

Ejemplo Ficticio: Árbol de Decisiones.

Esta es mi interacción con Google Colab

# Separar características (X) y variable objetivo (y)

X = data[['edad', 'genero', 'desarrollo_dental']]

y = data['mordida_abierta']

# Dividir el conjunto de datos en entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Inicializar y entrenar el modelo de árbol de decisiones

model = DecisionTreeClassifier(random_state=42)

model.fit(X_train, y_train)

# Hacer predicciones en el conjunto de prueba

predictions = model.predict(X_test)

# Evaluar el rendimiento del modelo

accuracy = accuracy_score(y_test, predictions)

conf_matrix = confusion_matrix(y_test, predictions)

report = classification_report(y_test, predictions)

# Imprimir resultados

print(f"Accuracy: {accuracy}")

print(f"Confusion Matrix:\n{conf_matrix}")

print(f"Classification Report:\n{report}")

# Visualizar el árbol de decisiones

tree_rules = export_text(model, feature_names=['edad', 'genero', 'desarrollo_dental'])

print("Árbol de Decisiones:")

print(tree_rules)

Puedes ayudarme con diferentes graficas en base a la información brindada.

Ejemplos de visualizaciones que se pueden utilizar para explorar y presentar tus datos y resultados. Utilizaré las bibliotecas matplotlib y seaborn para crear gráficos. Asegúrate de tener estas bibliotecas instaladas antes de ejecutar los siguientes ejemplos:

Esta es mi interacción con Google Colab

Diagrama de dispersión (Scatter Plot):

import seaborn as sns

import matplotlib.pyplot as plt

# Crear datos ficticios

data = pd.DataFrame({

    'edad': [3, 4, 2, 5, 6, 4, 3, 5],

    'genero': [1, 0, 1, 0, 1, 1, 0, 1],

    'longitud_dientes': [2.5, 3.0, 2.0, 3.5, 4.0, 3.2, 2.8, 4.2]

})

# Diagrama de dispersión

sns.scatterplot(x='edad', y='longitud_dientes', hue='genero', data=data)

plt.title('Diagrama de Dispersión: Longitud de Dientes vs Edad')

plt.show()

Histograma:

Esta es mi interacción con Google Colab

# Histograma de la variable objetivo (longitud de dientes)

sns.histplot(data['longitud_dientes'], bins=10, kde=True)

plt.title('Histograma: Longitud de Dientes')

plt.xlabel('Longitud de Dientes')

plt.show()

Visualización de Modelos:

Esta es mi interacción con Google Colab

Gráfico de Barras para Coeficientes de Regresión:

# Suponiendo que ya tienes un modelo de regresión lineal entrenado llamado 'model'

coefficients = pd.DataFrame({'Característica': X.columns, 'Coeficiente': model.coef_})

# Gráfico de barras

sns.barplot(x='Coeficiente', y='Característica', data=coefficients)

plt.title('Coeficientes de Regresión Lineal')

plt.show()

Representación del Árbol de Decisiones:

Esta es mi interacción con Google Colab

rom sklearn.tree import plot_tree

# Suponiendo que ya tienes un modelo de árbol de decisiones entrenado llamado 'model'

plt.figure(figsize=(12, 8))

plot_tree(model, feature_names=['edad', 'genero', 'desarrollo_dental'], filled=True, rounded=True, class_names=['No Mordida Abierta', 'Mordida Abierta'])

plt.title('Árbol de Decisiones para Mordida Abierta')

plt.show()

Estos son solo algunos ejemplos de visualizaciones que podrías utilizar. Recuerda personalizar los gráficos según tus necesidades específicas y características de los datos.

Conclusiones y reflexiones: Es de gran importancia conocer estas herramientas como el árbol de decisiones (aprendizaje supervisado) y el desarrollo de un modelo de árbol de decisiones para un caso de estudio de mordida abierta anterior en niños de 2 a 6 años y aun utilizando datos ficticios estos no estan fuera de la realidad.